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 (size
== 'g' && sizeof (LONGEST
) < 8
361 /* ok, we're going to have to get fancy here. Assumption: a
362 long is four bytes. FIXME. */
363 unsigned long v1
, v2
;
365 v1
= unpack_long (builtin_type_long
, valaddr
);
366 v2
= unpack_long (builtin_type_long
, valaddr
+ 4);
368 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
369 /* Swap the two for printing */
382 fprintf_filtered (stream
, local_hex_format_custom("08x%08"), v1
, v2
);
385 error ("Output size \"g\" unimplemented for format \"%c\".",
391 val_long
= unpack_long (type
, valaddr
);
393 /* If value is unsigned, truncate it in case negative. */
396 if (len
== sizeof (char))
397 val_long
&= (1 << 8 * sizeof(char)) - 1;
398 else if (len
== sizeof (short))
399 val_long
&= (1 << 8 * sizeof(short)) - 1;
400 else if (len
== sizeof (long))
401 val_long
&= (unsigned long) - 1;
409 /* no size specified, like in print. Print varying # of digits. */
410 print_longest (stream
, 'x', 1, val_long
);
419 print_longest (stream
, size
, 1, val_long
);
422 error ("Undefined output size \"%c\".", size
);
427 print_longest (stream
, 'd', 1, val_long
);
431 print_longest (stream
, 'u', 0, val_long
);
436 print_longest (stream
, 'o', 1, val_long
);
438 fprintf_filtered (stream
, "0");
442 print_address (unpack_pointer (type
, valaddr
), stream
);
446 value_print (value_from_longest (builtin_type_char
, val_long
), stream
, 0,
451 if (len
== sizeof (float))
452 type
= builtin_type_float
;
453 else if (len
== sizeof (double))
454 type
= builtin_type_double
;
455 print_floating (valaddr
, type
, stream
);
462 /* Binary; 't' stands for "two". */
464 char bits
[8*(sizeof val_long
) + 1];
469 width
= 8*(sizeof val_long
);
486 error ("Undefined output size \"%c\".", size
);
492 bits
[width
] = (val_long
& 1) ? '1' : '0';
497 while (*cp
&& *cp
== '0')
502 fprintf_filtered (stream
, local_binary_format_prefix());
503 fprintf_filtered (stream
, cp
);
504 fprintf_filtered (stream
, local_binary_format_suffix());
509 error ("Undefined output format \"%c\".", format
);
513 /* Specify default address for `x' command.
514 `info lines' uses this. */
517 set_next_address (addr
)
522 /* Make address available to the user as $_. */
523 set_internalvar (lookup_internalvar ("_"),
524 value_from_longest (lookup_pointer_type (builtin_type_void
),
528 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
529 after LEADIN. Print nothing if no symbolic name is found nearby.
530 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
531 or to interpret it as a possible C++ name and convert it back to source
532 form. However note that DO_DEMANGLE can be overridden by the specific
533 settings of the demangle and asm_demangle variables. */
536 print_address_symbolic (addr
, stream
, do_demangle
, leadin
)
542 CORE_ADDR name_location
;
543 register struct symbol
*symbol
;
546 /* First try to find the address in the symbol tables to find
547 static functions. If that doesn't succeed we try the minimal symbol
548 vector for symbols in non-text space.
549 FIXME: Should find a way to get at the static non-text symbols too. */
551 symbol
= find_pc_function (addr
);
554 name_location
= BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
));
556 name
= SYMBOL_SOURCE_NAME (symbol
);
558 name
= SYMBOL_LINKAGE_NAME (symbol
);
562 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (addr
);
564 /* If nothing comes out, don't print anything symbolic. */
567 name_location
= SYMBOL_VALUE_ADDRESS (msymbol
);
569 name
= SYMBOL_SOURCE_NAME (msymbol
);
571 name
= SYMBOL_LINKAGE_NAME (msymbol
);
574 /* If the nearest symbol is too far away, don't print anything symbolic. */
576 /* For when CORE_ADDR is larger than unsigned int, we do math in
577 CORE_ADDR. But when we detect unsigned wraparound in the
578 CORE_ADDR math, we ignore this test and print the offset,
579 because addr+max_symbolic_offset has wrapped through the end
580 of the address space back to the beginning, giving bogus comparison. */
581 if (addr
> name_location
+ max_symbolic_offset
582 && name_location
+ max_symbolic_offset
> name_location
)
585 fputs_filtered (leadin
, stream
);
586 fputs_filtered ("<", stream
);
587 fputs_filtered (name
, stream
);
588 if (addr
!= name_location
)
589 fprintf_filtered (stream
, "+%u", (unsigned int)(addr
- name_location
));
591 /* Append source filename and line number if desired. */
592 if (symbol
&& print_symbol_filename
)
594 struct symtab_and_line sal
;
596 sal
= find_pc_line (addr
, 0);
598 fprintf_filtered (stream
, " at %s:%d", sal
.symtab
->filename
, sal
.line
);
600 fputs_filtered (">", stream
);
603 /* Print address ADDR symbolically on STREAM.
604 First print it as a number. Then perhaps print
605 <SYMBOL + OFFSET> after the number. */
608 print_address (addr
, stream
)
612 #ifdef ADDR_BITS_REMOVE
613 fprintf_filtered (stream
, local_hex_format(), ADDR_BITS_REMOVE(addr
));
615 fprintf_filtered (stream
, local_hex_format(), addr
);
617 print_address_symbolic (addr
, stream
, asm_demangle
, " ");
620 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
621 controls whether to print the symbolic name "raw" or demangled.
622 Global setting "addressprint" controls whether to print hex address
626 print_address_demangle (addr
, stream
, do_demangle
)
632 fprintf_filtered (stream
, "0");
633 } else if (addressprint
) {
634 fprintf_filtered (stream
, local_hex_format(), addr
);
635 print_address_symbolic (addr
, stream
, do_demangle
, " ");
637 print_address_symbolic (addr
, stream
, do_demangle
, "");
642 /* Examine data at address ADDR in format FMT.
643 Fetch it from memory and print on stdout. */
646 do_examine (fmt
, addr
)
647 struct format_data fmt
;
650 register char format
= 0;
652 register int count
= 1;
653 struct type
*val_type
;
655 register int maxelts
;
662 /* String or instruction format implies fetch single bytes
663 regardless of the specified size. */
664 if (format
== 's' || format
== 'i')
668 val_type
= builtin_type_char
;
669 else if (size
== 'h')
670 val_type
= builtin_type_short
;
671 else if (size
== 'w')
672 val_type
= builtin_type_long
;
673 else if (size
== 'g')
674 #ifndef CC_HAS_LONG_LONG
675 val_type
= builtin_type_double
;
677 val_type
= builtin_type_long_long
;
685 if (format
== 's' || format
== 'i')
688 /* Print as many objects as specified in COUNT, at most maxelts per line,
689 with the address of the next one at the start of each line. */
693 print_address (next_address
, stdout
);
694 printf_filtered (":");
699 printf_filtered ("\t");
700 /* Note that print_formatted sets next_address for the next
702 last_examine_address
= next_address
;
703 last_examine_value
= value_at (val_type
, next_address
);
704 print_formatted (last_examine_value
, format
, size
);
706 printf_filtered ("\n");
712 validate_format (fmt
, cmdname
)
713 struct format_data fmt
;
717 error ("Size letters are meaningless in \"%s\" command.", cmdname
);
719 error ("Item count other than 1 is meaningless in \"%s\" command.",
721 if (fmt
.format
== 'i' || fmt
.format
== 's')
722 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
723 fmt
.format
, cmdname
);
726 /* Evaluate string EXP as an expression in the current language and
727 print the resulting value. EXP may contain a format specifier as the
728 first argument ("/x myvar" for example, to print myvar in hex).
732 print_command_1 (exp
, inspect
, voidprint
)
737 struct expression
*expr
;
738 register struct cleanup
*old_chain
= 0;
739 register char format
= 0;
741 struct format_data fmt
;
744 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
745 inspect_it
= inspect
;
747 if (exp
&& *exp
== '/')
750 fmt
= decode_format (&exp
, last_format
, 0);
751 validate_format (fmt
, "print");
752 last_format
= format
= fmt
.format
;
763 extern int objectprint
;
765 expr
= parse_expression (exp
);
766 old_chain
= make_cleanup (free_current_contents
, &expr
);
768 val
= evaluate_expression (expr
);
770 /* C++: figure out what type we actually want to print it as. */
771 type
= VALUE_TYPE (val
);
774 && ( TYPE_CODE (type
) == TYPE_CODE_PTR
775 || TYPE_CODE (type
) == TYPE_CODE_REF
)
776 && ( TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
777 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_UNION
))
781 v
= value_from_vtable_info (val
, TYPE_TARGET_TYPE (type
));
785 type
= VALUE_TYPE (val
);
790 val
= access_value_history (0);
792 if (voidprint
|| (val
&& VALUE_TYPE (val
) &&
793 TYPE_CODE (VALUE_TYPE (val
)) != TYPE_CODE_VOID
))
795 int histindex
= record_latest_value (val
);
798 printf ("\031(gdb-makebuffer \"%s\" %d '(\"", exp
, histindex
);
800 if (histindex
>= 0) printf_filtered ("$%d = ", histindex
);
802 print_formatted (val
, format
, fmt
.size
);
803 printf_filtered ("\n");
809 do_cleanups (old_chain
);
810 inspect_it
= 0; /* Reset print routines to normal */
815 print_command (exp
, from_tty
)
819 print_command_1 (exp
, 0, 1);
822 /* Same as print, except in epoch, it gets its own window */
825 inspect_command (exp
, from_tty
)
829 extern int epoch_interface
;
831 print_command_1 (exp
, epoch_interface
, 1);
834 /* Same as print, except it doesn't print void results. */
837 call_command (exp
, from_tty
)
841 print_command_1 (exp
, 0, 0);
846 output_command (exp
, from_tty
)
850 struct expression
*expr
;
851 register struct cleanup
*old_chain
;
852 register char format
= 0;
854 struct format_data fmt
;
856 if (exp
&& *exp
== '/')
859 fmt
= decode_format (&exp
, 0, 0);
860 validate_format (fmt
, "output");
864 expr
= parse_expression (exp
);
865 old_chain
= make_cleanup (free_current_contents
, &expr
);
867 val
= evaluate_expression (expr
);
869 print_formatted (val
, format
, fmt
.size
);
871 do_cleanups (old_chain
);
876 set_command (exp
, from_tty
)
880 struct expression
*expr
= parse_expression (exp
);
881 register struct cleanup
*old_chain
882 = make_cleanup (free_current_contents
, &expr
);
883 evaluate_expression (expr
);
884 do_cleanups (old_chain
);
889 address_info (exp
, from_tty
)
893 register struct symbol
*sym
;
894 register struct minimal_symbol
*msymbol
;
896 register long basereg
;
897 int is_a_field_of_this
; /* C++: lookup_symbol sets this to nonzero
898 if exp is a field of `this'. */
901 error ("Argument required.");
903 sym
= lookup_symbol (exp
, get_selected_block (), VAR_NAMESPACE
,
904 &is_a_field_of_this
, (struct symtab
**)NULL
);
907 if (is_a_field_of_this
)
909 printf ("Symbol \"%s\" is a field of the local class variable `this'\n", exp
);
913 msymbol
= lookup_minimal_symbol (exp
, (struct objfile
*) NULL
);
916 printf ("Symbol \"%s\" is at %s in a file compiled without debugging.\n",
917 exp
, local_hex_string(SYMBOL_VALUE_ADDRESS (msymbol
)));
919 error ("No symbol \"%s\" in current context.", exp
);
923 printf ("Symbol \"%s\" is ", SYMBOL_NAME (sym
));
924 val
= SYMBOL_VALUE (sym
);
925 basereg
= SYMBOL_BASEREG (sym
);
927 switch (SYMBOL_CLASS (sym
))
930 case LOC_CONST_BYTES
:
935 printf ("a label at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym
)));
939 printf ("a variable in register %s", reg_names
[val
]);
943 printf ("static storage at address %s", local_hex_string(SYMBOL_VALUE_ADDRESS (sym
)));
947 printf ("an argument in register %s", reg_names
[val
]);
950 case LOC_REGPARM_ADDR
:
951 printf ("address of an argument in register %s", reg_names
[val
]);
955 if (SYMBOL_BASEREG_VALID (sym
))
957 printf ("an argument at offset %ld from register %s",
958 val
, reg_names
[basereg
]);
962 printf ("an argument at offset %ld", val
);
967 if (SYMBOL_BASEREG_VALID (sym
))
969 printf ("an argument at offset %ld from register %s",
970 val
, reg_names
[basereg
]);
974 printf ("an argument at frame offset %ld", val
);
979 if (SYMBOL_BASEREG_VALID (sym
))
981 printf ("a local variable at offset %ld from register %s",
982 val
, reg_names
[basereg
]);
986 printf ("a local variable at frame offset %ld", val
);
991 printf ("a reference argument at offset %ld", val
);
995 printf ("a typedef");
999 printf ("a function at address %s",
1000 local_hex_string(BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
1003 case LOC_OPTIMIZED_OUT
:
1004 printf_filtered ("optimized out");
1008 printf ("of unknown (botched) type");
1015 x_command (exp
, from_tty
)
1019 struct expression
*expr
;
1020 struct format_data fmt
;
1021 struct cleanup
*old_chain
;
1024 fmt
.format
= last_format
;
1025 fmt
.size
= last_size
;
1028 if (exp
&& *exp
== '/')
1031 fmt
= decode_format (&exp
, last_format
, last_size
);
1034 /* If we have an expression, evaluate it and use it as the address. */
1036 if (exp
!= 0 && *exp
!= 0)
1038 expr
= parse_expression (exp
);
1039 /* Cause expression not to be there any more
1040 if this command is repeated with Newline.
1041 But don't clobber a user-defined command's definition. */
1044 old_chain
= make_cleanup (free_current_contents
, &expr
);
1045 val
= evaluate_expression (expr
);
1046 if (TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_REF
)
1047 val
= value_ind (val
);
1048 /* In rvalue contexts, such as this, functions are coerced into
1049 pointers to functions. This makes "x/i main" work. */
1050 if (/* last_format == 'i'
1051 && */ TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_FUNC
1052 && VALUE_LVAL (val
) == lval_memory
)
1053 next_address
= VALUE_ADDRESS (val
);
1055 next_address
= value_as_pointer (val
);
1056 do_cleanups (old_chain
);
1059 do_examine (fmt
, next_address
);
1061 /* If the examine succeeds, we remember its size and format for next time. */
1062 last_size
= fmt
.size
;
1063 last_format
= fmt
.format
;
1065 /* Set a couple of internal variables if appropriate. */
1066 if (last_examine_value
)
1068 /* Make last address examined available to the user as $_. Use
1069 the correct pointer type. */
1070 set_internalvar (lookup_internalvar ("_"),
1071 value_from_longest (
1072 lookup_pointer_type (VALUE_TYPE (last_examine_value
)),
1073 (LONGEST
) last_examine_address
));
1075 /* Make contents of last address examined available to the user as $__.*/
1076 set_internalvar (lookup_internalvar ("__"), last_examine_value
);
1081 /* Add an expression to the auto-display chain.
1082 Specify the expression. */
1085 display_command (exp
, from_tty
)
1089 struct format_data fmt
;
1090 register struct expression
*expr
;
1091 register struct display
*new;
1102 fmt
= decode_format (&exp
, 0, 0);
1103 if (fmt
.size
&& fmt
.format
== 0)
1105 if (fmt
.format
== 'i' || fmt
.format
== 's')
1115 innermost_block
= 0;
1116 expr
= parse_expression (exp
);
1118 new = (struct display
*) xmalloc (sizeof (struct display
));
1121 new->block
= innermost_block
;
1122 new->next
= display_chain
;
1123 new->number
= ++display_number
;
1125 new->status
= enabled
;
1126 display_chain
= new;
1128 if (from_tty
&& target_has_execution
)
1129 do_one_display (new);
1142 /* Clear out the display_chain.
1143 Done when new symtabs are loaded, since this invalidates
1144 the types stored in many expressions. */
1149 register struct display
*d
;
1151 while ((d
= display_chain
) != NULL
)
1154 display_chain
= d
->next
;
1159 /* Delete the auto-display number NUM. */
1162 delete_display (num
)
1165 register struct display
*d1
, *d
;
1168 error ("No display number %d.", num
);
1170 if (display_chain
->number
== num
)
1173 display_chain
= d1
->next
;
1177 for (d
= display_chain
; ; d
= d
->next
)
1180 error ("No display number %d.", num
);
1181 if (d
->next
->number
== num
)
1191 /* Delete some values from the auto-display chain.
1192 Specify the element numbers. */
1195 undisplay_command (args
, from_tty
)
1199 register char *p
= args
;
1205 if (query ("Delete all auto-display expressions? "))
1214 while (*p1
>= '0' && *p1
<= '9') p1
++;
1215 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1216 error ("Arguments must be display numbers.");
1220 delete_display (num
);
1223 while (*p
== ' ' || *p
== '\t') p
++;
1228 /* Display a single auto-display.
1229 Do nothing if the display cannot be printed in the current context,
1230 or if the display is disabled. */
1236 int within_current_scope
;
1238 if (d
->status
== disabled
)
1242 within_current_scope
= contained_in (get_selected_block (), d
->block
);
1244 within_current_scope
= 1;
1245 if (!within_current_scope
)
1248 current_display_number
= d
->number
;
1250 printf_filtered ("%d: ", d
->number
);
1255 printf_filtered ("x/");
1256 if (d
->format
.count
!= 1)
1257 printf_filtered ("%d", d
->format
.count
);
1258 printf_filtered ("%c", d
->format
.format
);
1259 if (d
->format
.format
!= 'i' && d
->format
.format
!= 's')
1260 printf_filtered ("%c", d
->format
.size
);
1261 printf_filtered (" ");
1262 print_expression (d
->exp
, stdout
);
1263 if (d
->format
.count
!= 1)
1264 printf_filtered ("\n");
1266 printf_filtered (" ");
1268 addr
= value_as_pointer (evaluate_expression (d
->exp
));
1269 if (d
->format
.format
== 'i')
1270 addr
= ADDR_BITS_REMOVE (addr
);
1272 do_examine (d
->format
, addr
);
1276 if (d
->format
.format
)
1277 printf_filtered ("/%c ", d
->format
.format
);
1278 print_expression (d
->exp
, stdout
);
1279 printf_filtered (" = ");
1280 print_formatted (evaluate_expression (d
->exp
),
1281 d
->format
.format
, d
->format
.size
);
1282 printf_filtered ("\n");
1286 current_display_number
= -1;
1289 /* Display all of the values on the auto-display chain which can be
1290 evaluated in the current scope. */
1295 register struct display
*d
;
1297 for (d
= display_chain
; d
; d
= d
->next
)
1301 /* Delete the auto-display which we were in the process of displaying.
1302 This is done when there is an error or a signal. */
1305 disable_display (num
)
1308 register struct display
*d
;
1310 for (d
= display_chain
; d
; d
= d
->next
)
1311 if (d
->number
== num
)
1313 d
->status
= disabled
;
1316 printf ("No display number %d.\n", num
);
1320 disable_current_display ()
1322 if (current_display_number
>= 0)
1324 disable_display (current_display_number
);
1325 fprintf (stderr
, "Disabling display %d to avoid infinite recursion.\n",
1326 current_display_number
);
1328 current_display_number
= -1;
1332 display_info (ignore
, from_tty
)
1336 register struct display
*d
;
1339 printf ("There are no auto-display expressions now.\n");
1341 printf_filtered ("Auto-display expressions now in effect:\n\
1342 Num Enb Expression\n");
1344 for (d
= display_chain
; d
; d
= d
->next
)
1346 printf_filtered ("%d: %c ", d
->number
, "ny"[(int)d
->status
]);
1348 printf_filtered ("/%d%c%c ", d
->format
.count
, d
->format
.size
,
1350 else if (d
->format
.format
)
1351 printf_filtered ("/%c ", d
->format
.format
);
1352 print_expression (d
->exp
, stdout
);
1353 if (d
->block
&& !contained_in (get_selected_block (), d
->block
))
1354 printf_filtered (" (cannot be evaluated in the current context)");
1355 printf_filtered ("\n");
1361 enable_display (args
, from_tty
)
1365 register char *p
= args
;
1368 register struct display
*d
;
1372 for (d
= display_chain
; d
; d
= d
->next
)
1373 d
->status
= enabled
;
1379 while (*p1
>= '0' && *p1
<= '9')
1381 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1382 error ("Arguments must be display numbers.");
1386 for (d
= display_chain
; d
; d
= d
->next
)
1387 if (d
->number
== num
)
1389 d
->status
= enabled
;
1392 printf ("No display number %d.\n", num
);
1395 while (*p
== ' ' || *p
== '\t')
1402 disable_display_command (args
, from_tty
)
1406 register char *p
= args
;
1408 register struct display
*d
;
1412 for (d
= display_chain
; d
; d
= d
->next
)
1413 d
->status
= disabled
;
1419 while (*p1
>= '0' && *p1
<= '9')
1421 if (*p1
&& *p1
!= ' ' && *p1
!= '\t')
1422 error ("Arguments must be display numbers.");
1424 disable_display (atoi (p
));
1427 while (*p
== ' ' || *p
== '\t')
1433 /* Print the value in stack frame FRAME of a variable
1434 specified by a struct symbol. */
1437 print_variable_value (var
, frame
, stream
)
1442 value val
= read_var_value (var
, frame
);
1443 value_print (val
, stream
, 0, Val_pretty_default
);
1446 /* Print the arguments of a stack frame, given the function FUNC
1447 running in that frame (as a symbol), the info on the frame,
1448 and the number of args according to the stack frame (or -1 if unknown). */
1450 /* References here and elsewhere to "number of args according to the
1451 stack frame" appear in all cases to refer to "number of ints of args
1452 according to the stack frame". At least for VAX, i386, isi. */
1455 print_frame_args (func
, fi
, num
, stream
)
1456 struct symbol
*func
;
1457 struct frame_info
*fi
;
1465 register struct symbol
*sym
;
1467 /* Offset of next stack argument beyond the one we have seen that is
1468 at the highest offset.
1469 -1 if we haven't come to a stack argument yet. */
1470 long highest_offset
= -1;
1472 /* Number of ints of arguments that we have printed so far. */
1473 int args_printed
= 0;
1477 b
= SYMBOL_BLOCK_VALUE (func
);
1478 nsyms
= BLOCK_NSYMS (b
);
1481 for (i
= 0; i
< nsyms
; i
++)
1484 sym
= BLOCK_SYM (b
, i
);
1486 /* Keep track of the highest stack argument offset seen, and
1487 skip over any kinds of symbols we don't care about. */
1489 switch (SYMBOL_CLASS (sym
)) {
1493 long current_offset
= SYMBOL_VALUE (sym
);
1495 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
1497 /* Compute address of next argument by adding the size of
1498 this argument and rounding to an int boundary. */
1500 = ((current_offset
+ arg_size
+ sizeof (int) - 1)
1501 & ~(sizeof (int) - 1));
1503 /* If this is the highest offset seen yet, set highest_offset. */
1504 if (highest_offset
== -1
1505 || (current_offset
> highest_offset
))
1506 highest_offset
= current_offset
;
1508 /* Add the number of ints we're about to print to args_printed. */
1509 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
1512 /* We care about types of symbols, but don't need to keep track of
1513 stack offsets in them. */
1515 case LOC_REGPARM_ADDR
:
1519 /* Other types of symbols we just skip over. */
1524 /* We have to look up the symbol because arguments can have
1525 two entries (one a parameter, one a local) and the one we
1526 want is the local, which lookup_symbol will find for us.
1527 This includes gcc1 (not gcc2) on the sparc when passing a
1528 small structure and gcc2 when the argument type is float
1529 and it is passed as a double and converted to float by
1530 the prologue (in the latter case the type of the LOC_ARG
1531 symbol is double and the type of the LOC_LOCAL symbol is
1532 float). There are also LOC_ARG/LOC_REGISTER pairs which
1533 are not combined in symbol-reading. */
1534 /* But if the parameter name is null, don't try it.
1535 Null parameter names occur on the RS/6000, for traceback tables.
1536 FIXME, should we even print them? */
1538 if (*SYMBOL_NAME (sym
))
1541 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1543 /* Print the current arg. */
1545 fprintf_filtered (stream
, ", ");
1547 fprintf_symbol_filtered (stream
, SYMBOL_SOURCE_NAME (sym
),
1548 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
1549 fputs_filtered ("=", stream
);
1551 /* Avoid value_print because it will deref ref parameters. We just
1552 want to print their addresses. Print ??? for args whose address
1553 we do not know. We pass 2 as "recurse" to val_print because our
1554 standard indentation here is 4 spaces, and val_print indents
1555 2 for each recurse. */
1556 val
= read_var_value (sym
, FRAME_INFO_ID (fi
));
1558 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), VALUE_ADDRESS (val
),
1559 stream
, 0, 0, 2, Val_no_prettyprint
);
1561 fputs_filtered ("???", stream
);
1565 /* Don't print nameless args in situations where we don't know
1566 enough about the stack to find them. */
1571 if (highest_offset
== -1)
1572 start
= FRAME_ARGS_SKIP
;
1574 start
= highest_offset
;
1576 print_frame_nameless_args (fi
, start
, num
- args_printed
,
1581 /* Print nameless args on STREAM.
1582 FI is the frameinfo for this frame, START is the offset
1583 of the first nameless arg, and NUM is the number of nameless args to
1584 print. FIRST is nonzero if this is the first argument (not just
1585 the first nameless arg). */
1587 print_frame_nameless_args (fi
, start
, num
, first
, stream
)
1588 struct frame_info
*fi
;
1598 for (i
= 0; i
< num
; i
++)
1601 #ifdef NAMELESS_ARG_VALUE
1602 NAMELESS_ARG_VALUE (fi
, start
, &arg_value
);
1604 argsaddr
= FRAME_ARGS_ADDRESS (fi
);
1608 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
1612 fprintf_filtered (stream
, ", ");
1614 #ifdef PRINT_NAMELESS_INTEGER
1615 PRINT_NAMELESS_INTEGER (stream
, arg_value
);
1617 #ifdef PRINT_TYPELESS_INTEGER
1618 PRINT_TYPELESS_INTEGER (stream
, builtin_type_int
, (LONGEST
) arg_value
);
1620 fprintf_filtered (stream
, "%d", arg_value
);
1621 #endif /* PRINT_TYPELESS_INTEGER */
1622 #endif /* PRINT_NAMELESS_INTEGER */
1624 start
+= sizeof (int);
1630 printf_command (arg
, from_tty
)
1635 register char *s
= arg
;
1639 int allocated_args
= 20;
1642 val_args
= (value
*) xmalloc (allocated_args
* sizeof (value
));
1645 error_no_arg ("format-control string and values to print");
1647 /* Skip white space before format string */
1648 while (*s
== ' ' || *s
== '\t') s
++;
1650 /* A format string should follow, enveloped in double quotes */
1652 error ("Bad format string, missing '\"'.");
1654 /* Parse the format-control string and copy it into the string STRING,
1655 processing some kinds of escape sequence. */
1657 f
= string
= (char *) alloca (strlen (s
) + 1);
1664 error ("Bad format string, non-terminated '\"'.");
1665 /* doesn't return */
1686 /* ??? TODO: handle other escape sequences */
1687 error ("Unrecognized \\ escape character in format string.");
1696 /* Skip over " and following space and comma. */
1699 while (*s
== ' ' || *s
== '\t') s
++;
1701 if (*s
!= ',' && *s
!= 0)
1702 error ("Invalid argument syntax");
1705 while (*s
== ' ' || *s
== '\t') s
++;
1708 /* Now scan the string for %-specs and see what kinds of args they want.
1709 argclass[I] classifies the %-specs so we can give vprintf something
1710 of the right size. */
1712 enum argclass
{int_arg
, string_arg
, double_arg
, long_long_arg
};
1713 enum argclass
*argclass
;
1719 argclass
= (enum argclass
*) alloca (strlen (s
) * sizeof *argclass
);
1726 while (strchr ("0123456789.hlL-+ #", *f
))
1728 if (*f
== 'l' || *f
== 'L')
1733 argclass
[nargs_wanted
++] = string_arg
;
1734 else if (*f
== 'e' || *f
== 'f' || *f
== 'g')
1735 argclass
[nargs_wanted
++] = double_arg
;
1736 else if (lcount
> 1)
1737 argclass
[nargs_wanted
++] = long_long_arg
;
1739 argclass
[nargs_wanted
++] = int_arg
;
1743 /* Now, parse all arguments and evaluate them.
1744 Store the VALUEs in VAL_ARGS. */
1749 if (nargs
== allocated_args
)
1750 val_args
= (value
*) xrealloc ((char *) val_args
,
1751 (allocated_args
*= 2)
1754 val_args
[nargs
] = parse_to_comma_and_eval (&s1
);
1756 /* If format string wants a float, unchecked-convert the value to
1757 floating point of the same size */
1759 if (argclass
[nargs
] == double_arg
)
1761 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (float))
1762 VALUE_TYPE (val_args
[nargs
]) = builtin_type_float
;
1763 if (TYPE_LENGTH (VALUE_TYPE (val_args
[nargs
])) == sizeof (double))
1764 VALUE_TYPE (val_args
[nargs
]) = builtin_type_double
;
1772 if (nargs
!= nargs_wanted
)
1773 error ("Wrong number of arguments for specified format-string");
1775 /* Now lay out an argument-list containing the arguments
1776 as doubles, integers and C pointers. */
1778 arg_bytes
= (char *) alloca (sizeof (double) * nargs
);
1780 for (i
= 0; i
< nargs
; i
++)
1782 if (argclass
[i
] == string_arg
)
1787 tem
= value_as_pointer (val_args
[i
]);
1789 /* This is a %s argument. Find the length of the string. */
1794 read_memory (tem
+ j
, &c
, 1);
1799 /* Copy the string contents into a string inside GDB. */
1800 str
= (char *) alloca (j
+ 1);
1801 read_memory (tem
, str
, j
);
1804 /* Pass address of internal copy as the arg to vprintf. */
1805 *((int *) &arg_bytes
[argindex
]) = (int) str
;
1806 argindex
+= sizeof (int);
1808 else if (VALUE_TYPE (val_args
[i
])->code
== TYPE_CODE_FLT
)
1810 *((double *) &arg_bytes
[argindex
]) = value_as_double (val_args
[i
]);
1811 argindex
+= sizeof (double);
1814 #ifdef CC_HAS_LONG_LONG
1815 if (argclass
[i
] == long_long_arg
)
1817 *(LONGEST
*) &arg_bytes
[argindex
] = value_as_long (val_args
[i
]);
1818 argindex
+= sizeof (LONGEST
);
1823 *((long *) &arg_bytes
[argindex
]) = value_as_long (val_args
[i
]);
1824 argindex
+= sizeof (long);
1829 /* There is not a standard way to make a va_list, so we need
1830 to do various things for different systems. */
1831 #if defined (__INT_VARARGS_H)
1836 list
.__va_stk
= (int *) arg_bytes
;
1837 list
.__va_reg
= (int *) arg_bytes
;
1838 vprintf (string
, list
);
1840 #else /* No __INT_VARARGS_H. */
1841 vprintf (string
, arg_bytes
);
1842 #endif /* No __INT_VARARGS_H. */
1845 /* Helper function for asdump_command. Finds the bounds of a function
1846 for a specified section of text. PC is an address within the
1847 function which you want bounds for; *LOW and *HIGH are set to the
1848 beginning (inclusive) and end (exclusive) of the function. This
1849 function returns 1 on success and 0 on failure. */
1852 containing_function_bounds (pc
, low
, high
)
1853 CORE_ADDR pc
, *low
, *high
;
1857 struct obj_section
*sec
;
1859 if (!find_pc_partial_function (pc
, 0, low
))
1862 sec
= find_pc_section (pc
);
1865 limit
= sec
->endaddr
;
1868 while (scan
< limit
)
1871 if (!find_pc_partial_function (scan
, 0, high
))
1880 /* Dump a specified section of assembly code. With no command line
1881 arguments, this command will dump the assembly code for the
1882 function surrounding the pc value in the selected frame. With one
1883 argument, it will dump the assembly code surrounding that pc value.
1884 Two arguments are interpeted as bounds within which to dump
1889 disassemble_command (arg
, from_tty
)
1893 CORE_ADDR low
, high
;
1899 if (!selected_frame
)
1900 error ("No frame selected.\n");
1902 pc
= get_frame_pc (selected_frame
);
1903 if (!containing_function_bounds (pc
, &low
, &high
))
1904 error ("No function contains pc specified by selected frame.\n");
1906 else if (!(space_index
= (char *) strchr (arg
, ' ')))
1909 pc
= parse_and_eval_address (arg
);
1910 if (!containing_function_bounds (pc
, &low
, &high
))
1911 error ("No function contains specified pc.\n");
1915 /* Two arguments. */
1916 *space_index
= '\0';
1917 low
= parse_and_eval_address (arg
);
1918 high
= parse_and_eval_address (space_index
+ 1);
1921 printf_filtered ("Dump of assembler code ");
1925 find_pc_partial_function (pc
, &name
, 0);
1926 printf_filtered ("for function %s:\n", name
);
1930 printf_filtered ("from %s ", local_hex_string(low
));
1931 printf_filtered ("to %s:\n", local_hex_string(high
));
1934 /* Dump the specified range. */
1935 for (pc
= low
; pc
< high
; )
1938 print_address (pc
, stdout
);
1939 printf_filtered (":\t");
1940 pc
+= print_insn (pc
, stdout
);
1941 printf_filtered ("\n");
1943 printf_filtered ("End of assembler dump.\n");
1949 _initialize_printcmd ()
1951 current_display_number
= -1;
1953 add_info ("address", address_info
,
1954 "Describe where variable VAR is stored.");
1956 add_com ("x", class_vars
, x_command
,
1957 "Examine memory: x/FMT ADDRESS.\n\
1958 ADDRESS is an expression for the memory address to examine.\n\
1959 FMT is a repeat count followed by a format letter and a size letter.\n\
1960 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
1961 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
1962 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
1963 The specified number of objects of the specified size are printed\n\
1964 according to the format.\n\n\
1965 Defaults for format and size letters are those previously used.\n\
1966 Default count is 1. Default address is following last thing printed\n\
1967 with this command or \"print\".");
1969 add_com ("disassemble", class_vars
, disassemble_command
,
1970 "Disassemble a specified section of memory.\n\
1971 Default is the function surrounding the pc of the selected frame.\n\
1972 With a single argument, the function surrounding that address is dumped.\n\
1973 Two arguments are taken as a range of memory to dump.");
1976 add_com ("whereis", class_vars
, whereis_command
,
1977 "Print line number and file of definition of variable.");
1980 add_info ("display", display_info
,
1981 "Expressions to display when program stops, with code numbers.");
1983 add_cmd ("undisplay", class_vars
, undisplay_command
,
1984 "Cancel some expressions to be displayed when program stops.\n\
1985 Arguments are the code numbers of the expressions to stop displaying.\n\
1986 No argument means cancel all automatic-display expressions.\n\
1987 \"delete display\" has the same effect as this command.\n\
1988 Do \"info display\" to see current list of code numbers.",
1991 add_com ("display", class_vars
, display_command
,
1992 "Print value of expression EXP each time the program stops.\n\
1993 /FMT may be used before EXP as in the \"print\" command.\n\
1994 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
1995 as in the \"x\" command, and then EXP is used to get the address to examine\n\
1996 and examining is done as in the \"x\" command.\n\n\
1997 With no argument, display all currently requested auto-display expressions.\n\
1998 Use \"undisplay\" to cancel display requests previously made.");
2000 add_cmd ("display", class_vars
, enable_display
,
2001 "Enable some expressions to be displayed when program stops.\n\
2002 Arguments are the code numbers of the expressions to resume displaying.\n\
2003 No argument means enable all automatic-display expressions.\n\
2004 Do \"info display\" to see current list of code numbers.", &enablelist
);
2006 add_cmd ("display", class_vars
, disable_display_command
,
2007 "Disable some expressions to be displayed when program stops.\n\
2008 Arguments are the code numbers of the expressions to stop displaying.\n\
2009 No argument means disable all automatic-display expressions.\n\
2010 Do \"info display\" to see current list of code numbers.", &disablelist
);
2012 add_cmd ("display", class_vars
, undisplay_command
,
2013 "Cancel some expressions to be displayed when program stops.\n\
2014 Arguments are the code numbers of the expressions to stop displaying.\n\
2015 No argument means cancel all automatic-display expressions.\n\
2016 Do \"info display\" to see current list of code numbers.", &deletelist
);
2018 add_com ("printf", class_vars
, printf_command
,
2019 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2020 This is useful for formatted output in user-defined commands.");
2021 add_com ("output", class_vars
, output_command
,
2022 "Like \"print\" but don't put in value history and don't print newline.\n\
2023 This is useful in user-defined commands.");
2025 add_prefix_cmd ("set", class_vars
, set_command
,
2026 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2027 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2028 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2029 with $), a register (a few standard names starting with $), or an actual\n\
2030 variable in the program being debugged. EXP is any valid expression.\n\
2031 Use \"set variable\" for variables with names identical to set subcommands.\n\
2032 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2033 You can see these environment settings with the \"show\" command.",
2034 &setlist
, "set ", 1, &cmdlist
);
2036 /* "call" is the same as "set", but handy for dbx users to call fns. */
2037 add_com ("call", class_vars
, call_command
,
2038 "Call a function in the program.\n\
2039 The argument is the function name and arguments, in the notation of the\n\
2040 current working language. The result is printed and saved in the value\n\
2041 history, if it is not void.");
2043 add_cmd ("variable", class_vars
, set_command
,
2044 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2045 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2046 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2047 with $), a register (a few standard names starting with $), or an actual\n\
2048 variable in the program being debugged. EXP is any valid expression.\n\
2049 This may usually be abbreviated to simply \"set\".",
2052 add_com ("print", class_vars
, print_command
,
2053 concat ("Print value of expression EXP.\n\
2054 Variables accessible are those of the lexical environment of the selected\n\
2055 stack frame, plus all those whose scope is global or an entire file.\n\
2057 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2058 $$NUM refers to NUM'th value back from the last one.\n\
2059 Names starting with $ refer to registers (with the values they would have\n\
2060 if the program were to return to the stack frame now selected, restoring\n\
2061 all registers saved by frames farther in) or else to debugger\n\
2062 \"convenience\" variables (any such name not a known register).\n\
2063 Use assignment expressions to give values to convenience variables.\n",
2065 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2066 @ is a binary operator for treating consecutive data objects\n\
2067 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2068 element is FOO, whose second element is stored in the space following\n\
2069 where FOO is stored, etc. FOO must be an expression whose value\n\
2070 resides in memory.\n",
2072 EXP may be preceded with /FMT, where FMT is a format letter\n\
2073 but no count or size letter (see \"x\" command).", NULL
));
2074 add_com_alias ("p", "print", class_vars
, 1);
2076 add_com ("inspect", class_vars
, inspect_command
,
2077 "Same as \"print\" command, except that if you are running in the epoch\n\
2078 environment, the value is printed in its own window.");
2081 add_set_cmd ("max-symbolic-offset", no_class
, var_uinteger
,
2082 (char *)&max_symbolic_offset
,
2083 "Set the largest offset that will be printed in <symbol+1234> form.",
2087 add_set_cmd ("symbol-filename", no_class
, var_boolean
,
2088 (char *)&print_symbol_filename
,
2089 "Set printing of source filename and line number with <symbol>.",