1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
35 #include "floatformat.h"
40 /* Prototypes for local functions */
42 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
43 int len, int *errnoptr);
45 static void show_print (char *, int);
47 static void set_print (char *, int);
49 static void set_radix (char *, int);
51 static void show_radix (char *, int);
53 static void set_input_radix (char *, int, struct cmd_list_element *);
55 static void set_input_radix_1 (int, unsigned);
57 static void set_output_radix (char *, int, struct cmd_list_element *);
59 static void set_output_radix_1 (int, unsigned);
61 void _initialize_valprint (void);
63 /* Maximum number of chars to print for a string pointer value or vector
64 contents, or UINT_MAX for no limit. Note that "set print elements 0"
65 stores UINT_MAX in print_max, which displays in a show command as
68 unsigned int print_max;
69 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
71 show_print_max (struct ui_file *file, int from_tty,
72 struct cmd_list_element *c, const char *value)
74 fprintf_filtered (file, _("\
75 Limit on string chars or array elements to print is %s.\n"),
80 /* Default input and output radixes, and output format letter. */
82 unsigned input_radix = 10;
84 show_input_radix (struct ui_file *file, int from_tty,
85 struct cmd_list_element *c, const char *value)
87 fprintf_filtered (file, _("\
88 Default input radix for entering numbers is %s.\n"),
92 unsigned output_radix = 10;
94 show_output_radix (struct ui_file *file, int from_tty,
95 struct cmd_list_element *c, const char *value)
97 fprintf_filtered (file, _("\
98 Default output radix for printing of values is %s.\n"),
101 int output_format = 0;
103 /* By default we print arrays without printing the index of each element in
104 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
106 static int print_array_indexes = 0;
108 show_print_array_indexes (struct ui_file *file, int from_tty,
109 struct cmd_list_element *c, const char *value)
111 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
114 /* Print repeat counts if there are more than this many repetitions of an
115 element in an array. Referenced by the low level language dependent
118 unsigned int repeat_count_threshold = 10;
120 show_repeat_count_threshold (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c, const char *value)
123 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
127 /* If nonzero, stops printing of char arrays at first null. */
129 int stop_print_at_null;
131 show_stop_print_at_null (struct ui_file *file, int from_tty,
132 struct cmd_list_element *c, const char *value)
134 fprintf_filtered (file, _("\
135 Printing of char arrays to stop at first null char is %s.\n"),
139 /* Controls pretty printing of structures. */
141 int prettyprint_structs;
143 show_prettyprint_structs (struct ui_file *file, int from_tty,
144 struct cmd_list_element *c, const char *value)
146 fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
149 /* Controls pretty printing of arrays. */
151 int prettyprint_arrays;
153 show_prettyprint_arrays (struct ui_file *file, int from_tty,
154 struct cmd_list_element *c, const char *value)
156 fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
159 /* If nonzero, causes unions inside structures or other unions to be
162 int unionprint; /* Controls printing of nested unions. */
164 show_unionprint (struct ui_file *file, int from_tty,
165 struct cmd_list_element *c, const char *value)
167 fprintf_filtered (file, _("\
168 Printing of unions interior to structures is %s.\n"),
172 /* If nonzero, causes machine addresses to be printed in certain contexts. */
174 int addressprint; /* Controls printing of machine addresses */
176 show_addressprint (struct ui_file *file, int from_tty,
177 struct cmd_list_element *c, const char *value)
179 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
183 /* Print data of type TYPE located at VALADDR (within GDB), which came from
184 the inferior at address ADDRESS, onto stdio stream STREAM according to
185 FORMAT (a letter, or 0 for natural format using TYPE).
187 If DEREF_REF is nonzero, then dereference references, otherwise just print
190 The PRETTY parameter controls prettyprinting.
192 If the data are a string pointer, returns the number of string characters
195 FIXME: The data at VALADDR is in target byte order. If gdb is ever
196 enhanced to be able to debug more than the single target it was compiled
197 for (specific CPU type and thus specific target byte ordering), then
198 either the print routines are going to have to take this into account,
199 or the data is going to have to be passed into here already converted
200 to the host byte ordering, whichever is more convenient. */
204 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
205 CORE_ADDR address, struct ui_file *stream, int format,
206 int deref_ref, int recurse, enum val_prettyprint pretty)
208 struct type *real_type = check_typedef (type);
209 if (pretty == Val_pretty_default)
211 pretty = prettyprint_structs ? Val_prettyprint : Val_no_prettyprint;
216 /* Ensure that the type is complete and not just a stub. If the type is
217 only a stub and we can't find and substitute its complete type, then
218 print appropriate string and return. */
220 if (TYPE_STUB (real_type))
222 fprintf_filtered (stream, "<incomplete type>");
227 return (LA_VAL_PRINT (type, valaddr, embedded_offset, address,
228 stream, format, deref_ref, recurse, pretty));
231 /* Check whether the value VAL is printable. Return 1 if it is;
232 return 0 and print an appropriate error message to STREAM if it
236 value_check_printable (struct value *val, struct ui_file *stream)
240 fprintf_filtered (stream, _("<address of value unknown>"));
244 if (value_optimized_out (val))
246 fprintf_filtered (stream, _("<value optimized out>"));
253 /* Print the value VAL onto stream STREAM according to FORMAT (a
254 letter, or 0 for natural format using TYPE).
256 If DEREF_REF is nonzero, then dereference references, otherwise just print
259 The PRETTY parameter controls prettyprinting.
261 If the data are a string pointer, returns the number of string characters
264 This is a preferable interface to val_print, above, because it uses
265 GDB's value mechanism. */
268 common_val_print (struct value *val, struct ui_file *stream, int format,
269 int deref_ref, int recurse, enum val_prettyprint pretty)
271 if (!value_check_printable (val, stream))
274 return val_print (value_type (val), value_contents_all (val),
275 value_embedded_offset (val), VALUE_ADDRESS (val),
276 stream, format, deref_ref, recurse, pretty);
279 /* Print the value VAL in C-ish syntax on stream STREAM.
280 FORMAT is a format-letter, or 0 for print in natural format of data type.
281 If the object printed is a string pointer, returns
282 the number of string bytes printed. */
285 value_print (struct value *val, struct ui_file *stream, int format,
286 enum val_prettyprint pretty)
288 if (!value_check_printable (val, stream))
291 return LA_VALUE_PRINT (val, stream, format, pretty);
294 /* Called by various <lang>_val_print routines to print
295 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
296 value. STREAM is where to print the value. */
299 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
300 struct ui_file *stream)
302 if (TYPE_LENGTH (type) > sizeof (LONGEST))
306 if (TYPE_UNSIGNED (type)
307 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
310 print_longest (stream, 'u', 0, val);
314 /* Signed, or we couldn't turn an unsigned value into a
315 LONGEST. For signed values, one could assume two's
316 complement (a reasonable assumption, I think) and do
318 print_hex_chars (stream, (unsigned char *) valaddr,
324 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
325 unpack_long (type, valaddr));
330 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
331 struct ui_file *stream)
333 LONGEST val = unpack_long (type, valaddr);
334 int bitpos, nfields = TYPE_NFIELDS (type);
336 fputs_filtered ("[ ", stream);
337 for (bitpos = 0; bitpos < nfields; bitpos++)
339 if (TYPE_FIELD_BITPOS (type, bitpos) != -1 && (val & (1 << bitpos)))
341 if (TYPE_FIELD_NAME (type, bitpos))
342 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
344 fprintf_filtered (stream, "#%d ", bitpos);
347 fputs_filtered ("]", stream);
350 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
351 The raison d'etre of this function is to consolidate printing of
352 LONG_LONG's into this one function. The format chars b,h,w,g are
353 from print_scalar_formatted(). Numbers are printed using C
356 USE_C_FORMAT means to use C format in all cases. Without it,
357 'o' and 'x' format do not include the standard C radix prefix
360 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
361 and was intended to request formating according to the current
362 language and would be used for most integers that GDB prints. The
363 exceptional cases were things like protocols where the format of
364 the integer is a protocol thing, not a user-visible thing). The
365 parameter remains to preserve the information of what things might
366 be printed with language-specific format, should we ever resurrect
370 print_longest (struct ui_file *stream, int format, int use_c_format,
378 val = int_string (val_long, 10, 1, 0, 1); break;
380 val = int_string (val_long, 10, 0, 0, 1); break;
382 val = int_string (val_long, 16, 0, 0, use_c_format); break;
384 val = int_string (val_long, 16, 0, 2, 1); break;
386 val = int_string (val_long, 16, 0, 4, 1); break;
388 val = int_string (val_long, 16, 0, 8, 1); break;
390 val = int_string (val_long, 16, 0, 16, 1); break;
393 val = int_string (val_long, 8, 0, 0, use_c_format); break;
395 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
397 fputs_filtered (val, stream);
400 /* This used to be a macro, but I don't think it is called often enough
401 to merit such treatment. */
402 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
403 arguments to a function, number in a value history, register number, etc.)
404 where the value must not be larger than can fit in an int. */
407 longest_to_int (LONGEST arg)
409 /* Let the compiler do the work */
410 int rtnval = (int) arg;
412 /* Check for overflows or underflows */
413 if (sizeof (LONGEST) > sizeof (int))
417 error (_("Value out of range."));
423 /* Print a floating point value of type TYPE (not always a
424 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
427 print_floating (const gdb_byte *valaddr, struct type *type,
428 struct ui_file *stream)
432 const struct floatformat *fmt = NULL;
433 unsigned len = TYPE_LENGTH (type);
435 /* If it is a floating-point, check for obvious problems. */
436 if (TYPE_CODE (type) == TYPE_CODE_FLT)
437 fmt = floatformat_from_type (type);
438 if (fmt != NULL && floatformat_is_nan (fmt, valaddr))
440 if (floatformat_is_negative (fmt, valaddr))
441 fprintf_filtered (stream, "-");
442 fprintf_filtered (stream, "nan(");
443 fputs_filtered ("0x", stream);
444 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
445 fprintf_filtered (stream, ")");
449 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
450 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
451 needs to be used as that takes care of any necessary type
452 conversions. Such conversions are of course direct to DOUBLEST
453 and disregard any possible target floating point limitations.
454 For instance, a u64 would be converted and displayed exactly on a
455 host with 80 bit DOUBLEST but with loss of information on a host
456 with 64 bit DOUBLEST. */
458 doub = unpack_double (type, valaddr, &inv);
461 fprintf_filtered (stream, "<invalid float value>");
465 /* FIXME: kettenis/2001-01-20: The following code makes too much
466 assumptions about the host and target floating point format. */
468 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
469 not necessarily be a TYPE_CODE_FLT, the below ignores that and
470 instead uses the type's length to determine the precision of the
471 floating-point value being printed. */
473 if (len < sizeof (double))
474 fprintf_filtered (stream, "%.9g", (double) doub);
475 else if (len == sizeof (double))
476 fprintf_filtered (stream, "%.17g", (double) doub);
478 #ifdef PRINTF_HAS_LONG_DOUBLE
479 fprintf_filtered (stream, "%.35Lg", doub);
481 /* This at least wins with values that are representable as
483 fprintf_filtered (stream, "%.17g", (double) doub);
488 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
492 #define BITS_IN_BYTES 8
498 /* Declared "int" so it will be signed.
499 * This ensures that right shift will shift in zeros.
501 const int mask = 0x080;
503 /* FIXME: We should be not printing leading zeroes in most cases. */
505 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
511 /* Every byte has 8 binary characters; peel off
512 * and print from the MSB end.
514 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
516 if (*p & (mask >> i))
521 fprintf_filtered (stream, "%1d", b);
527 for (p = valaddr + len - 1;
531 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
533 if (*p & (mask >> i))
538 fprintf_filtered (stream, "%1d", b);
544 /* VALADDR points to an integer of LEN bytes.
545 * Print it in octal on stream or format it in buf.
548 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
552 unsigned char octa1, octa2, octa3, carry;
555 /* FIXME: We should be not printing leading zeroes in most cases. */
558 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
559 * the extra bits, which cycle every three bytes:
563 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
565 * Octal side: 0 1 carry 3 4 carry ...
567 * Cycle number: 0 1 2
569 * But of course we are printing from the high side, so we have to
570 * figure out where in the cycle we are so that we end up with no
571 * left over bits at the end.
573 #define BITS_IN_OCTAL 3
574 #define HIGH_ZERO 0340
575 #define LOW_ZERO 0016
576 #define CARRY_ZERO 0003
577 #define HIGH_ONE 0200
580 #define CARRY_ONE 0001
581 #define HIGH_TWO 0300
585 /* For 32 we start in cycle 2, with two bits and one bit carry;
586 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
588 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
591 fputs_filtered ("0", stream);
592 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
601 /* No carry in, carry out two bits.
603 octa1 = (HIGH_ZERO & *p) >> 5;
604 octa2 = (LOW_ZERO & *p) >> 2;
605 carry = (CARRY_ZERO & *p);
606 fprintf_filtered (stream, "%o", octa1);
607 fprintf_filtered (stream, "%o", octa2);
611 /* Carry in two bits, carry out one bit.
613 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
614 octa2 = (MID_ONE & *p) >> 4;
615 octa3 = (LOW_ONE & *p) >> 1;
616 carry = (CARRY_ONE & *p);
617 fprintf_filtered (stream, "%o", octa1);
618 fprintf_filtered (stream, "%o", octa2);
619 fprintf_filtered (stream, "%o", octa3);
623 /* Carry in one bit, no carry out.
625 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
626 octa2 = (MID_TWO & *p) >> 3;
627 octa3 = (LOW_TWO & *p);
629 fprintf_filtered (stream, "%o", octa1);
630 fprintf_filtered (stream, "%o", octa2);
631 fprintf_filtered (stream, "%o", octa3);
635 error (_("Internal error in octal conversion;"));
639 cycle = cycle % BITS_IN_OCTAL;
644 for (p = valaddr + len - 1;
651 /* Carry out, no carry in */
652 octa1 = (HIGH_ZERO & *p) >> 5;
653 octa2 = (LOW_ZERO & *p) >> 2;
654 carry = (CARRY_ZERO & *p);
655 fprintf_filtered (stream, "%o", octa1);
656 fprintf_filtered (stream, "%o", octa2);
660 /* Carry in, carry out */
661 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
662 octa2 = (MID_ONE & *p) >> 4;
663 octa3 = (LOW_ONE & *p) >> 1;
664 carry = (CARRY_ONE & *p);
665 fprintf_filtered (stream, "%o", octa1);
666 fprintf_filtered (stream, "%o", octa2);
667 fprintf_filtered (stream, "%o", octa3);
671 /* Carry in, no carry out */
672 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
673 octa2 = (MID_TWO & *p) >> 3;
674 octa3 = (LOW_TWO & *p);
676 fprintf_filtered (stream, "%o", octa1);
677 fprintf_filtered (stream, "%o", octa2);
678 fprintf_filtered (stream, "%o", octa3);
682 error (_("Internal error in octal conversion;"));
686 cycle = cycle % BITS_IN_OCTAL;
692 /* VALADDR points to an integer of LEN bytes.
693 * Print it in decimal on stream or format it in buf.
696 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
700 #define TWO_TO_FOURTH 16
701 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
702 #define CARRY_LEFT( x ) ((x) % TEN)
703 #define SHIFT( x ) ((x) << 4)
705 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
707 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
709 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? p++ : p-- )
710 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
711 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
714 unsigned char *digits;
717 int i, j, decimal_digits;
721 /* Base-ten number is less than twice as many digits
722 * as the base 16 number, which is 2 digits per byte.
724 decimal_len = len * 2 * 2;
725 digits = xmalloc (decimal_len);
727 for (i = 0; i < decimal_len; i++)
732 /* Ok, we have an unknown number of bytes of data to be printed in
735 * Given a hex number (in nibbles) as XYZ, we start by taking X and
736 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
737 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
739 * The trick is that "digits" holds a base-10 number, but sometimes
740 * the individual digits are > 10.
742 * Outer loop is per nibble (hex digit) of input, from MSD end to
745 decimal_digits = 0; /* Number of decimal digits so far */
751 * Multiply current base-ten number by 16 in place.
752 * Each digit was between 0 and 9, now is between
755 for (j = 0; j < decimal_digits; j++)
757 digits[j] = SHIFT (digits[j]);
760 /* Take the next nibble off the input and add it to what
761 * we've got in the LSB position. Bottom 'digit' is now
764 * "flip" is used to run this loop twice for each byte.
770 digits[0] += HIGH_NIBBLE (*p);
775 /* Take low nibble and bump our pointer "p".
777 digits[0] += LOW_NIBBLE (*p);
782 /* Re-decimalize. We have to do this often enough
783 * that we don't overflow, but once per nibble is
784 * overkill. Easier this way, though. Note that the
785 * carry is often larger than 10 (e.g. max initial
786 * carry out of lowest nibble is 15, could bubble all
787 * the way up greater than 10). So we have to do
788 * the carrying beyond the last current digit.
791 for (j = 0; j < decimal_len - 1; j++)
795 /* "/" won't handle an unsigned char with
796 * a value that if signed would be negative.
797 * So extend to longword int via "dummy".
800 carry = CARRY_OUT (dummy);
801 digits[j] = CARRY_LEFT (dummy);
803 if (j >= decimal_digits && carry == 0)
806 * All higher digits are 0 and we
807 * no longer have a carry.
809 * Note: "j" is 0-based, "decimal_digits" is
812 decimal_digits = j + 1;
818 /* Ok, now "digits" is the decimal representation, with
819 * the "decimal_digits" actual digits. Print!
821 for (i = decimal_digits - 1; i >= 0; i--)
823 fprintf_filtered (stream, "%1d", digits[i]);
828 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
831 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
836 /* FIXME: We should be not printing leading zeroes in most cases. */
838 fputs_filtered ("0x", stream);
839 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
845 fprintf_filtered (stream, "%02x", *p);
850 for (p = valaddr + len - 1;
854 fprintf_filtered (stream, "%02x", *p);
859 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
860 Omit any leading zero chars. */
863 print_char_chars (struct ui_file *stream, const gdb_byte *valaddr,
868 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
871 while (p < valaddr + len - 1 && *p == 0)
874 while (p < valaddr + len)
876 LA_EMIT_CHAR (*p, stream, '\'');
882 p = valaddr + len - 1;
883 while (p > valaddr && *p == 0)
888 LA_EMIT_CHAR (*p, stream, '\'');
894 /* Return non-zero if the debugger should print the index of each element
895 when printing array values. */
898 print_array_indexes_p (void)
900 return print_array_indexes;
903 /* Assuming TYPE is a simple, non-empty array type, compute its lower bound.
904 Save it into LOW_BOUND if not NULL.
906 Return 1 if the operation was successful. Return zero otherwise,
907 in which case the value of LOW_BOUND is unmodified.
909 Computing the array lower bound is pretty easy, but this function
910 does some additional verifications before returning the low bound.
911 If something incorrect is detected, it is better to return a status
912 rather than throwing an error, making it easier for the caller to
913 implement an error-recovery plan. For instance, it may decide to
914 warn the user that the bound was not found and then use a default
918 get_array_low_bound (struct type *type, long *low_bound)
920 struct type *index = TYPE_INDEX_TYPE (type);
926 if (TYPE_CODE (index) != TYPE_CODE_RANGE
927 && TYPE_CODE (index) != TYPE_CODE_ENUM)
930 low = TYPE_LOW_BOUND (index);
931 if (low > TYPE_HIGH_BOUND (index))
940 /* Print on STREAM using the given FORMAT the index for the element
941 at INDEX of an array whose index type is INDEX_TYPE. */
944 maybe_print_array_index (struct type *index_type, LONGEST index,
945 struct ui_file *stream, int format,
946 enum val_prettyprint pretty)
948 struct value *index_value;
950 if (!print_array_indexes)
953 index_value = value_from_longest (index_type, index);
955 LA_PRINT_ARRAY_INDEX (index_value, stream, format, pretty);
958 /* Called by various <lang>_val_print routines to print elements of an
959 array in the form "<elem1>, <elem2>, <elem3>, ...".
961 (FIXME?) Assumes array element separator is a comma, which is correct
962 for all languages currently handled.
963 (FIXME?) Some languages have a notation for repeated array elements,
964 perhaps we should try to use that notation when appropriate.
968 val_print_array_elements (struct type *type, const gdb_byte *valaddr,
969 CORE_ADDR address, struct ui_file *stream,
970 int format, int deref_ref,
971 int recurse, enum val_prettyprint pretty,
974 unsigned int things_printed = 0;
976 struct type *elttype, *index_type;
978 /* Position of the array element we are examining to see
979 whether it is repeated. */
981 /* Number of repetitions we have detected so far. */
983 long low_bound_index = 0;
985 elttype = TYPE_TARGET_TYPE (type);
986 eltlen = TYPE_LENGTH (check_typedef (elttype));
987 len = TYPE_LENGTH (type) / eltlen;
988 index_type = TYPE_INDEX_TYPE (type);
990 /* Get the array low bound. This only makes sense if the array
991 has one or more element in it. */
992 if (len > 0 && !get_array_low_bound (type, &low_bound_index))
994 warning ("unable to get low bound of array, using zero as default");
998 annotate_array_section_begin (i, elttype);
1000 for (; i < len && things_printed < print_max; i++)
1004 if (prettyprint_arrays)
1006 fprintf_filtered (stream, ",\n");
1007 print_spaces_filtered (2 + 2 * recurse, stream);
1011 fprintf_filtered (stream, ", ");
1014 wrap_here (n_spaces (2 + 2 * recurse));
1015 maybe_print_array_index (index_type, i + low_bound_index,
1016 stream, format, pretty);
1020 while ((rep1 < len) &&
1021 !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1027 if (reps > repeat_count_threshold)
1029 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1030 deref_ref, recurse + 1, pretty);
1031 annotate_elt_rep (reps);
1032 fprintf_filtered (stream, " <repeats %u times>", reps);
1033 annotate_elt_rep_end ();
1036 things_printed += repeat_count_threshold;
1040 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1041 deref_ref, recurse + 1, pretty);
1046 annotate_array_section_end ();
1049 fprintf_filtered (stream, "...");
1053 /* Read LEN bytes of target memory at address MEMADDR, placing the
1054 results in GDB's memory at MYADDR. Returns a count of the bytes
1055 actually read, and optionally an errno value in the location
1056 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1058 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1059 function be eliminated. */
1062 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr)
1064 int nread; /* Number of bytes actually read. */
1065 int errcode; /* Error from last read. */
1067 /* First try a complete read. */
1068 errcode = target_read_memory (memaddr, myaddr, len);
1076 /* Loop, reading one byte at a time until we get as much as we can. */
1077 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1079 errcode = target_read_memory (memaddr++, myaddr++, 1);
1081 /* If an error, the last read was unsuccessful, so adjust count. */
1087 if (errnoptr != NULL)
1089 *errnoptr = errcode;
1094 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1095 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1096 stops at the first null byte, otherwise printing proceeds (including null
1097 bytes) until either print_max or LEN characters have been printed,
1098 whichever is smaller. */
1100 /* FIXME: Use target_read_string. */
1103 val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream)
1105 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
1106 int errcode; /* Errno returned from bad reads. */
1107 unsigned int fetchlimit; /* Maximum number of chars to print. */
1108 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1109 unsigned int chunksize; /* Size of each fetch, in chars. */
1110 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
1111 gdb_byte *bufptr; /* Pointer to next available byte in buffer. */
1112 gdb_byte *limit; /* First location past end of fetch buffer. */
1113 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1114 int found_nul; /* Non-zero if we found the nul char */
1116 /* First we need to figure out the limit on the number of characters we are
1117 going to attempt to fetch and print. This is actually pretty simple. If
1118 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1119 LEN is -1, then the limit is print_max. This is true regardless of
1120 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1121 because finding the null byte (or available memory) is what actually
1122 limits the fetch. */
1124 fetchlimit = (len == -1 ? print_max : min (len, print_max));
1126 /* Now decide how large of chunks to try to read in one operation. This
1127 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1128 so we might as well read them all in one operation. If LEN is -1, we
1129 are looking for a null terminator to end the fetching, so we might as
1130 well read in blocks that are large enough to be efficient, but not so
1131 large as to be slow if fetchlimit happens to be large. So we choose the
1132 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1133 200 is way too big for remote debugging over a serial line. */
1135 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1137 /* Loop until we either have all the characters to print, or we encounter
1138 some error, such as bumping into the end of the address space. */
1141 old_chain = make_cleanup (null_cleanup, 0);
1145 buffer = (gdb_byte *) xmalloc (len * width);
1147 old_chain = make_cleanup (xfree, buffer);
1149 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1151 addr += nfetch * width;
1152 bufptr += nfetch * width;
1156 unsigned long bufsize = 0;
1160 nfetch = min (chunksize, fetchlimit - bufsize);
1163 buffer = (gdb_byte *) xmalloc (nfetch * width);
1166 discard_cleanups (old_chain);
1167 buffer = (gdb_byte *) xrealloc (buffer, (nfetch + bufsize) * width);
1170 old_chain = make_cleanup (xfree, buffer);
1171 bufptr = buffer + bufsize * width;
1174 /* Read as much as we can. */
1175 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1178 /* Scan this chunk for the null byte that terminates the string
1179 to print. If found, we don't need to fetch any more. Note
1180 that bufptr is explicitly left pointing at the next character
1181 after the null byte, or at the next character after the end of
1184 limit = bufptr + nfetch * width;
1185 while (bufptr < limit)
1189 c = extract_unsigned_integer (bufptr, width);
1194 /* We don't care about any error which happened after
1195 the NULL terminator. */
1202 while (errcode == 0 /* no error */
1203 && bufptr - buffer < fetchlimit * width /* no overrun */
1204 && !found_nul); /* haven't found nul yet */
1207 { /* length of string is really 0! */
1208 buffer = bufptr = NULL;
1212 /* bufptr and addr now point immediately beyond the last byte which we
1213 consider part of the string (including a '\0' which ends the string). */
1215 /* We now have either successfully filled the buffer to fetchlimit, or
1216 terminated early due to an error or finding a null char when LEN is -1. */
1218 if (len == -1 && !found_nul)
1222 /* We didn't find a null terminator we were looking for. Attempt
1223 to peek at the next character. If not successful, or it is not
1224 a null byte, then force ellipsis to be printed. */
1226 peekbuf = (gdb_byte *) alloca (width);
1228 if (target_read_memory (addr, peekbuf, width) == 0
1229 && extract_unsigned_integer (peekbuf, width) != 0)
1232 else if ((len >= 0 && errcode != 0) || (len > (bufptr - buffer) / width))
1234 /* Getting an error when we have a requested length, or fetching less
1235 than the number of characters actually requested, always make us
1242 /* If we get an error before fetching anything, don't print a string.
1243 But if we fetch something and then get an error, print the string
1244 and then the error message. */
1245 if (errcode == 0 || bufptr > buffer)
1249 fputs_filtered (" ", stream);
1251 LA_PRINT_STRING (stream, buffer, (bufptr - buffer) / width, width, force_ellipsis);
1258 fprintf_filtered (stream, " <Address ");
1259 deprecated_print_address_numeric (addr, 1, stream);
1260 fprintf_filtered (stream, " out of bounds>");
1264 fprintf_filtered (stream, " <Error reading address ");
1265 deprecated_print_address_numeric (addr, 1, stream);
1266 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1270 do_cleanups (old_chain);
1271 return ((bufptr - buffer) / width);
1275 /* Validate an input or output radix setting, and make sure the user
1276 knows what they really did here. Radix setting is confusing, e.g.
1277 setting the input radix to "10" never changes it! */
1280 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
1282 set_input_radix_1 (from_tty, input_radix);
1286 set_input_radix_1 (int from_tty, unsigned radix)
1288 /* We don't currently disallow any input radix except 0 or 1, which don't
1289 make any mathematical sense. In theory, we can deal with any input
1290 radix greater than 1, even if we don't have unique digits for every
1291 value from 0 to radix-1, but in practice we lose on large radix values.
1292 We should either fix the lossage or restrict the radix range more.
1297 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1299 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1302 input_radix = radix;
1305 printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1306 radix, radix, radix);
1311 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
1313 set_output_radix_1 (from_tty, output_radix);
1317 set_output_radix_1 (int from_tty, unsigned radix)
1319 /* Validate the radix and disallow ones that we aren't prepared to
1320 handle correctly, leaving the radix unchanged. */
1324 output_format = 'x'; /* hex */
1327 output_format = 0; /* decimal */
1330 output_format = 'o'; /* octal */
1333 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1335 error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1338 output_radix = radix;
1341 printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1342 radix, radix, radix);
1346 /* Set both the input and output radix at once. Try to set the output radix
1347 first, since it has the most restrictive range. An radix that is valid as
1348 an output radix is also valid as an input radix.
1350 It may be useful to have an unusual input radix. If the user wishes to
1351 set an input radix that is not valid as an output radix, he needs to use
1352 the 'set input-radix' command. */
1355 set_radix (char *arg, int from_tty)
1359 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
1360 set_output_radix_1 (0, radix);
1361 set_input_radix_1 (0, radix);
1364 printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1365 radix, radix, radix);
1369 /* Show both the input and output radices. */
1372 show_radix (char *arg, int from_tty)
1376 if (input_radix == output_radix)
1378 printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1379 input_radix, input_radix, input_radix);
1383 printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1384 input_radix, input_radix, input_radix);
1385 printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1386 output_radix, output_radix, output_radix);
1393 set_print (char *arg, int from_tty)
1396 "\"set print\" must be followed by the name of a print subcommand.\n");
1397 help_list (setprintlist, "set print ", -1, gdb_stdout);
1401 show_print (char *args, int from_tty)
1403 cmd_show_list (showprintlist, from_tty, "");
1407 _initialize_valprint (void)
1409 struct cmd_list_element *c;
1411 add_prefix_cmd ("print", no_class, set_print,
1412 _("Generic command for setting how things print."),
1413 &setprintlist, "set print ", 0, &setlist);
1414 add_alias_cmd ("p", "print", no_class, 1, &setlist);
1415 /* prefer set print to set prompt */
1416 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1418 add_prefix_cmd ("print", no_class, show_print,
1419 _("Generic command for showing print settings."),
1420 &showprintlist, "show print ", 0, &showlist);
1421 add_alias_cmd ("p", "print", no_class, 1, &showlist);
1422 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
1424 add_setshow_uinteger_cmd ("elements", no_class, &print_max, _("\
1425 Set limit on string chars or array elements to print."), _("\
1426 Show limit on string chars or array elements to print."), _("\
1427 \"set print elements 0\" causes there to be no limit."),
1430 &setprintlist, &showprintlist);
1432 add_setshow_boolean_cmd ("null-stop", no_class, &stop_print_at_null, _("\
1433 Set printing of char arrays to stop at first null char."), _("\
1434 Show printing of char arrays to stop at first null char."), NULL,
1436 show_stop_print_at_null,
1437 &setprintlist, &showprintlist);
1439 add_setshow_uinteger_cmd ("repeats", no_class,
1440 &repeat_count_threshold, _("\
1441 Set threshold for repeated print elements."), _("\
1442 Show threshold for repeated print elements."), _("\
1443 \"set print repeats 0\" causes all elements to be individually printed."),
1445 show_repeat_count_threshold,
1446 &setprintlist, &showprintlist);
1448 add_setshow_boolean_cmd ("pretty", class_support, &prettyprint_structs, _("\
1449 Set prettyprinting of structures."), _("\
1450 Show prettyprinting of structures."), NULL,
1452 show_prettyprint_structs,
1453 &setprintlist, &showprintlist);
1455 add_setshow_boolean_cmd ("union", class_support, &unionprint, _("\
1456 Set printing of unions interior to structures."), _("\
1457 Show printing of unions interior to structures."), NULL,
1460 &setprintlist, &showprintlist);
1462 add_setshow_boolean_cmd ("array", class_support, &prettyprint_arrays, _("\
1463 Set prettyprinting of arrays."), _("\
1464 Show prettyprinting of arrays."), NULL,
1466 show_prettyprint_arrays,
1467 &setprintlist, &showprintlist);
1469 add_setshow_boolean_cmd ("address", class_support, &addressprint, _("\
1470 Set printing of addresses."), _("\
1471 Show printing of addresses."), NULL,
1474 &setprintlist, &showprintlist);
1476 add_setshow_uinteger_cmd ("input-radix", class_support, &input_radix, _("\
1477 Set default input radix for entering numbers."), _("\
1478 Show default input radix for entering numbers."), NULL,
1481 &setlist, &showlist);
1483 add_setshow_uinteger_cmd ("output-radix", class_support, &output_radix, _("\
1484 Set default output radix for printing of values."), _("\
1485 Show default output radix for printing of values."), NULL,
1488 &setlist, &showlist);
1490 /* The "set radix" and "show radix" commands are special in that
1491 they are like normal set and show commands but allow two normally
1492 independent variables to be either set or shown with a single
1493 command. So the usual deprecated_add_set_cmd() and [deleted]
1494 add_show_from_set() commands aren't really appropriate. */
1495 /* FIXME: i18n: With the new add_setshow_integer command, that is no
1496 longer true - show can display anything. */
1497 add_cmd ("radix", class_support, set_radix, _("\
1498 Set default input and output number radices.\n\
1499 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1500 Without an argument, sets both radices back to the default value of 10."),
1502 add_cmd ("radix", class_support, show_radix, _("\
1503 Show the default input and output number radices.\n\
1504 Use 'show input-radix' or 'show output-radix' to independently show each."),
1507 add_setshow_boolean_cmd ("array-indexes", class_support,
1508 &print_array_indexes, _("\
1509 Set printing of array indexes."), _("\
1510 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
1511 &setprintlist, &showprintlist);
1513 /* Give people the defaults which they are used to. */
1514 prettyprint_structs = 0;
1515 prettyprint_arrays = 0;
1518 print_max = PRINT_MAX_DEFAULT;