1 /* Print values for GNU debugger GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 #include "expression.h"
31 #include "breakpoint.h"
34 /* These are just for containing_function_bounds. It might be better
35 to move containing_function_bounds to blockframe.c or thereabouts. */
40 extern int asm_demangle
; /* Whether to demangle syms in asm printouts */
41 extern int addressprint
; /* Whether to print hex addresses in HLL " */
50 /* Last specified output format. */
52 static char last_format
= 'x';
54 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
56 static char last_size
= 'w';
58 /* Default address to examine next. */
60 static CORE_ADDR next_address
;
62 /* Last address examined. */
64 static CORE_ADDR last_examine_address
;
66 /* Contents of last address examined.
67 This is not valid past the end of the `x' command! */
69 static value last_examine_value
;
71 /* Largest offset between a symbolic value and an address, that will be
72 printed as `0x1234 <symbol+offset>'. */
74 static unsigned int max_symbolic_offset
= UINT_MAX
;
76 /* Append the source filename and linenumber of the symbol when
77 printing a symbolic value as `<symbol at filename:linenum>' if set. */
78 static int print_symbol_filename
= 0;
80 /* Number of auto-display expression currently being displayed.
81 So that we can disable it if we get an error or a signal within it.
82 -1 when not doing one. */
84 int current_display_number
;
86 /* Flag to low-level print routines that this value is being printed
87 in an epoch window. We'd like to pass this as a parameter, but
88 every routine would need to take it. Perhaps we can encapsulate
89 this in the I/O stream once we have GNU stdio. */
95 /* Chain link to next auto-display item. */
97 /* Expression to be evaluated and displayed. */
98 struct expression
*exp
;
99 /* Item number of this auto-display item. */
101 /* Display format specified. */
102 struct format_data format
;
103 /* Innermost block required by this expression when evaluated */
105 /* Status of this display (enabled or disabled) */
109 /* Chain of expressions whose values should be displayed
110 automatically each time the program stops. */
112 static struct display
*display_chain
;
114 static int display_number
;
116 /* Prototypes for local functions */
119 delete_display
PARAMS ((int));
122 enable_display
PARAMS ((char *, int));
125 disable_display_command
PARAMS ((char *, int));
128 disassemble_command
PARAMS ((char *, int));
131 containing_function_bounds
PARAMS ((CORE_ADDR
, CORE_ADDR
*, CORE_ADDR
*));
134 printf_command
PARAMS ((char *, int));
137 print_frame_nameless_args
PARAMS ((struct frame_info
*, long, int, int,
141 display_info
PARAMS ((char *, int));
144 do_one_display
PARAMS ((struct display
*));
147 undisplay_command
PARAMS ((char *, int));
150 free_display
PARAMS ((struct display
*));
153 display_command
PARAMS ((char *, int));
156 x_command
PARAMS ((char *, int));
159 address_info
PARAMS ((char *, int));
162 set_command
PARAMS ((char *, int));
165 output_command
PARAMS ((char *, int));
168 call_command
PARAMS ((char *, int));
171 inspect_command
PARAMS ((char *, int));
174 print_command
PARAMS ((char *, int));
177 print_command_1
PARAMS ((char *, int, int));
180 validate_format
PARAMS ((struct format_data
, char *));
183 do_examine
PARAMS ((struct format_data
, CORE_ADDR
));
186 print_formatted
PARAMS ((value
, int, int));
188 static struct format_data
189 decode_format
PARAMS ((char **, int, int));
192 /* Decode a format specification. *STRING_PTR should point to it.
193 OFORMAT and OSIZE are used as defaults for the format and size
194 if none are given in the format specification.
195 If OSIZE is zero, then the size field of the returned value
196 should be set only if a size is explicitly specified by the
198 The structure returned describes all the data
199 found in the specification. In addition, *STRING_PTR is advanced
200 past the specification and past all whitespace following it. */
202 static struct format_data
203 decode_format (string_ptr
, oformat
, osize
)
208 struct format_data val
;
209 register char *p
= *string_ptr
;
215 if (*p
>= '0' && *p
<= '9')
216 val
.count
= atoi (p
);
217 while (*p
>= '0' && *p
<= '9') p
++;
219 /* Now process size or format letters that follow. */
223 if (*p
== 'b' || *p
== 'h' || *p
== 'w' || *p
== 'g')
225 #ifdef CC_HAS_LONG_LONG
232 else if (*p
>= 'a' && *p
<= 'z')
238 #ifndef CC_HAS_LONG_LONG
239 /* Make sure 'g' size is not used on integer types.
240 Well, actually, we can handle hex. */
241 if (val
.size
== 'g' && val
.format
!= 'f' && val
.format
!= 'x')
245 while (*p
== ' ' || *p
== '\t') p
++;
248 /* Set defaults for format and size if not specified. */
249 if (val
.format
== '?')
253 /* Neither has been specified. */
254 val
.format
= oformat
;
258 /* If a size is specified, any format makes a reasonable
259 default except 'i'. */
260 val
.format
= oformat
== 'i' ? 'x' : oformat
;
262 else if (val
.size
== '?')
267 /* Addresses must be words. */
268 val
.size
= osize
? 'w' : osize
;
271 /* Floating point has to be word or giantword. */
272 if (osize
== 'w' || osize
== 'g')
275 /* Default it to giantword if the last used size is not
277 val
.size
= osize
? 'g' : osize
;
280 /* Characters default to one byte. */
281 val
.size
= osize
? 'b' : osize
;
284 /* The default is the size most recently specified. */
291 /* Print value VAL on stdout according to FORMAT, a letter or 0.
292 Do not end with a newline.
293 0 means print VAL according to its own type.
294 SIZE is the letter for the size of datum being printed.
295 This is used to pad hex numbers so they line up. */
298 print_formatted (val
, format
, size
)
303 int len
= TYPE_LENGTH (VALUE_TYPE (val
));
305 if (VALUE_LVAL (val
) == lval_memory
)
306 next_address
= VALUE_ADDRESS (val
) + len
;
311 next_address
= VALUE_ADDRESS (val
)
312 + value_print (value_addr (val
), stdout
, format
, Val_pretty_default
);
316 /* The old comment says
317 "Force output out, print_insn not using _filtered".
318 I'm not completely sure what that means, I suspect most print_insn
319 now do use _filtered, so I guess it's obsolete. */
320 /* We often wrap here if there are long symbolic names. */
322 next_address
= VALUE_ADDRESS (val
)
323 + print_insn (VALUE_ADDRESS (val
), stdout
);
328 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_ARRAY
329 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_STRING
330 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_STRUCT
331 || TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_UNION
332 || VALUE_REPEATED (val
))
333 value_print (val
, stdout
, format
, Val_pretty_default
);
335 print_scalar_formatted (VALUE_CONTENTS (val
), VALUE_TYPE (val
),
336 format
, size
, stdout
);
340 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
341 according to letters FORMAT and SIZE on STREAM.
342 FORMAT may not be zero. Formats s and i are not supported at this level.
344 This is how the elements of an array or structure are printed
348 print_scalar_formatted (valaddr
, type
, format
, size
, stream
)
356 int len
= TYPE_LENGTH (type
);
358 if (len
> sizeof (LONGEST
)
366 /* We can't print it normally, but we can print it in hex.
367 Printing it in the wrong radix is more useful than saying
368 "use /x, you dummy". */
369 /* FIXME: we could also do octal or binary if that was the
371 /* FIXME: we should be using the size field to give us a minimum
372 field width to print. */
373 val_print_type_code_int (type
, valaddr
, stream
);
377 val_long
= unpack_long (type
, valaddr
);
379 /* If value is unsigned, truncate it in case negative. */
382 if (len
== sizeof (char))
383 val_long
&= (1 << 8 * sizeof(char)) - 1;
384 else if (len
== sizeof (short))
385 val_long
&= (1 << 8 * sizeof(short)) - 1;
386 else if (len
== sizeof (long))
387 val_long
&= (unsigned long) - 1;
395 /* no size specified, like in print. Print varying # of digits. */
396 print_longest (stream
, 'x', 1, val_long
);
405 print_longest (stream
, size
, 1, val_long
);
408 error ("Undefined output size \"%c\".", size
);
413 print_longest (stream
, 'd', 1, val_long
);
417 print_longest (stream
, 'u', 0, val_long
);
422 print_longest (stream
, 'o', 1, val_long
);
424 fprintf_filtered (stream
, "0");
428 print_address (unpack_pointer (type
, valaddr
), stream
);
432 value_print (value_from_longest (builtin_type_char
, val_long
), stream
, 0,
437 if (len
== sizeof (float))
438 type
= builtin_type_float
;
439 else if (len
== sizeof (double))
440 type
= builtin_type_double
;
441 print_floating (valaddr
, type
, stream
);
448 /* Binary; 't' stands for "two". */
450 char bits
[8*(sizeof val_long
) + 1];
455 width
= 8*(sizeof val_long
);
472 error ("Undefined output size \"%c\".", size
);
478 bits
[width
] = (val_long
& 1) ? '1' : '0';
483 while (*cp
&& *cp
== '0')
488 fprintf_filtered (stream
, local_binary_format_prefix());
489 fprintf_filtered (stream
, cp
);
490 fprintf_filtered (stream
, local_binary_format_suffix());
495 error ("Undefined output format \"%c\".", format
);
499 /* Specify default address for `x' command.
500 `info lines' uses this. */
503 set_next_address (addr
)
508 /* Make address available to the user as $_. */
509 set_internalvar (lookup_internalvar ("_"),
510 value_from_longest (lookup_pointer_type (builtin_type_void
),
514 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
515 after LEADIN. Print nothing if no symbolic name is found nearby.
516 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
517 or to interpret it as a possible C++ name and convert it back to source
518 form. However note that DO_DEMANGLE can be overridden by the specific
519 settings of the demangle and asm_demangle variables. */
522 print_address_symbolic (addr
, stream
, do_demangle
, leadin
)
528 CORE_ADDR name_location
;
529 register struct symbol
*symbol
;
532 /* First try to find the address in the symbol tables to find
533 static functions. If that doesn't succeed we try the minimal symbol
534 vector for symbols in non-text space.
535 FIXME: Should find a way to get at the static non-text symbols too. */
537 symbol
= find_pc_function (addr
);
540 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
542 name
= SYMBOL_SOURCE_NAME (symbol
);
544 name
= SYMBOL_LINKAGE_NAME (symbol
);
548 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (addr
);
550 /* If nothing comes out, don't print anything symbolic. */
553 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
555 name
= SYMBOL_SOURCE_NAME (msymbol
);
557 name
= SYMBOL_LINKAGE_NAME (msymbol
);
560 /* If the nearest symbol is too far away, don't print anything symbolic. */
562 /* For when CORE_ADDR is larger than unsigned int, we do math in
563 CORE_ADDR. But when we detect unsigned wraparound in the
564 CORE_ADDR math, we ignore this test and print the offset,
565 because addr+max_symbolic_offset has wrapped through the end
566 of the address space back to the beginning, giving bogus comparison. */
567 if (addr
> name_location
+ max_symbolic_offset
568 && name_location
+ max_symbolic_offset
> name_location
)
571 fputs_filtered (leadin
, stream
);
572 fputs_filtered ("<", stream
);
573 fputs_filtered (name
, stream
);
574 if (addr
!= name_location
)
575 fprintf_filtered (stream
, "+%u", (unsigned int)(addr
- name_location
));
577 /* Append source filename and line number if desired. */
578 if (symbol
&& print_symbol_filename
)
580 struct symtab_and_line sal
;
582 sal
= find_pc_line (addr
, 0);
584 fprintf_filtered (stream
, " at %s:%d", sal
.symtab
->filename
, sal
.line
);
586 fputs_filtered (">", stream
);
589 /* Print address ADDR symbolically on STREAM.
590 First print it as a number. Then perhaps print
591 <SYMBOL + OFFSET> after the number. */
594 print_address (addr
, stream
)
598 #ifdef ADDR_BITS_REMOVE
599 fprintf_filtered (stream
, local_hex_format(), ADDR_BITS_REMOVE(addr
));
601 fprintf_filtered (stream
, local_hex_format(), addr
);
603 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
606 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
607 controls whether to print the symbolic name "raw" or demangled.
608 Global setting "addressprint" controls whether to print hex address
612 print_address_demangle (addr
, stream
, do_demangle
)
618 fprintf_filtered (stream
, "0");
619 } else if (addressprint
) {
620 fprintf_filtered (stream
, local_hex_format(), addr
);
621 print_address_symbolic (addr
, stream
, do_demangle
, " ");
623 print_address_symbolic (addr
, stream
, do_demangle
, "");
628 /* Examine data at address ADDR in format FMT.
629 Fetch it from memory and print on stdout. */
632 do_examine (fmt
, addr
)
633 struct format_data fmt
;
636 register char format
= 0;
638 register int count
= 1;
639 struct type
*val_type
;
641 register int maxelts
;
648 /* String or instruction format implies fetch single bytes
649 regardless of the specified size. */
650 if (format
== 's' || format
== 'i')
654 val_type
= builtin_type_char
;
655 else if (size
== 'h')
656 val_type
= builtin_type_short
;
657 else if (size
== 'w')
658 val_type
= builtin_type_long
;
659 else if (size
== 'g')
660 #ifndef CC_HAS_LONG_LONG
661 val_type
= builtin_type_double
;
663 val_type
= builtin_type_long_long
;
671 if (format
== 's' || format
== 'i')
674 /* Print as many objects as specified in COUNT, at most maxelts per line,
675 with the address of the next one at the start of each line. */
679 print_address (next_address
, stdout
);
680 printf_filtered (":");
685 printf_filtered ("\t");
686 /* Note that print_formatted sets next_address for the next
688 last_examine_address
= next_address
;
689 last_examine_value
= value_at (val_type
, next_address
);
690 print_formatted (last_examine_value
, format
, size
);
692 printf_filtered ("\n");
698 validate_format (fmt
, cmdname
)
699 struct format_data fmt
;
703 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
705 error ("Item count other than 1 is meaningless in \"%s\" command.",
707 if (fmt
.format
== 'i' || fmt
.format
== 's')
708 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
709 fmt
.format
, cmdname
);
712 /* Evaluate string EXP as an expression in the current language and
713 print the resulting value. EXP may contain a format specifier as the
714 first argument ("/x myvar" for example, to print myvar in hex).
718 print_command_1 (exp
, inspect
, voidprint
)
723 struct expression
*expr
;
724 register struct cleanup
*old_chain
= 0;
725 register char format
= 0;
727 struct format_data fmt
;
730 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
731 inspect_it
= inspect
;
733 if (exp
&& *exp
== '/')
736 fmt
= decode_format (&exp
, last_format
, 0);
737 validate_format (fmt
, "print");
738 last_format
= format
= fmt
.format
;
749 extern int objectprint
;
751 expr
= parse_expression (exp
);
752 old_chain
= make_cleanup (free_current_contents
, &expr
);
754 val
= evaluate_expression (expr
);
756 /* C++: figure out what type we actually want to print it as. */
757 type
= VALUE_TYPE (val
);
760 && ( TYPE_CODE (type
) == TYPE_CODE_PTR
761 || TYPE_CODE (type
) == TYPE_CODE_REF
)
762 && ( TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
763 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
767 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
771 type
= VALUE_TYPE (val
);
776 val
= access_value_history (0);
778 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
779 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
781 int histindex
= record_latest_value (val
);
784 printf ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
786 if (histindex
>= 0) printf_filtered ("$%d = ", histindex
);
788 print_formatted (val
, format
, fmt
.size
);
789 printf_filtered ("\n");
795 do_cleanups (old_chain
);
796 inspect_it
= 0; /* Reset print routines to normal */
801 print_command (exp
, from_tty
)
805 print_command_1 (exp
, 0, 1);
808 /* Same as print, except in epoch, it gets its own window */
811 inspect_command (exp
, from_tty
)
815 extern int epoch_interface
;
817 print_command_1 (exp
, epoch_interface
, 1);
820 /* Same as print, except it doesn't print void results. */
823 call_command (exp
, from_tty
)
827 print_command_1 (exp
, 0, 0);
832 output_command (exp
, from_tty
)
836 struct expression
*expr
;
837 register struct cleanup
*old_chain
;
838 register char format
= 0;
840 struct format_data fmt
;
842 if (exp
&& *exp
== '/')
845 fmt
= decode_format (&exp
, 0, 0);
846 validate_format (fmt
, "output");
850 expr
= parse_expression (exp
);
851 old_chain
= make_cleanup (free_current_contents
, &expr
);
853 val
= evaluate_expression (expr
);
855 print_formatted (val
, format
, fmt
.size
);
857 do_cleanups (old_chain
);
862 set_command (exp
, from_tty
)
866 struct expression
*expr
= parse_expression (exp
);
867 register struct cleanup
*old_chain
868 = make_cleanup (free_current_contents
, &expr
);
869 evaluate_expression (expr
);
870 do_cleanups (old_chain
);
875 address_info (exp
, from_tty
)
879 register struct symbol
*sym
;
880 register struct minimal_symbol
*msymbol
;
882 register long basereg
;
883 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
884 if exp is a field of `this'. */
887 error ("Argument required.");
889 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
890 &is_a_field_of_this
, (struct symtab
**)NULL
);
893 if (is_a_field_of_this
)
895 printf ("Symbol \"%s\" is a field of the local class variable `this'\n", exp
);
899 msymbol
= lookup_minimal_symbol (exp
, (struct objfile
*) NULL
);
902 printf ("Symbol \"%s\" is at %s in a file compiled without debugging.\n",
903 exp
, local_hex_string(SYMBOL_VALUE_ADDRESS (msymbol
)));
905 error ("No symbol \"%s\" in current context.", exp
);
909 printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym
));
910 val
= SYMBOL_VALUE (sym
);
911 basereg
= SYMBOL_BASEREG (sym
);
913 switch (SYMBOL_CLASS (sym
))
916 case LOC_CONST_BYTES
:
921 printf ("a label at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym
)));
925 printf ("a variable in register %s", reg_names
[val
]);
929 printf ("static storage at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym
)));
933 printf ("an argument in register %s", reg_names
[val
]);
936 case LOC_REGPARM_ADDR
:
937 printf ("address of an argument in register %s", reg_names
[val
]);
941 if (SYMBOL_BASEREG_VALID (sym
))
943 printf ("an argument at offset %ld from register %s",
944 val
, reg_names
[basereg
]);
948 printf ("an argument at offset %ld", val
);
953 if (SYMBOL_BASEREG_VALID (sym
))
955 printf ("an argument at offset %ld from register %s",
956 val
, reg_names
[basereg
]);
960 printf ("an argument at frame offset %ld", val
);
965 if (SYMBOL_BASEREG_VALID (sym
))
967 printf ("a local variable at offset %ld from register %s",
968 val
, reg_names
[basereg
]);
972 printf ("a local variable at frame offset %ld", val
);
977 printf ("a reference argument at offset %ld", val
);
981 printf ("a typedef");
985 printf ("a function at address %s",
986 local_hex_string(BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
989 case LOC_OPTIMIZED_OUT
:
990 printf_filtered ("optimized out");
994 printf ("of unknown (botched) type");
1001 x_command (exp
, from_tty
)
1005 struct expression
*expr
;
1006 struct format_data fmt
;
1007 struct cleanup
*old_chain
;
1010 fmt
.format
= last_format
;
1011 fmt
.size
= last_size
;
1014 if (exp
&& *exp
== '/')
1017 fmt
= decode_format (&exp
, last_format
, last_size
);
1020 /* If we have an expression, evaluate it and use it as the address. */
1022 if (exp
!= 0 && *exp
!= 0)
1024 expr
= parse_expression (exp
);
1025 /* Cause expression not to be there any more
1026 if this command is repeated with Newline.
1027 But don't clobber a user-defined command's definition. */
1030 old_chain
= make_cleanup (free_current_contents
, &expr
);
1031 val
= evaluate_expression (expr
);
1032 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1033 val
= value_ind (val
);
1034 /* In rvalue contexts, such as this, functions are coerced into
1035 pointers to functions. This makes "x/i main" work. */
1036 if (/* last_format == 'i'
1037 && */ TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1038 && VALUE_LVAL (val
) == lval_memory
)
1039 next_address
= VALUE_ADDRESS (val
);
1041 next_address
= value_as_pointer (val
);
1042 do_cleanups (old_chain
);
1045 do_examine (fmt
, next_address
);
1047 /* If the examine succeeds, we remember its size and format for next time. */
1048 last_size
= fmt
.size
;
1049 last_format
= fmt
.format
;
1051 /* Set a couple of internal variables if appropriate. */
1052 if (last_examine_value
)
1054 /* Make last address examined available to the user as $_. Use
1055 the correct pointer type. */
1056 set_internalvar (lookup_internalvar ("_"),
1057 value_from_longest (
1058 lookup_pointer_type (VALUE_TYPE (last_examine_value
)),
1059 (LONGEST
) last_examine_address
));
1061 /* Make contents of last address examined available to the user as $__.*/
1062 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1067 /* Add an expression to the auto-display chain.
1068 Specify the expression. */
1071 display_command (exp
, from_tty
)
1075 struct format_data fmt
;
1076 register struct expression
*expr
;
1077 register struct display
*new;
1088 fmt
= decode_format (&exp
, 0, 0);
1089 if (fmt
.size
&& fmt
.format
== 0)
1091 if (fmt
.format
== 'i' || fmt
.format
== 's')
1101 innermost_block
= 0;
1102 expr
= parse_expression (exp
);
1104 new = (struct display
*) xmalloc (sizeof (struct display
));
1107 new->block
= innermost_block
;
1108 new->next
= display_chain
;
1109 new->number
= ++display_number
;
1111 new->status
= enabled
;
1112 display_chain
= new;
1114 if (from_tty
&& target_has_execution
)
1115 do_one_display (new);
1128 /* Clear out the display_chain.
1129 Done when new symtabs are loaded, since this invalidates
1130 the types stored in many expressions. */
1135 register struct display
*d
;
1137 while ((d
= display_chain
) != NULL
)
1140 display_chain
= d
->next
;
1145 /* Delete the auto-display number NUM. */
1148 delete_display (num
)
1151 register struct display
*d1
, *d
;
1154 error ("No display number %d.", num
);
1156 if (display_chain
->number
== num
)
1159 display_chain
= d1
->next
;
1163 for (d
= display_chain
; ; d
= d
->next
)
1166 error ("No display number %d.", num
);
1167 if (d
->next
->number
== num
)
1177 /* Delete some values from the auto-display chain.
1178 Specify the element numbers. */
1181 undisplay_command (args
, from_tty
)
1185 register char *p
= args
;
1191 if (query ("Delete all auto-display expressions? "))
1200 while (*p1
>= '0' && *p1
<= '9') p1
++;
1201 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1202 error ("Arguments must be display numbers.");
1206 delete_display (num
);
1209 while (*p
== ' ' || *p
== '\t') p
++;
1214 /* Display a single auto-display.
1215 Do nothing if the display cannot be printed in the current context,
1216 or if the display is disabled. */
1222 int within_current_scope
;
1224 if (d
->status
== disabled
)
1228 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1230 within_current_scope
= 1;
1231 if (!within_current_scope
)
1234 current_display_number
= d
->number
;
1236 printf_filtered ("%d: ", d
->number
);
1241 printf_filtered ("x/");
1242 if (d
->format
.count
!= 1)
1243 printf_filtered ("%d", d
->format
.count
);
1244 printf_filtered ("%c", d
->format
.format
);
1245 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1246 printf_filtered ("%c", d
->format
.size
);
1247 printf_filtered (" ");
1248 print_expression (d
->exp
, stdout
);
1249 if (d
->format
.count
!= 1)
1250 printf_filtered ("\n");
1252 printf_filtered (" ");
1254 addr
= value_as_pointer (evaluate_expression (d
->exp
));
1255 if (d
->format
.format
== 'i')
1256 addr
= ADDR_BITS_REMOVE (addr
);
1258 do_examine (d
->format
, addr
);
1262 if (d
->format
.format
)
1263 printf_filtered ("/%c ", d
->format
.format
);
1264 print_expression (d
->exp
, stdout
);
1265 printf_filtered (" = ");
1266 print_formatted (evaluate_expression (d
->exp
),
1267 d
->format
.format
, d
->format
.size
);
1268 printf_filtered ("\n");
1272 current_display_number
= -1;
1275 /* Display all of the values on the auto-display chain which can be
1276 evaluated in the current scope. */
1281 register struct display
*d
;
1283 for (d
= display_chain
; d
; d
= d
->next
)
1287 /* Delete the auto-display which we were in the process of displaying.
1288 This is done when there is an error or a signal. */
1291 disable_display (num
)
1294 register struct display
*d
;
1296 for (d
= display_chain
; d
; d
= d
->next
)
1297 if (d
->number
== num
)
1299 d
->status
= disabled
;
1302 printf ("No display number %d.\n", num
);
1306 disable_current_display ()
1308 if (current_display_number
>= 0)
1310 disable_display (current_display_number
);
1311 fprintf (stderr
, "Disabling display %d to avoid infinite recursion.\n",
1312 current_display_number
);
1314 current_display_number
= -1;
1318 display_info (ignore
, from_tty
)
1322 register struct display
*d
;
1325 printf ("There are no auto-display expressions now.\n");
1327 printf_filtered ("Auto-display expressions now in effect:\n\
1328 Num Enb Expression\n");
1330 for (d
= display_chain
; d
; d
= d
->next
)
1332 printf_filtered ("%d: %c ", d
->number
, "ny"[(int)d
->status
]);
1334 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1336 else if (d
->format
.format
)
1337 printf_filtered ("/%c ", d
->format
.format
);
1338 print_expression (d
->exp
, stdout
);
1339 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1340 printf_filtered (" (cannot be evaluated in the current context)");
1341 printf_filtered ("\n");
1347 enable_display (args
, from_tty
)
1351 register char *p
= args
;
1354 register struct display
*d
;
1358 for (d
= display_chain
; d
; d
= d
->next
)
1359 d
->status
= enabled
;
1365 while (*p1
>= '0' && *p1
<= '9')
1367 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1368 error ("Arguments must be display numbers.");
1372 for (d
= display_chain
; d
; d
= d
->next
)
1373 if (d
->number
== num
)
1375 d
->status
= enabled
;
1378 printf ("No display number %d.\n", num
);
1381 while (*p
== ' ' || *p
== '\t')
1388 disable_display_command (args
, from_tty
)
1392 register char *p
= args
;
1394 register struct display
*d
;
1398 for (d
= display_chain
; d
; d
= d
->next
)
1399 d
->status
= disabled
;
1405 while (*p1
>= '0' && *p1
<= '9')
1407 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1408 error ("Arguments must be display numbers.");
1410 disable_display (atoi (p
));
1413 while (*p
== ' ' || *p
== '\t')
1419 /* Print the value in stack frame FRAME of a variable
1420 specified by a struct symbol. */
1423 print_variable_value (var
, frame
, stream
)
1428 value val
= read_var_value (var
, frame
);
1429 value_print (val
, stream
, 0, Val_pretty_default
);
1432 /* Print the arguments of a stack frame, given the function FUNC
1433 running in that frame (as a symbol), the info on the frame,
1434 and the number of args according to the stack frame (or -1 if unknown). */
1436 /* References here and elsewhere to "number of args according to the
1437 stack frame" appear in all cases to refer to "number of ints of args
1438 according to the stack frame". At least for VAX, i386, isi. */
1441 print_frame_args (func
, fi
, num
, stream
)
1442 struct symbol
*func
;
1443 struct frame_info
*fi
;
1451 register struct symbol
*sym
;
1453 /* Offset of next stack argument beyond the one we have seen that is
1454 at the highest offset.
1455 -1 if we haven't come to a stack argument yet. */
1456 long highest_offset
= -1;
1458 /* Number of ints of arguments that we have printed so far. */
1459 int args_printed
= 0;
1463 b
= SYMBOL_BLOCK_VALUE (func
);
1464 nsyms
= BLOCK_NSYMS (b
);
1467 for (i
= 0; i
< nsyms
; i
++)
1470 sym
= BLOCK_SYM (b
, i
);
1472 /* Keep track of the highest stack argument offset seen, and
1473 skip over any kinds of symbols we don't care about. */
1475 switch (SYMBOL_CLASS (sym
)) {
1479 long current_offset
= SYMBOL_VALUE (sym
);
1481 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1483 /* Compute address of next argument by adding the size of
1484 this argument and rounding to an int boundary. */
1486 = ((current_offset
+ arg_size
+ sizeof (int) - 1)
1487 & ~(sizeof (int) - 1));
1489 /* If this is the highest offset seen yet, set highest_offset. */
1490 if (highest_offset
== -1
1491 || (current_offset
> highest_offset
))
1492 highest_offset
= current_offset
;
1494 /* Add the number of ints we're about to print to args_printed. */
1495 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1498 /* We care about types of symbols, but don't need to keep track of
1499 stack offsets in them. */
1501 case LOC_REGPARM_ADDR
:
1505 /* Other types of symbols we just skip over. */
1510 /* We have to look up the symbol because arguments can have
1511 two entries (one a parameter, one a local) and the one we
1512 want is the local, which lookup_symbol will find for us.
1513 This includes gcc1 (not gcc2) on the sparc when passing a
1514 small structure and gcc2 when the argument type is float
1515 and it is passed as a double and converted to float by
1516 the prologue (in the latter case the type of the LOC_ARG
1517 symbol is double and the type of the LOC_LOCAL symbol is
1518 float). There are also LOC_ARG/LOC_REGISTER pairs which
1519 are not combined in symbol-reading. */
1520 /* But if the parameter name is null, don't try it.
1521 Null parameter names occur on the RS/6000, for traceback tables.
1522 FIXME, should we even print them? */
1524 if (*SYMBOL_NAME (sym
))
1527 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1529 /* Print the current arg. */
1531 fprintf_filtered (stream
, ", ");
1533 fprintf_symbol_filtered (stream
, SYMBOL_SOURCE_NAME (sym
),
1534 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1535 fputs_filtered ("=", stream
);
1537 /* Avoid value_print because it will deref ref parameters. We just
1538 want to print their addresses. Print ??? for args whose address
1539 we do not know. We pass 2 as "recurse" to val_print because our
1540 standard indentation here is 4 spaces, and val_print indents
1541 2 for each recurse. */
1542 val
= read_var_value (sym
, FRAME_INFO_ID (fi
));
1544 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), VALUE_ADDRESS (val
),
1545 stream
, 0, 0, 2, Val_no_prettyprint
);
1547 fputs_filtered ("???", stream
);
1551 /* Don't print nameless args in situations where we don't know
1552 enough about the stack to find them. */
1557 if (highest_offset
== -1)
1558 start
= FRAME_ARGS_SKIP
;
1560 start
= highest_offset
;
1562 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1567 /* Print nameless args on STREAM.
1568 FI is the frameinfo for this frame, START is the offset
1569 of the first nameless arg, and NUM is the number of nameless args to
1570 print. FIRST is nonzero if this is the first argument (not just
1571 the first nameless arg). */
1573 print_frame_nameless_args (fi
, start
, num
, first
, stream
)
1574 struct frame_info
*fi
;
1584 for (i
= 0; i
< num
; i
++)
1587 #ifdef NAMELESS_ARG_VALUE
1588 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1590 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1594 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1598 fprintf_filtered (stream
, ", ");
1600 #ifdef PRINT_NAMELESS_INTEGER
1601 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1603 #ifdef PRINT_TYPELESS_INTEGER
1604 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1606 fprintf_filtered (stream
, "%d", arg_value
);
1607 #endif /* PRINT_TYPELESS_INTEGER */
1608 #endif /* PRINT_NAMELESS_INTEGER */
1610 start
+= sizeof (int);
1616 printf_command (arg
, from_tty
)
1621 register char *s
= arg
;
1625 int allocated_args
= 20;
1628 val_args
= (value
*) xmalloc (allocated_args
* sizeof (value
));
1631 error_no_arg ("format-control string and values to print");
1633 /* Skip white space before format string */
1634 while (*s
== ' ' || *s
== '\t') s
++;
1636 /* A format string should follow, enveloped in double quotes */
1638 error ("Bad format string, missing '\"'.");
1640 /* Parse the format-control string and copy it into the string STRING,
1641 processing some kinds of escape sequence. */
1643 f
= string
= (char *) alloca (strlen (s
) + 1);
1650 error ("Bad format string, non-terminated '\"'.");
1651 /* doesn't return */
1672 /* ??? TODO: handle other escape sequences */
1673 error ("Unrecognized \\ escape character in format string.");
1682 /* Skip over " and following space and comma. */
1685 while (*s
== ' ' || *s
== '\t') s
++;
1687 if (*s
!= ',' && *s
!= 0)
1688 error ("Invalid argument syntax");
1691 while (*s
== ' ' || *s
== '\t') s
++;
1694 /* Now scan the string for %-specs and see what kinds of args they want.
1695 argclass[I] classifies the %-specs so we can give vprintf something
1696 of the right size. */
1698 enum argclass
{int_arg
, string_arg
, double_arg
, long_long_arg
};
1699 enum argclass
*argclass
;
1705 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1712 while (strchr ("0123456789.hlL-+ #", *f
))
1714 if (*f
== 'l' || *f
== 'L')
1719 argclass
[nargs_wanted
++] = string_arg
;
1720 else if (*f
== 'e' || *f
== 'f' || *f
== 'g')
1721 argclass
[nargs_wanted
++] = double_arg
;
1722 else if (lcount
> 1)
1723 argclass
[nargs_wanted
++] = long_long_arg
;
1725 argclass
[nargs_wanted
++] = int_arg
;
1729 /* Now, parse all arguments and evaluate them.
1730 Store the VALUEs in VAL_ARGS. */
1735 if (nargs
== allocated_args
)
1736 val_args
= (value
*) xrealloc ((char *) val_args
,
1737 (allocated_args
*= 2)
1740 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1742 /* If format string wants a float, unchecked-convert the value to
1743 floating point of the same size */
1745 if (argclass
[nargs
] == double_arg
)
1747 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (float))
1748 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1749 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (double))
1750 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1758 if (nargs
!= nargs_wanted
)
1759 error ("Wrong number of arguments for specified format-string");
1761 /* Now lay out an argument-list containing the arguments
1762 as doubles, integers and C pointers. */
1764 arg_bytes
= (char *) alloca (sizeof (double) * nargs
);
1766 for (i
= 0; i
< nargs
; i
++)
1768 if (argclass
[i
] == string_arg
)
1773 tem
= value_as_pointer (val_args
[i
]);
1775 /* This is a %s argument. Find the length of the string. */
1780 read_memory (tem
+ j
, &c
, 1);
1785 /* Copy the string contents into a string inside GDB. */
1786 str
= (char *) alloca (j
+ 1);
1787 read_memory (tem
, str
, j
);
1790 /* Pass address of internal copy as the arg to vprintf. */
1791 *((int *) &arg_bytes
[argindex
]) = (int) str
;
1792 argindex
+= sizeof (int);
1794 else if (VALUE_TYPE (val_args
[i
])->code
== TYPE_CODE_FLT
)
1796 *((double *) &arg_bytes
[argindex
]) = value_as_double (val_args
[i
]);
1797 argindex
+= sizeof (double);
1800 #ifdef CC_HAS_LONG_LONG
1801 if (argclass
[i
] == long_long_arg
)
1803 *(LONGEST
*) &arg_bytes
[argindex
] = value_as_long (val_args
[i
]);
1804 argindex
+= sizeof (LONGEST
);
1809 *((long *) &arg_bytes
[argindex
]) = value_as_long (val_args
[i
]);
1810 argindex
+= sizeof (long);
1815 /* There is not a standard way to make a va_list, so we need
1816 to do various things for different systems. */
1817 #if defined (__INT_VARARGS_H)
1818 /* This is defined by an 88k using gcc1. Do other machines use it? */
1823 list
.__va_stk
= (int *) arg_bytes
;
1824 list
.__va_reg
= (int *) arg_bytes
;
1825 vprintf (string
, list
);
1827 #else /* No __INT_VARARGS_H. */
1829 VPRINTF (string
, arg_bytes
);
1830 #else /* No VPRINTF. */
1831 vprintf (string
, (PTR
) arg_bytes
);
1832 #endif /* No VPRINTF. */
1833 #endif /* No __INT_VARARGS_H. */
1836 /* Helper function for asdump_command. Finds the bounds of a function
1837 for a specified section of text. PC is an address within the
1838 function which you want bounds for; *LOW and *HIGH are set to the
1839 beginning (inclusive) and end (exclusive) of the function. This
1840 function returns 1 on success and 0 on failure. */
1843 containing_function_bounds (pc
, low
, high
)
1844 CORE_ADDR pc
, *low
, *high
;
1848 struct obj_section
*sec
;
1850 if (!find_pc_partial_function (pc
, 0, low
))
1853 sec
= find_pc_section (pc
);
1856 limit
= sec
->endaddr
;
1859 while (scan
< limit
)
1862 if (!find_pc_partial_function (scan
, 0, high
))
1871 /* Dump a specified section of assembly code. With no command line
1872 arguments, this command will dump the assembly code for the
1873 function surrounding the pc value in the selected frame. With one
1874 argument, it will dump the assembly code surrounding that pc value.
1875 Two arguments are interpeted as bounds within which to dump
1880 disassemble_command (arg
, from_tty
)
1884 CORE_ADDR low
, high
;
1890 if (!selected_frame
)
1891 error ("No frame selected.\n");
1893 pc
= get_frame_pc (selected_frame
);
1894 if (!containing_function_bounds (pc
, &low
, &high
))
1895 error ("No function contains pc specified by selected frame.\n");
1897 else if (!(space_index
= (char *) strchr (arg
, ' ')))
1900 pc
= parse_and_eval_address (arg
);
1901 if (!containing_function_bounds (pc
, &low
, &high
))
1902 error ("No function contains specified pc.\n");
1906 /* Two arguments. */
1907 *space_index
= '\0';
1908 low
= parse_and_eval_address (arg
);
1909 high
= parse_and_eval_address (space_index
+ 1);
1912 printf_filtered ("Dump of assembler code ");
1916 find_pc_partial_function (pc
, &name
, 0);
1917 printf_filtered ("for function %s:\n", name
);
1921 printf_filtered ("from %s ", local_hex_string(low
));
1922 printf_filtered ("to %s:\n", local_hex_string(high
));
1925 /* Dump the specified range. */
1926 for (pc
= low
; pc
< high
; )
1929 print_address (pc
, stdout
);
1930 printf_filtered (":\t");
1931 pc
+= print_insn (pc
, stdout
);
1932 printf_filtered ("\n");
1934 printf_filtered ("End of assembler dump.\n");
1940 _initialize_printcmd ()
1942 current_display_number
= -1;
1944 add_info ("address", address_info
,
1945 "Describe where variable VAR is stored.");
1947 add_com ("x", class_vars
, x_command
,
1948 "Examine memory: x/FMT ADDRESS.\n\
1949 ADDRESS is an expression for the memory address to examine.\n\
1950 FMT is a repeat count followed by a format letter and a size letter.\n\
1951 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
1952 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
1953 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
1954 The specified number of objects of the specified size are printed\n\
1955 according to the format.\n\n\
1956 Defaults for format and size letters are those previously used.\n\
1957 Default count is 1. Default address is following last thing printed\n\
1958 with this command or \"print\".");
1960 add_com ("disassemble", class_vars
, disassemble_command
,
1961 "Disassemble a specified section of memory.\n\
1962 Default is the function surrounding the pc of the selected frame.\n\
1963 With a single argument, the function surrounding that address is dumped.\n\
1964 Two arguments are taken as a range of memory to dump.");
1967 add_com ("whereis", class_vars
, whereis_command
,
1968 "Print line number and file of definition of variable.");
1971 add_info ("display", display_info
,
1972 "Expressions to display when program stops, with code numbers.");
1974 add_cmd ("undisplay", class_vars
, undisplay_command
,
1975 "Cancel some expressions to be displayed when program stops.\n\
1976 Arguments are the code numbers of the expressions to stop displaying.\n\
1977 No argument means cancel all automatic-display expressions.\n\
1978 \"delete display\" has the same effect as this command.\n\
1979 Do \"info display\" to see current list of code numbers.",
1982 add_com ("display", class_vars
, display_command
,
1983 "Print value of expression EXP each time the program stops.\n\
1984 /FMT may be used before EXP as in the \"print\" command.\n\
1985 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
1986 as in the \"x\" command, and then EXP is used to get the address to examine\n\
1987 and examining is done as in the \"x\" command.\n\n\
1988 With no argument, display all currently requested auto-display expressions.\n\
1989 Use \"undisplay\" to cancel display requests previously made.");
1991 add_cmd ("display", class_vars
, enable_display
,
1992 "Enable some expressions to be displayed when program stops.\n\
1993 Arguments are the code numbers of the expressions to resume displaying.\n\
1994 No argument means enable all automatic-display expressions.\n\
1995 Do \"info display\" to see current list of code numbers.", &enablelist
);
1997 add_cmd ("display", class_vars
, disable_display_command
,
1998 "Disable some expressions to be displayed when program stops.\n\
1999 Arguments are the code numbers of the expressions to stop displaying.\n\
2000 No argument means disable all automatic-display expressions.\n\
2001 Do \"info display\" to see current list of code numbers.", &disablelist
);
2003 add_cmd ("display", class_vars
, undisplay_command
,
2004 "Cancel some expressions to be displayed when program stops.\n\
2005 Arguments are the code numbers of the expressions to stop displaying.\n\
2006 No argument means cancel all automatic-display expressions.\n\
2007 Do \"info display\" to see current list of code numbers.", &deletelist
);
2009 add_com ("printf", class_vars
, printf_command
,
2010 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2011 This is useful for formatted output in user-defined commands.");
2012 add_com ("output", class_vars
, output_command
,
2013 "Like \"print\" but don't put in value history and don't print newline.\n\
2014 This is useful in user-defined commands.");
2016 add_prefix_cmd ("set", class_vars
, set_command
,
2017 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2018 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2019 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2020 with $), a register (a few standard names starting with $), or an actual\n\
2021 variable in the program being debugged. EXP is any valid expression.\n\
2022 Use \"set variable\" for variables with names identical to set subcommands.\n\
2023 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2024 You can see these environment settings with the \"show\" command.",
2025 &setlist
, "set ", 1, &cmdlist
);
2027 /* "call" is the same as "set", but handy for dbx users to call fns. */
2028 add_com ("call", class_vars
, call_command
,
2029 "Call a function in the program.\n\
2030 The argument is the function name and arguments, in the notation of the\n\
2031 current working language. The result is printed and saved in the value\n\
2032 history, if it is not void.");
2034 add_cmd ("variable", class_vars
, set_command
,
2035 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2036 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2037 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2038 with $), a register (a few standard names starting with $), or an actual\n\
2039 variable in the program being debugged. EXP is any valid expression.\n\
2040 This may usually be abbreviated to simply \"set\".",
2043 add_com ("print", class_vars
, print_command
,
2044 concat ("Print value of expression EXP.\n\
2045 Variables accessible are those of the lexical environment of the selected\n\
2046 stack frame, plus all those whose scope is global or an entire file.\n\
2048 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2049 $$NUM refers to NUM'th value back from the last one.\n\
2050 Names starting with $ refer to registers (with the values they would have\n\
2051 if the program were to return to the stack frame now selected, restoring\n\
2052 all registers saved by frames farther in) or else to debugger\n\
2053 \"convenience\" variables (any such name not a known register).\n\
2054 Use assignment expressions to give values to convenience variables.\n",
2056 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2057 @ is a binary operator for treating consecutive data objects\n\
2058 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2059 element is FOO, whose second element is stored in the space following\n\
2060 where FOO is stored, etc. FOO must be an expression whose value\n\
2061 resides in memory.\n",
2063 EXP may be preceded with /FMT, where FMT is a format letter\n\
2064 but no count or size letter (see \"x\" command).", NULL
));
2065 add_com_alias ("p", "print", class_vars
, 1);
2067 add_com ("inspect", class_vars
, inspect_command
,
2068 "Same as \"print\" command, except that if you are running in the epoch\n\
2069 environment, the value is printed in its own window.");
2072 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2073 (char *)&max_symbolic_offset
,
2074 "Set the largest offset that will be printed in <symbol+1234> form.",
2078 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2079 (char *)&print_symbol_filename
,
2080 "Set printing of source filename and line number with <symbol>.",