1 /* Print values for GNU debugger GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include "expression.h"
33 #include "breakpoint.h"
37 extern int asm_demangle; /* Whether to demangle syms in asm printouts */
38 extern int addressprint; /* Whether to print hex addresses in HLL " */
47 /* Last specified output format. */
49 static char last_format = 'x';
51 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
53 static char last_size = 'w';
55 /* Default address to examine next. */
57 static CORE_ADDR next_address;
59 /* Last address examined. */
61 static CORE_ADDR last_examine_address;
63 /* Contents of last address examined.
64 This is not valid past the end of the `x' command! */
66 static value_ptr last_examine_value;
68 /* Largest offset between a symbolic value and an address, that will be
69 printed as `0x1234 <symbol+offset>'. */
71 static unsigned int max_symbolic_offset = UINT_MAX;
73 /* Append the source filename and linenumber of the symbol when
74 printing a symbolic value as `<symbol at filename:linenum>' if set. */
75 static int print_symbol_filename = 0;
77 /* Number of auto-display expression currently being displayed.
78 So that we can disable it if we get an error or a signal within it.
79 -1 when not doing one. */
81 int current_display_number;
83 /* Flag to low-level print routines that this value is being printed
84 in an epoch window. We'd like to pass this as a parameter, but
85 every routine would need to take it. Perhaps we can encapsulate
86 this in the I/O stream once we have GNU stdio. */
94 /* FIXME: Should we be printing * for references as well as pointers? */
96 && TYPE_CODE (t) == TYPE_CODE_PTR
97 && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID)
98 printf_filtered ("*");
100 printf_filtered ("-");
105 /* Chain link to next auto-display item. */
106 struct display *next;
107 /* Expression to be evaluated and displayed. */
108 struct expression *exp;
109 /* Item number of this auto-display item. */
111 /* Display format specified. */
112 struct format_data format;
113 /* Innermost block required by this expression when evaluated */
115 /* Status of this display (enabled or disabled) */
119 /* Chain of expressions whose values should be displayed
120 automatically each time the program stops. */
122 static struct display *display_chain;
124 static int display_number;
126 /* Prototypes for local functions */
129 delete_display PARAMS ((int));
132 enable_display PARAMS ((char *, int));
135 disable_display_command PARAMS ((char *, int));
138 disassemble_command PARAMS ((char *, int));
141 printf_command PARAMS ((char *, int));
144 print_frame_nameless_args PARAMS ((struct frame_info *, long, int, int,
148 display_info PARAMS ((char *, int));
151 do_one_display PARAMS ((struct display *));
154 undisplay_command PARAMS ((char *, int));
157 free_display PARAMS ((struct display *));
160 display_command PARAMS ((char *, int));
163 x_command PARAMS ((char *, int));
166 address_info PARAMS ((char *, int));
169 set_command PARAMS ((char *, int));
172 output_command PARAMS ((char *, int));
175 call_command PARAMS ((char *, int));
178 inspect_command PARAMS ((char *, int));
181 print_command PARAMS ((char *, int));
184 print_command_1 PARAMS ((char *, int, int));
187 validate_format PARAMS ((struct format_data, char *));
190 do_examine PARAMS ((struct format_data, CORE_ADDR));
193 print_formatted PARAMS ((value_ptr, int, int));
195 static struct format_data
196 decode_format PARAMS ((char **, int, int));
199 /* Decode a format specification. *STRING_PTR should point to it.
200 OFORMAT and OSIZE are used as defaults for the format and size
201 if none are given in the format specification.
202 If OSIZE is zero, then the size field of the returned value
203 should be set only if a size is explicitly specified by the
205 The structure returned describes all the data
206 found in the specification. In addition, *STRING_PTR is advanced
207 past the specification and past all whitespace following it. */
209 static struct format_data
210 decode_format (string_ptr, oformat, osize)
215 struct format_data val;
216 register char *p = *string_ptr;
222 if (*p >= '0' && *p <= '9')
223 val.count = atoi (p);
224 while (*p >= '0' && *p <= '9') p++;
226 /* Now process size or format letters that follow. */
230 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
232 else if (*p >= 'a' && *p <= 'z')
238 while (*p == ' ' || *p == '\t') p++;
241 /* Set defaults for format and size if not specified. */
242 if (val.format == '?')
246 /* Neither has been specified. */
247 val.format = oformat;
251 /* If a size is specified, any format makes a reasonable
252 default except 'i'. */
253 val.format = oformat == 'i' ? 'x' : oformat;
255 else if (val.size == '?')
260 /* Pick the appropriate size for an address. */
261 #if TARGET_PTR_BIT == 64
262 val.size = osize ? 'g' : osize;
265 #if TARGET_PTR_BIT == 32
266 val.size = osize ? 'w' : osize;
269 #if TARGET_PTR_BIT == 16
270 val.size = osize ? 'h' : osize;
273 #error Bad value for TARGET_PTR_BIT
279 /* Floating point has to be word or giantword. */
280 if (osize == 'w' || osize == 'g')
283 /* Default it to giantword if the last used size is not
285 val.size = osize ? 'g' : osize;
288 /* Characters default to one byte. */
289 val.size = osize ? 'b' : osize;
292 /* The default is the size most recently specified. */
299 /* Print value VAL on gdb_stdout according to FORMAT, a letter or 0.
300 Do not end with a newline.
301 0 means print VAL according to its own type.
302 SIZE is the letter for the size of datum being printed.
303 This is used to pad hex numbers so they line up. */
306 print_formatted (val, format, size)
307 register value_ptr val;
311 int len = TYPE_LENGTH (VALUE_TYPE (val));
313 if (VALUE_LVAL (val) == lval_memory)
314 next_address = VALUE_ADDRESS (val) + len;
319 next_address = VALUE_ADDRESS (val)
320 + value_print (value_addr (val), gdb_stdout, format, Val_pretty_default);
324 /* The old comment says
325 "Force output out, print_insn not using _filtered".
326 I'm not completely sure what that means, I suspect most print_insn
327 now do use _filtered, so I guess it's obsolete. */
328 /* We often wrap here if there are long symbolic names. */
330 next_address = VALUE_ADDRESS (val)
331 + print_insn (VALUE_ADDRESS (val), gdb_stdout);
336 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_ARRAY
337 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRING
338 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_STRUCT
339 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_UNION
340 || VALUE_REPEATED (val))
341 value_print (val, gdb_stdout, format, Val_pretty_default);
343 print_scalar_formatted (VALUE_CONTENTS (val), VALUE_TYPE (val),
344 format, size, gdb_stdout);
348 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
349 according to letters FORMAT and SIZE on STREAM.
350 FORMAT may not be zero. Formats s and i are not supported at this level.
352 This is how the elements of an array or structure are printed
356 print_scalar_formatted (valaddr, type, format, size, stream)
364 int len = TYPE_LENGTH (type);
366 if (len > sizeof (LONGEST)
374 /* We can't print it normally, but we can print it in hex.
375 Printing it in the wrong radix is more useful than saying
376 "use /x, you dummy". */
377 /* FIXME: we could also do octal or binary if that was the
379 /* FIXME: we should be using the size field to give us a minimum
380 field width to print. */
381 val_print_type_code_int (type, valaddr, stream);
386 val_long = unpack_long (type, valaddr);
388 /* If we are printing it as unsigned, truncate it in case it is actually
389 a negative signed value (e.g. "print/u (short)-1" should print 65535
390 (if shorts are 16 bits) instead of 4294967295). */
393 if (len < sizeof (LONGEST))
394 val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
402 /* no size specified, like in print. Print varying # of digits. */
403 print_longest (stream, 'x', 1, val_long);
412 print_longest (stream, size, 1, val_long);
415 error ("Undefined output size \"%c\".", size);
420 print_longest (stream, 'd', 1, val_long);
424 print_longest (stream, 'u', 0, val_long);
429 print_longest (stream, 'o', 1, val_long);
431 fprintf_filtered (stream, "0");
435 print_address (unpack_pointer (type, valaddr), stream);
439 value_print (value_from_longest (builtin_type_char, val_long), stream, 0,
444 if (len == sizeof (float))
445 type = builtin_type_float;
446 else if (len == sizeof (double))
447 type = builtin_type_double;
448 print_floating (valaddr, type, stream);
455 /* Binary; 't' stands for "two". */
457 char bits[8*(sizeof val_long) + 1];
462 width = 8*(sizeof val_long);
479 error ("Undefined output size \"%c\".", size);
485 bits[width] = (val_long & 1) ? '1' : '0';
490 while (*cp && *cp == '0')
495 fprintf_filtered (stream, local_binary_format_prefix());
496 fprintf_filtered (stream, cp);
497 fprintf_filtered (stream, local_binary_format_suffix());
502 error ("Undefined output format \"%c\".", format);
506 /* Specify default address for `x' command.
507 `info lines' uses this. */
510 set_next_address (addr)
515 /* Make address available to the user as $_. */
516 set_internalvar (lookup_internalvar ("_"),
517 value_from_longest (lookup_pointer_type (builtin_type_void),
521 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
522 after LEADIN. Print nothing if no symbolic name is found nearby.
523 Optionally also print source file and line number, if available.
524 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
525 or to interpret it as a possible C++ name and convert it back to source
526 form. However note that DO_DEMANGLE can be overridden by the specific
527 settings of the demangle and asm_demangle variables. */
530 print_address_symbolic (addr, stream, do_demangle, leadin)
536 struct minimal_symbol *msymbol;
537 struct symbol *symbol;
538 struct symtab *symtab = 0;
539 CORE_ADDR name_location = 0;
542 /* First try to find the address in the symbol table, then
543 in the minsyms. Take the closest one. */
545 /* This is defective in the sense that it only finds text symbols. So
546 really this is kind of pointless--we should make sure that the
547 minimal symbols have everything we need (by changing that we could
548 save some memory, but for many debug format--ELF/DWARF or
549 anything/stabs--it would be inconvenient to eliminate those minimal
551 symbol = find_pc_function (addr);
553 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
558 name = SYMBOL_SOURCE_NAME (symbol);
560 name = SYMBOL_LINKAGE_NAME (symbol);
563 msymbol = lookup_minimal_symbol_by_pc (addr);
566 if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
568 /* The msymbol is closer to the address than the symbol;
569 use the msymbol instead. */
572 name_location = SYMBOL_VALUE_ADDRESS (msymbol);
574 name = SYMBOL_SOURCE_NAME (msymbol);
576 name = SYMBOL_LINKAGE_NAME (msymbol);
579 if (symbol == NULL && msymbol == NULL)
582 /* If the nearest symbol is too far away, don't print anything symbolic. */
584 /* For when CORE_ADDR is larger than unsigned int, we do math in
585 CORE_ADDR. But when we detect unsigned wraparound in the
586 CORE_ADDR math, we ignore this test and print the offset,
587 because addr+max_symbolic_offset has wrapped through the end
588 of the address space back to the beginning, giving bogus comparison. */
589 if (addr > name_location + max_symbolic_offset
590 && name_location + max_symbolic_offset > name_location)
593 fputs_filtered (leadin, stream);
594 fputs_filtered ("<", stream);
595 fputs_filtered (name, stream);
596 if (addr != name_location)
597 fprintf_filtered (stream, "+%u", (unsigned int)(addr - name_location));
599 /* Append source filename and line number if desired. Give specific
600 line # of this addr, if we have it; else line # of the nearest symbol. */
601 if (print_symbol_filename)
603 struct symtab_and_line sal;
605 sal = find_pc_line (addr, 0);
607 fprintf_filtered (stream, " at %s:%d", sal.symtab->filename, sal.line);
608 else if (symtab && symbol && symbol->line)
609 fprintf_filtered (stream, " at %s:%d", symtab->filename, symbol->line);
611 fprintf_filtered (stream, " in %s", symtab->filename);
613 fputs_filtered (">", stream);
616 /* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
619 print_address_numeric (addr, use_local, stream)
624 /* This assumes a CORE_ADDR can fit in a LONGEST. Probably a safe
625 assumption. We pass use_local but I'm not completely sure whether
626 that is correct. When (if ever) should we *not* use_local? */
627 print_longest (stream, 'x', 1, (unsigned LONGEST) addr);
630 /* Print address ADDR symbolically on STREAM.
631 First print it as a number. Then perhaps print
632 <SYMBOL + OFFSET> after the number. */
635 print_address (addr, stream)
639 print_address_numeric (addr, 1, stream);
640 print_address_symbolic (addr, stream, asm_demangle, " ");
643 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
644 controls whether to print the symbolic name "raw" or demangled.
645 Global setting "addressprint" controls whether to print hex address
649 print_address_demangle (addr, stream, do_demangle)
656 fprintf_filtered (stream, "0");
658 else if (addressprint)
660 print_address_numeric (addr, 1, stream);
661 print_address_symbolic (addr, stream, do_demangle, " ");
665 print_address_symbolic (addr, stream, do_demangle, "");
670 /* These are the types that $__ will get after an examine command of one
673 static struct type *examine_b_type;
674 static struct type *examine_h_type;
675 static struct type *examine_w_type;
676 static struct type *examine_g_type;
678 /* Examine data at address ADDR in format FMT.
679 Fetch it from memory and print on gdb_stdout. */
682 do_examine (fmt, addr)
683 struct format_data fmt;
686 register char format = 0;
688 register int count = 1;
689 struct type *val_type = NULL;
691 register int maxelts;
698 /* String or instruction format implies fetch single bytes
699 regardless of the specified size. */
700 if (format == 's' || format == 'i')
704 val_type = examine_b_type;
705 else if (size == 'h')
706 val_type = examine_h_type;
707 else if (size == 'w')
708 val_type = examine_w_type;
709 else if (size == 'g')
710 val_type = examine_g_type;
717 if (format == 's' || format == 'i')
720 /* Print as many objects as specified in COUNT, at most maxelts per line,
721 with the address of the next one at the start of each line. */
725 print_address (next_address, gdb_stdout);
726 printf_filtered (":");
731 printf_filtered ("\t");
732 /* Note that print_formatted sets next_address for the next
734 last_examine_address = next_address;
735 last_examine_value = value_at (val_type, next_address);
736 print_formatted (last_examine_value, format, size);
738 printf_filtered ("\n");
739 gdb_flush (gdb_stdout);
744 validate_format (fmt, cmdname)
745 struct format_data fmt;
749 error ("Size letters are meaningless in \"%s\" command.", cmdname);
751 error ("Item count other than 1 is meaningless in \"%s\" command.",
753 if (fmt.format == 'i' || fmt.format == 's')
754 error ("Format letter \"%c\" is meaningless in \"%s\" command.",
755 fmt.format, cmdname);
758 /* Evaluate string EXP as an expression in the current language and
759 print the resulting value. EXP may contain a format specifier as the
760 first argument ("/x myvar" for example, to print myvar in hex).
764 print_command_1 (exp, inspect, voidprint)
769 struct expression *expr;
770 register struct cleanup *old_chain = 0;
771 register char format = 0;
772 register value_ptr val;
773 struct format_data fmt;
776 /* Pass inspect flag to the rest of the print routines in a global (sigh). */
777 inspect_it = inspect;
779 if (exp && *exp == '/')
782 fmt = decode_format (&exp, last_format, 0);
783 validate_format (fmt, "print");
784 last_format = format = fmt.format;
795 extern int objectprint;
797 expr = parse_expression (exp);
798 old_chain = make_cleanup (free_current_contents, &expr);
800 val = evaluate_expression (expr);
802 /* C++: figure out what type we actually want to print it as. */
803 type = VALUE_TYPE (val);
806 && ( TYPE_CODE (type) == TYPE_CODE_PTR
807 || TYPE_CODE (type) == TYPE_CODE_REF)
808 && ( TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT
809 || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_UNION))
813 v = value_from_vtable_info (val, TYPE_TARGET_TYPE (type));
817 type = VALUE_TYPE (val);
822 val = access_value_history (0);
824 if (voidprint || (val && VALUE_TYPE (val) &&
825 TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
827 int histindex = record_latest_value (val);
829 if (annotation_level > 1)
832 printf_filtered ("\n\032\032value-history-begin %d ", histindex);
834 printf_filtered ("\n\032\032value-begin ");
835 print_value_flags (VALUE_TYPE (val));
836 printf_filtered ("\n");
840 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp, histindex);
842 if (histindex >= 0) printf_filtered ("$%d = ", histindex);
844 if (annotation_level > 1 && histindex >= 0)
845 printf_filtered ("\n\032\032value-history-value\n");
847 print_formatted (val, format, fmt.size);
848 printf_filtered ("\n");
850 if (annotation_level > 1)
853 printf_filtered ("\n\032\032value-history-end\n");
855 printf_filtered ("\n\032\032value-end\n");
859 printf_unfiltered("\") )\030");
863 do_cleanups (old_chain);
864 inspect_it = 0; /* Reset print routines to normal */
869 print_command (exp, from_tty)
873 print_command_1 (exp, 0, 1);
876 /* Same as print, except in epoch, it gets its own window */
879 inspect_command (exp, from_tty)
883 extern int epoch_interface;
885 print_command_1 (exp, epoch_interface, 1);
888 /* Same as print, except it doesn't print void results. */
891 call_command (exp, from_tty)
895 print_command_1 (exp, 0, 0);
900 output_command (exp, from_tty)
904 struct expression *expr;
905 register struct cleanup *old_chain;
906 register char format = 0;
907 register value_ptr val;
908 struct format_data fmt;
910 if (exp && *exp == '/')
913 fmt = decode_format (&exp, 0, 0);
914 validate_format (fmt, "output");
918 expr = parse_expression (exp);
919 old_chain = make_cleanup (free_current_contents, &expr);
921 val = evaluate_expression (expr);
923 if (annotation_level > 1)
925 printf_filtered ("\n\032\032value-begin ");
926 print_value_flags (VALUE_TYPE (val));
927 printf_filtered ("\n");
930 print_formatted (val, format, fmt.size);
932 if (annotation_level > 1)
933 printf_filtered ("\n\032\032value-end\n");
935 do_cleanups (old_chain);
940 set_command (exp, from_tty)
944 struct expression *expr = parse_expression (exp);
945 register struct cleanup *old_chain
946 = make_cleanup (free_current_contents, &expr);
947 evaluate_expression (expr);
948 do_cleanups (old_chain);
953 address_info (exp, from_tty)
957 register struct symbol *sym;
958 register struct minimal_symbol *msymbol;
960 register long basereg;
961 int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
962 if exp is a field of `this'. */
965 error ("Argument required.");
967 sym = lookup_symbol (exp, get_selected_block (), VAR_NAMESPACE,
968 &is_a_field_of_this, (struct symtab **)NULL);
971 if (is_a_field_of_this)
973 printf_filtered ("Symbol \"");
974 fprintf_symbol_filtered (gdb_stdout, exp,
975 current_language->la_language, DMGL_ANSI);
976 printf_filtered ("\" is a field of the local class variable `this'\n");
980 msymbol = lookup_minimal_symbol (exp, (struct objfile *) NULL);
984 printf_filtered ("Symbol \"");
985 fprintf_symbol_filtered (gdb_stdout, exp,
986 current_language->la_language, DMGL_ANSI);
987 printf_filtered ("\" is at ");
988 print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1,
990 printf_filtered (" in a file compiled without debugging.\n");
993 error ("No symbol \"%s\" in current context.", exp);
997 printf_filtered ("Symbol \"");
998 fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
999 current_language->la_language, DMGL_ANSI);
1000 printf_filtered ("\" is ", SYMBOL_NAME (sym));
1001 val = SYMBOL_VALUE (sym);
1002 basereg = SYMBOL_BASEREG (sym);
1004 switch (SYMBOL_CLASS (sym))
1007 case LOC_CONST_BYTES:
1008 printf_filtered ("constant");
1012 printf_filtered ("a label at address ");
1013 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
1017 printf_filtered ("a variable in register %s", reg_names[val]);
1021 printf_filtered ("static storage at address ");
1022 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
1026 printf_filtered ("an argument in register %s", reg_names[val]);
1029 case LOC_REGPARM_ADDR:
1030 printf_filtered ("address of an argument in register %s", reg_names[val]);
1034 printf_filtered ("an argument at offset %ld", val);
1038 printf_filtered ("an argument at frame offset %ld", val);
1042 printf_filtered ("a local variable at frame offset %ld", val);
1046 printf_filtered ("a reference argument at offset %ld", val);
1050 printf_filtered ("a variable at offset %ld from register %s",
1051 val, reg_names[basereg]);
1054 case LOC_BASEREG_ARG:
1055 printf_filtered ("an argument at offset %ld from register %s",
1056 val, reg_names[basereg]);
1060 printf_filtered ("a typedef");
1064 printf_filtered ("a function at address ");
1065 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
1069 case LOC_OPTIMIZED_OUT:
1070 printf_filtered ("optimized out");
1074 printf_filtered ("of unknown (botched) type");
1077 printf_filtered (".\n");
1081 x_command (exp, from_tty)
1085 struct expression *expr;
1086 struct format_data fmt;
1087 struct cleanup *old_chain;
1090 fmt.format = last_format;
1091 fmt.size = last_size;
1094 if (exp && *exp == '/')
1097 fmt = decode_format (&exp, last_format, last_size);
1100 /* If we have an expression, evaluate it and use it as the address. */
1102 if (exp != 0 && *exp != 0)
1104 expr = parse_expression (exp);
1105 /* Cause expression not to be there any more
1106 if this command is repeated with Newline.
1107 But don't clobber a user-defined command's definition. */
1110 old_chain = make_cleanup (free_current_contents, &expr);
1111 val = evaluate_expression (expr);
1112 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
1113 val = value_ind (val);
1114 /* In rvalue contexts, such as this, functions are coerced into
1115 pointers to functions. This makes "x/i main" work. */
1116 if (/* last_format == 'i'
1117 && */ TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
1118 && VALUE_LVAL (val) == lval_memory)
1119 next_address = VALUE_ADDRESS (val);
1121 next_address = value_as_pointer (val);
1122 do_cleanups (old_chain);
1125 do_examine (fmt, next_address);
1127 /* If the examine succeeds, we remember its size and format for next time. */
1128 last_size = fmt.size;
1129 last_format = fmt.format;
1131 /* Set a couple of internal variables if appropriate. */
1132 if (last_examine_value)
1134 /* Make last address examined available to the user as $_. Use
1135 the correct pointer type. */
1136 set_internalvar (lookup_internalvar ("_"),
1137 value_from_longest (
1138 lookup_pointer_type (VALUE_TYPE (last_examine_value)),
1139 (LONGEST) last_examine_address));
1141 /* Make contents of last address examined available to the user as $__.*/
1142 set_internalvar (lookup_internalvar ("__"), last_examine_value);
1147 /* Add an expression to the auto-display chain.
1148 Specify the expression. */
1151 display_command (exp, from_tty)
1155 struct format_data fmt;
1156 register struct expression *expr;
1157 register struct display *new;
1168 fmt = decode_format (&exp, 0, 0);
1169 if (fmt.size && fmt.format == 0)
1171 if (fmt.format == 'i' || fmt.format == 's')
1181 innermost_block = 0;
1182 expr = parse_expression (exp);
1184 new = (struct display *) xmalloc (sizeof (struct display));
1187 new->block = innermost_block;
1188 new->next = display_chain;
1189 new->number = ++display_number;
1191 new->status = enabled;
1192 display_chain = new;
1194 if (from_tty && target_has_execution)
1195 do_one_display (new);
1208 /* Clear out the display_chain.
1209 Done when new symtabs are loaded, since this invalidates
1210 the types stored in many expressions. */
1215 register struct display *d;
1217 while ((d = display_chain) != NULL)
1220 display_chain = d->next;
1225 /* Delete the auto-display number NUM. */
1228 delete_display (num)
1231 register struct display *d1, *d;
1234 error ("No display number %d.", num);
1236 if (display_chain->number == num)
1239 display_chain = d1->next;
1243 for (d = display_chain; ; d = d->next)
1246 error ("No display number %d.", num);
1247 if (d->next->number == num)
1257 /* Delete some values from the auto-display chain.
1258 Specify the element numbers. */
1261 undisplay_command (args, from_tty)
1265 register char *p = args;
1271 if (query ("Delete all auto-display expressions? "))
1280 while (*p1 >= '0' && *p1 <= '9') p1++;
1281 if (*p1 && *p1 != ' ' && *p1 != '\t')
1282 error ("Arguments must be display numbers.");
1286 delete_display (num);
1289 while (*p == ' ' || *p == '\t') p++;
1294 /* Display a single auto-display.
1295 Do nothing if the display cannot be printed in the current context,
1296 or if the display is disabled. */
1302 int within_current_scope;
1304 if (d->status == disabled)
1308 within_current_scope = contained_in (get_selected_block (), d->block);
1310 within_current_scope = 1;
1311 if (!within_current_scope)
1314 current_display_number = d->number;
1316 printf_filtered ("%d: ", d->number);
1321 printf_filtered ("x/");
1322 if (d->format.count != 1)
1323 printf_filtered ("%d", d->format.count);
1324 printf_filtered ("%c", d->format.format);
1325 if (d->format.format != 'i' && d->format.format != 's')
1326 printf_filtered ("%c", d->format.size);
1327 printf_filtered (" ");
1328 print_expression (d->exp, gdb_stdout);
1329 if (d->format.count != 1)
1330 printf_filtered ("\n");
1332 printf_filtered (" ");
1334 addr = value_as_pointer (evaluate_expression (d->exp));
1335 if (d->format.format == 'i')
1336 addr = ADDR_BITS_REMOVE (addr);
1338 do_examine (d->format, addr);
1342 if (d->format.format)
1343 printf_filtered ("/%c ", d->format.format);
1344 print_expression (d->exp, gdb_stdout);
1345 printf_filtered (" = ");
1346 print_formatted (evaluate_expression (d->exp),
1347 d->format.format, d->format.size);
1348 printf_filtered ("\n");
1351 gdb_flush (gdb_stdout);
1352 current_display_number = -1;
1355 /* Display all of the values on the auto-display chain which can be
1356 evaluated in the current scope. */
1361 register struct display *d;
1363 for (d = display_chain; d; d = d->next)
1367 /* Delete the auto-display which we were in the process of displaying.
1368 This is done when there is an error or a signal. */
1371 disable_display (num)
1374 register struct display *d;
1376 for (d = display_chain; d; d = d->next)
1377 if (d->number == num)
1379 d->status = disabled;
1382 printf_unfiltered ("No display number %d.\n", num);
1386 disable_current_display ()
1388 if (current_display_number >= 0)
1390 disable_display (current_display_number);
1391 fprintf_unfiltered (gdb_stderr, "Disabling display %d to avoid infinite recursion.\n",
1392 current_display_number);
1394 current_display_number = -1;
1398 display_info (ignore, from_tty)
1402 register struct display *d;
1405 printf_unfiltered ("There are no auto-display expressions now.\n");
1407 printf_filtered ("Auto-display expressions now in effect:\n\
1408 Num Enb Expression\n");
1410 for (d = display_chain; d; d = d->next)
1412 printf_filtered ("%d: %c ", d->number, "ny"[(int)d->status]);
1414 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1416 else if (d->format.format)
1417 printf_filtered ("/%c ", d->format.format);
1418 print_expression (d->exp, gdb_stdout);
1419 if (d->block && !contained_in (get_selected_block (), d->block))
1420 printf_filtered (" (cannot be evaluated in the current context)");
1421 printf_filtered ("\n");
1422 gdb_flush (gdb_stdout);
1427 enable_display (args, from_tty)
1431 register char *p = args;
1434 register struct display *d;
1438 for (d = display_chain; d; d = d->next)
1439 d->status = enabled;
1445 while (*p1 >= '0' && *p1 <= '9')
1447 if (*p1 && *p1 != ' ' && *p1 != '\t')
1448 error ("Arguments must be display numbers.");
1452 for (d = display_chain; d; d = d->next)
1453 if (d->number == num)
1455 d->status = enabled;
1458 printf_unfiltered ("No display number %d.\n", num);
1461 while (*p == ' ' || *p == '\t')
1468 disable_display_command (args, from_tty)
1472 register char *p = args;
1474 register struct display *d;
1478 for (d = display_chain; d; d = d->next)
1479 d->status = disabled;
1485 while (*p1 >= '0' && *p1 <= '9')
1487 if (*p1 && *p1 != ' ' && *p1 != '\t')
1488 error ("Arguments must be display numbers.");
1490 disable_display (atoi (p));
1493 while (*p == ' ' || *p == '\t')
1499 /* Print the value in stack frame FRAME of a variable
1500 specified by a struct symbol. */
1503 print_variable_value (var, frame, stream)
1508 value_ptr val = read_var_value (var, frame);
1509 value_print (val, stream, 0, Val_pretty_default);
1512 /* Print the arguments of a stack frame, given the function FUNC
1513 running in that frame (as a symbol), the info on the frame,
1514 and the number of args according to the stack frame (or -1 if unknown). */
1516 /* References here and elsewhere to "number of args according to the
1517 stack frame" appear in all cases to refer to "number of ints of args
1518 according to the stack frame". At least for VAX, i386, isi. */
1521 print_frame_args (func, fi, num, stream)
1522 struct symbol *func;
1523 struct frame_info *fi;
1527 struct block *b = NULL;
1531 register struct symbol *sym;
1532 register value_ptr val;
1533 /* Offset of next stack argument beyond the one we have seen that is
1534 at the highest offset.
1535 -1 if we haven't come to a stack argument yet. */
1536 long highest_offset = -1;
1538 /* Number of ints of arguments that we have printed so far. */
1539 int args_printed = 0;
1543 b = SYMBOL_BLOCK_VALUE (func);
1544 nsyms = BLOCK_NSYMS (b);
1547 for (i = 0; i < nsyms; i++)
1550 sym = BLOCK_SYM (b, i);
1552 /* Keep track of the highest stack argument offset seen, and
1553 skip over any kinds of symbols we don't care about. */
1555 switch (SYMBOL_CLASS (sym)) {
1559 long current_offset = SYMBOL_VALUE (sym);
1561 arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
1563 /* Compute address of next argument by adding the size of
1564 this argument and rounding to an int boundary. */
1566 = ((current_offset + arg_size + sizeof (int) - 1)
1567 & ~(sizeof (int) - 1));
1569 /* If this is the highest offset seen yet, set highest_offset. */
1570 if (highest_offset == -1
1571 || (current_offset > highest_offset))
1572 highest_offset = current_offset;
1574 /* Add the number of ints we're about to print to args_printed. */
1575 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
1578 /* We care about types of symbols, but don't need to keep track of
1579 stack offsets in them. */
1581 case LOC_REGPARM_ADDR:
1583 case LOC_BASEREG_ARG:
1586 /* Other types of symbols we just skip over. */
1591 /* We have to look up the symbol because arguments can have
1592 two entries (one a parameter, one a local) and the one we
1593 want is the local, which lookup_symbol will find for us.
1594 This includes gcc1 (not gcc2) on the sparc when passing a
1595 small structure and gcc2 when the argument type is float
1596 and it is passed as a double and converted to float by
1597 the prologue (in the latter case the type of the LOC_ARG
1598 symbol is double and the type of the LOC_LOCAL symbol is
1600 /* But if the parameter name is null, don't try it.
1601 Null parameter names occur on the RS/6000, for traceback tables.
1602 FIXME, should we even print them? */
1604 if (*SYMBOL_NAME (sym))
1606 struct symbol *nsym;
1607 nsym = lookup_symbol
1609 b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
1610 if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
1612 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
1613 it was passed on the stack and loaded into a register,
1614 or passed in a register and stored in a stack slot.
1615 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
1617 Reasons for using the LOC_ARG:
1618 (1) because find_saved_registers may be slow for remote
1620 (2) because registers are often re-used and stack slots
1621 rarely (never?) are. Therefore using the stack slot is
1622 much less likely to print garbage.
1624 Reasons why we might want to use the LOC_REGISTER:
1625 (1) So that the backtrace prints the same value as
1626 "print foo". I see no compelling reason why this needs
1627 to be the case; having the backtrace print the value which
1628 was passed in, and "print foo" print the value as modified
1629 within the called function, makes perfect sense to me.
1631 Additional note: It might be nice if "info args" displayed
1633 One more note: There is a case with sparc structure passing
1634 where we need to use the LOC_REGISTER, but this is dealt with
1635 by creating a single LOC_REGPARM in symbol reading. */
1637 /* Leave sym (the LOC_ARG) alone. */
1644 /* Print the current arg. */
1646 fprintf_filtered (stream, ", ");
1649 if (annotation_level > 1)
1650 printf_filtered ("\n\032\032arg-begin\n");
1652 fprintf_symbol_filtered (stream, SYMBOL_SOURCE_NAME (sym),
1653 SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
1654 if (annotation_level > 1)
1655 printf_filtered ("\n\032\032arg-name-end\n");
1656 fputs_filtered ("=", stream);
1658 /* Avoid value_print because it will deref ref parameters. We just
1659 want to print their addresses. Print ??? for args whose address
1660 we do not know. We pass 2 as "recurse" to val_print because our
1661 standard indentation here is 4 spaces, and val_print indents
1662 2 for each recurse. */
1663 val = read_var_value (sym, FRAME_INFO_ID (fi));
1665 if (annotation_level > 1)
1667 printf_filtered ("\n\032\032arg-value ");
1668 print_value_flags (val == NULL ? NULL : VALUE_TYPE (val));
1669 printf_filtered ("\n");
1673 val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
1674 stream, 0, 0, 2, Val_no_prettyprint);
1676 fputs_filtered ("???", stream);
1678 if (annotation_level > 1)
1679 printf_filtered ("\n\032\032arg-end\n");
1684 /* Don't print nameless args in situations where we don't know
1685 enough about the stack to find them. */
1690 if (highest_offset == -1)
1691 start = FRAME_ARGS_SKIP;
1693 start = highest_offset;
1695 print_frame_nameless_args (fi, start, num - args_printed,
1700 /* Print nameless args on STREAM.
1701 FI is the frameinfo for this frame, START is the offset
1702 of the first nameless arg, and NUM is the number of nameless args to
1703 print. FIRST is nonzero if this is the first argument (not just
1704 the first nameless arg). */
1706 print_frame_nameless_args (fi, start, num, first, stream)
1707 struct frame_info *fi;
1717 for (i = 0; i < num; i++)
1720 #ifdef NAMELESS_ARG_VALUE
1721 NAMELESS_ARG_VALUE (fi, start, &arg_value);
1723 argsaddr = FRAME_ARGS_ADDRESS (fi);
1727 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
1731 fprintf_filtered (stream, ", ");
1733 #ifdef PRINT_NAMELESS_INTEGER
1734 PRINT_NAMELESS_INTEGER (stream, arg_value);
1736 #ifdef PRINT_TYPELESS_INTEGER
1737 PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
1739 fprintf_filtered (stream, "%d", arg_value);
1740 #endif /* PRINT_TYPELESS_INTEGER */
1741 #endif /* PRINT_NAMELESS_INTEGER */
1743 start += sizeof (int);
1749 printf_command (arg, from_tty)
1754 register char *s = arg;
1756 value_ptr *val_args;
1758 char *current_substring;
1760 int allocated_args = 20;
1761 struct cleanup *old_cleanups;
1763 val_args = (value_ptr *) xmalloc (allocated_args * sizeof (value_ptr));
1764 old_cleanups = make_cleanup (free_current_contents, &val_args);
1767 error_no_arg ("format-control string and values to print");
1769 /* Skip white space before format string */
1770 while (*s == ' ' || *s == '\t') s++;
1772 /* A format string should follow, enveloped in double quotes */
1774 error ("Bad format string, missing '\"'.");
1776 /* Parse the format-control string and copy it into the string STRING,
1777 processing some kinds of escape sequence. */
1779 f = string = (char *) alloca (strlen (s) + 1);
1787 error ("Bad format string, non-terminated '\"'.");
1799 *f++ = '\007'; /* Bell */
1824 /* ??? TODO: handle other escape sequences */
1825 error ("Unrecognized escape character \\%c in format string.",
1835 /* Skip over " and following space and comma. */
1838 while (*s == ' ' || *s == '\t') s++;
1840 if (*s != ',' && *s != 0)
1841 error ("Invalid argument syntax");
1844 while (*s == ' ' || *s == '\t') s++;
1846 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1847 substrings = alloca (strlen (string) * 2);
1848 current_substring = substrings;
1851 /* Now scan the string for %-specs and see what kinds of args they want.
1852 argclass[I] classifies the %-specs so we can give vprintf_unfiltered something
1853 of the right size. */
1855 enum argclass {no_arg, int_arg, string_arg, double_arg, long_long_arg};
1856 enum argclass *argclass;
1857 enum argclass this_argclass;
1863 argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
1871 while (strchr ("0123456789.hlL-+ #", *f))
1873 if (*f == 'l' || *f == 'L')
1880 this_argclass = string_arg;
1886 this_argclass = double_arg;
1890 error ("`*' not supported for precision or width in printf");
1893 error ("Format specifier `n' not supported in printf");
1896 this_argclass = no_arg;
1901 this_argclass = long_long_arg;
1903 this_argclass = int_arg;
1907 if (this_argclass != no_arg)
1909 strncpy (current_substring, last_arg, f - last_arg);
1910 current_substring += f - last_arg;
1911 *current_substring++ = '\0';
1913 argclass[nargs_wanted++] = this_argclass;
1917 /* Now, parse all arguments and evaluate them.
1918 Store the VALUEs in VAL_ARGS. */
1923 if (nargs == allocated_args)
1924 val_args = (value_ptr *) xrealloc ((char *) val_args,
1925 (allocated_args *= 2)
1926 * sizeof (value_ptr));
1928 val_args[nargs] = parse_to_comma_and_eval (&s1);
1930 /* If format string wants a float, unchecked-convert the value to
1931 floating point of the same size */
1933 if (argclass[nargs] == double_arg)
1935 if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (float))
1936 VALUE_TYPE (val_args[nargs]) = builtin_type_float;
1937 if (TYPE_LENGTH (VALUE_TYPE (val_args[nargs])) == sizeof (double))
1938 VALUE_TYPE (val_args[nargs]) = builtin_type_double;
1946 if (nargs != nargs_wanted)
1947 error ("Wrong number of arguments for specified format-string");
1949 /* FIXME: We should be using vprintf_filtered, but as long as it
1950 has an arbitrary limit that is unacceptable. Correct fix is
1951 for vprintf_filtered to scan down the format string so it knows
1952 how big a buffer it needs (perhaps by putting a vasprintf (see
1953 GNU C library) in libiberty).
1955 But for now, just force out any pending output, so at least the output
1956 appears in the correct order. */
1957 wrap_here ((char *)NULL);
1959 /* Now actually print them. */
1960 current_substring = substrings;
1961 for (i = 0; i < nargs; i++)
1963 switch (argclass[i])
1970 tem = value_as_pointer (val_args[i]);
1972 /* This is a %s argument. Find the length of the string. */
1977 read_memory (tem + j, &c, 1);
1982 /* Copy the string contents into a string inside GDB. */
1983 str = (char *) alloca (j + 1);
1984 read_memory (tem, str, j);
1987 /* Don't use printf_filtered because of arbitrary limit. */
1988 printf_unfiltered (current_substring, str);
1993 double val = value_as_double (val_args[i]);
1994 /* Don't use printf_filtered because of arbitrary limit. */
1995 printf_unfiltered (current_substring, val);
1999 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2001 long long val = value_as_long (val_args[i]);
2002 /* Don't use printf_filtered because of arbitrary limit. */
2003 printf_unfiltered (current_substring, val);
2007 error ("long long not supported in printf");
2011 /* FIXME: there should be separate int_arg and long_arg. */
2012 long val = value_as_long (val_args[i]);
2013 /* Don't use printf_filtered because of arbitrary limit. */
2014 printf_unfiltered (current_substring, val);
2018 error ("internal error in printf_command");
2020 /* Skip to the next substring. */
2021 current_substring += strlen (current_substring) + 1;
2023 /* Print the portion of the format string after the last argument. */
2024 /* It would be OK to use printf_filtered here. */
2027 do_cleanups (old_cleanups);
2030 /* Dump a specified section of assembly code. With no command line
2031 arguments, this command will dump the assembly code for the
2032 function surrounding the pc value in the selected frame. With one
2033 argument, it will dump the assembly code surrounding that pc value.
2034 Two arguments are interpeted as bounds within which to dump
2039 disassemble_command (arg, from_tty)
2043 CORE_ADDR low, high;
2051 if (!selected_frame)
2052 error ("No frame selected.\n");
2054 pc = get_frame_pc (selected_frame);
2055 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
2056 error ("No function contains program counter for selected frame.\n");
2058 else if (!(space_index = (char *) strchr (arg, ' ')))
2061 pc = parse_and_eval_address (arg);
2062 if (find_pc_partial_function (pc, &name, &low, &high) == 0)
2063 error ("No function contains specified address.\n");
2067 /* Two arguments. */
2068 *space_index = '\0';
2069 low = parse_and_eval_address (arg);
2070 high = parse_and_eval_address (space_index + 1);
2073 printf_filtered ("Dump of assembler code ");
2076 printf_filtered ("for function %s:\n", name);
2080 printf_filtered ("from ");
2081 print_address_numeric (low, 1, gdb_stdout);
2082 printf_filtered (" to ");
2083 print_address_numeric (high, 1, gdb_stdout);
2084 printf_filtered (":\n");
2087 /* Dump the specified range. */
2088 for (pc = low; pc < high; )
2091 print_address (pc, gdb_stdout);
2092 printf_filtered (":\t");
2093 /* We often wrap here if there are long symbolic names. */
2095 pc += print_insn (pc, gdb_stdout);
2096 printf_filtered ("\n");
2098 printf_filtered ("End of assembler dump.\n");
2099 gdb_flush (gdb_stdout);
2104 _initialize_printcmd ()
2106 current_display_number = -1;
2108 add_info ("address", address_info,
2109 "Describe where variable VAR is stored.");
2111 add_com ("x", class_vars, x_command,
2112 "Examine memory: x/FMT ADDRESS.\n\
2113 ADDRESS is an expression for the memory address to examine.\n\
2114 FMT is a repeat count followed by a format letter and a size letter.\n\
2115 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2116 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2117 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2118 The specified number of objects of the specified size are printed\n\
2119 according to the format.\n\n\
2120 Defaults for format and size letters are those previously used.\n\
2121 Default count is 1. Default address is following last thing printed\n\
2122 with this command or \"print\".");
2124 add_com ("disassemble", class_vars, disassemble_command,
2125 "Disassemble a specified section of memory.\n\
2126 Default is the function surrounding the pc of the selected frame.\n\
2127 With a single argument, the function surrounding that address is dumped.\n\
2128 Two arguments are taken as a range of memory to dump.");
2131 add_com ("whereis", class_vars, whereis_command,
2132 "Print line number and file of definition of variable.");
2135 add_info ("display", display_info,
2136 "Expressions to display when program stops, with code numbers.");
2138 add_cmd ("undisplay", class_vars, undisplay_command,
2139 "Cancel some expressions to be displayed when program stops.\n\
2140 Arguments are the code numbers of the expressions to stop displaying.\n\
2141 No argument means cancel all automatic-display expressions.\n\
2142 \"delete display\" has the same effect as this command.\n\
2143 Do \"info display\" to see current list of code numbers.",
2146 add_com ("display", class_vars, display_command,
2147 "Print value of expression EXP each time the program stops.\n\
2148 /FMT may be used before EXP as in the \"print\" command.\n\
2149 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2150 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2151 and examining is done as in the \"x\" command.\n\n\
2152 With no argument, display all currently requested auto-display expressions.\n\
2153 Use \"undisplay\" to cancel display requests previously made.");
2155 add_cmd ("display", class_vars, enable_display,
2156 "Enable some expressions to be displayed when program stops.\n\
2157 Arguments are the code numbers of the expressions to resume displaying.\n\
2158 No argument means enable all automatic-display expressions.\n\
2159 Do \"info display\" to see current list of code numbers.", &enablelist);
2161 add_cmd ("display", class_vars, disable_display_command,
2162 "Disable some expressions to be displayed when program stops.\n\
2163 Arguments are the code numbers of the expressions to stop displaying.\n\
2164 No argument means disable all automatic-display expressions.\n\
2165 Do \"info display\" to see current list of code numbers.", &disablelist);
2167 add_cmd ("display", class_vars, undisplay_command,
2168 "Cancel some expressions to be displayed when program stops.\n\
2169 Arguments are the code numbers of the expressions to stop displaying.\n\
2170 No argument means cancel all automatic-display expressions.\n\
2171 Do \"info display\" to see current list of code numbers.", &deletelist);
2173 add_com ("printf", class_vars, printf_command,
2174 "printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2175 This is useful for formatted output in user-defined commands.");
2176 add_com ("output", class_vars, output_command,
2177 "Like \"print\" but don't put in value history and don't print newline.\n\
2178 This is useful in user-defined commands.");
2180 add_prefix_cmd ("set", class_vars, set_command,
2181 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2182 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2183 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2184 with $), a register (a few standard names starting with $), or an actual\n\
2185 variable in the program being debugged. EXP is any valid expression.\n\
2186 Use \"set variable\" for variables with names identical to set subcommands.\n\
2187 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2188 You can see these environment settings with the \"show\" command.",
2189 &setlist, "set ", 1, &cmdlist);
2191 /* "call" is the same as "set", but handy for dbx users to call fns. */
2192 add_com ("call", class_vars, call_command,
2193 "Call a function in the program.\n\
2194 The argument is the function name and arguments, in the notation of the\n\
2195 current working language. The result is printed and saved in the value\n\
2196 history, if it is not void.");
2198 add_cmd ("variable", class_vars, set_command,
2199 "Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2200 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2201 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2202 with $), a register (a few standard names starting with $), or an actual\n\
2203 variable in the program being debugged. EXP is any valid expression.\n\
2204 This may usually be abbreviated to simply \"set\".",
2207 add_com ("print", class_vars, print_command,
2208 concat ("Print value of expression EXP.\n\
2209 Variables accessible are those of the lexical environment of the selected\n\
2210 stack frame, plus all those whose scope is global or an entire file.\n\
2212 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2213 $$NUM refers to NUM'th value back from the last one.\n\
2214 Names starting with $ refer to registers (with the values they would have\n\
2215 if the program were to return to the stack frame now selected, restoring\n\
2216 all registers saved by frames farther in) or else to debugger\n\
2217 \"convenience\" variables (any such name not a known register).\n\
2218 Use assignment expressions to give values to convenience variables.\n",
2220 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2221 @ is a binary operator for treating consecutive data objects\n\
2222 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2223 element is FOO, whose second element is stored in the space following\n\
2224 where FOO is stored, etc. FOO must be an expression whose value\n\
2225 resides in memory.\n",
2227 EXP may be preceded with /FMT, where FMT is a format letter\n\
2228 but no count or size letter (see \"x\" command).", NULL));
2229 add_com_alias ("p", "print", class_vars, 1);
2231 add_com ("inspect", class_vars, inspect_command,
2232 "Same as \"print\" command, except that if you are running in the epoch\n\
2233 environment, the value is printed in its own window.");
2236 add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,
2237 (char *)&max_symbolic_offset,
2238 "Set the largest offset that will be printed in <symbol+1234> form.",
2242 add_set_cmd ("symbol-filename", no_class, var_boolean,
2243 (char *)&print_symbol_filename,
2244 "Set printing of source filename and line number with <symbol>.",
2248 examine_b_type = init_type (TYPE_CODE_INT, 1, 0, NULL, NULL);
2249 examine_h_type = init_type (TYPE_CODE_INT, 2, 0, NULL, NULL);
2250 examine_w_type = init_type (TYPE_CODE_INT, 4, 0, NULL, NULL);
2251 examine_g_type = init_type (TYPE_CODE_INT, 8, 0, NULL, NULL);