1 /* Print values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
35 #include "floatformat.h"
40 /* Prototypes for local functions */
42 static int partial_memory_read (CORE_ADDR memaddr, char *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 /* Default input and output radixes, and output format letter. */
73 unsigned input_radix = 10;
74 unsigned output_radix = 10;
75 int output_format = 0;
77 /* Print repeat counts if there are more than this many repetitions of an
78 element in an array. Referenced by the low level language dependent
81 unsigned int repeat_count_threshold = 10;
83 /* If nonzero, stops printing of char arrays at first null. */
85 int stop_print_at_null;
87 /* Controls pretty printing of structures. */
89 int prettyprint_structs;
91 /* Controls pretty printing of arrays. */
93 int prettyprint_arrays;
95 /* If nonzero, causes unions inside structures or other unions to be
98 int unionprint; /* Controls printing of nested unions. */
100 /* If nonzero, causes machine addresses to be printed in certain contexts. */
102 int addressprint; /* Controls printing of machine addresses */
105 /* Print data of type TYPE located at VALADDR (within GDB), which came from
106 the inferior at address ADDRESS, onto stdio stream STREAM according to
107 FORMAT (a letter, or 0 for natural format using TYPE).
109 If DEREF_REF is nonzero, then dereference references, otherwise just print
112 The PRETTY parameter controls prettyprinting.
114 If the data are a string pointer, returns the number of string characters
117 FIXME: The data at VALADDR is in target byte order. If gdb is ever
118 enhanced to be able to debug more than the single target it was compiled
119 for (specific CPU type and thus specific target byte ordering), then
120 either the print routines are going to have to take this into account,
121 or the data is going to have to be passed into here already converted
122 to the host byte ordering, whichever is more convenient. */
126 val_print (struct type *type, char *valaddr, int embedded_offset,
127 CORE_ADDR address, struct ui_file *stream, int format, int deref_ref,
128 int recurse, enum val_prettyprint pretty)
130 struct type *real_type = check_typedef (type);
131 if (pretty == Val_pretty_default)
133 pretty = prettyprint_structs ? Val_prettyprint : Val_no_prettyprint;
138 /* Ensure that the type is complete and not just a stub. If the type is
139 only a stub and we can't find and substitute its complete type, then
140 print appropriate string and return. */
142 if (TYPE_STUB (real_type))
144 fprintf_filtered (stream, "<incomplete type>");
149 return (LA_VAL_PRINT (type, valaddr, embedded_offset, address,
150 stream, format, deref_ref, recurse, pretty));
153 /* Check whether the value VAL is printable. Return 1 if it is;
154 return 0 and print an appropriate error message to STREAM if it
158 value_check_printable (struct value *val, struct ui_file *stream)
162 fprintf_filtered (stream, "<address of value unknown>");
166 if (VALUE_OPTIMIZED_OUT (val))
168 fprintf_filtered (stream, "<value optimized out>");
175 /* Print the value VAL onto stream STREAM according to FORMAT (a
176 letter, or 0 for natural format using TYPE).
178 If DEREF_REF is nonzero, then dereference references, otherwise just print
181 The PRETTY parameter controls prettyprinting.
183 If the data are a string pointer, returns the number of string characters
186 This is a preferable interface to val_print, above, because it uses
187 GDB's value mechanism. */
190 common_val_print (struct value *val, struct ui_file *stream, int format,
191 int deref_ref, int recurse, enum val_prettyprint pretty)
193 if (!value_check_printable (val, stream))
196 return val_print (VALUE_TYPE(val), VALUE_CONTENTS_ALL (val),
197 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
198 stream, format, deref_ref, recurse, pretty);
201 /* Print the value VAL in C-ish syntax on stream STREAM.
202 FORMAT is a format-letter, or 0 for print in natural format of data type.
203 If the object printed is a string pointer, returns
204 the number of string bytes printed. */
207 value_print (struct value *val, struct ui_file *stream, int format,
208 enum val_prettyprint pretty)
210 if (!value_check_printable (val, stream))
213 return LA_VALUE_PRINT (val, stream, format, pretty);
216 /* Called by various <lang>_val_print routines to print
217 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
218 value. STREAM is where to print the value. */
221 val_print_type_code_int (struct type *type, char *valaddr,
222 struct ui_file *stream)
224 if (TYPE_LENGTH (type) > sizeof (LONGEST))
228 if (TYPE_UNSIGNED (type)
229 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
232 print_longest (stream, 'u', 0, val);
236 /* Signed, or we couldn't turn an unsigned value into a
237 LONGEST. For signed values, one could assume two's
238 complement (a reasonable assumption, I think) and do
240 print_hex_chars (stream, (unsigned char *) valaddr,
246 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
247 unpack_long (type, valaddr));
251 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
252 The raison d'etre of this function is to consolidate printing of
253 LONG_LONG's into this one function. Some platforms have long longs but
254 don't have a printf() that supports "ll" in the format string. We handle
255 these by seeing if the number is representable as either a signed or
256 unsigned long, depending upon what format is desired, and if not we just
257 bail out and print the number in hex.
259 The format chars b,h,w,g are from print_scalar_formatted(). If USE_LOCAL,
260 format it according to the current language (this should be used for most
261 integers which GDB prints, the exception is things like protocols where
262 the format of the integer is a protocol thing, not a user-visible thing).
265 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
266 static void print_decimal (struct ui_file * stream, char *sign,
267 int use_local, ULONGEST val_ulong);
269 print_decimal (struct ui_file *stream, char *sign, int use_local,
272 unsigned long temp[3];
276 temp[i] = val_ulong % (1000 * 1000 * 1000);
277 val_ulong /= (1000 * 1000 * 1000);
280 while (val_ulong != 0 && i < (sizeof (temp) / sizeof (temp[0])));
284 fprintf_filtered (stream, "%s%lu",
288 fprintf_filtered (stream, "%s%lu%09lu",
289 sign, temp[1], temp[0]);
292 fprintf_filtered (stream, "%s%lu%09lu%09lu",
293 sign, temp[2], temp[1], temp[0]);
296 internal_error (__FILE__, __LINE__, "failed internal consistency check");
303 print_longest (struct ui_file *stream, int format, int use_local,
306 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
307 if (sizeof (long) < sizeof (LONGEST))
313 /* Print a signed value, that doesn't fit in a long */
314 if ((long) val_long != val_long)
317 print_decimal (stream, "-", use_local, -val_long);
319 print_decimal (stream, "", use_local, val_long);
326 /* Print an unsigned value, that doesn't fit in a long */
327 if ((unsigned long) val_long != (ULONGEST) val_long)
329 print_decimal (stream, "", use_local, val_long);
340 /* Print as unsigned value, must fit completely in unsigned long */
342 unsigned long temp = val_long;
343 if (temp != val_long)
345 /* Urk, can't represent value in long so print in hex.
346 Do shift in two operations so that if sizeof (long)
347 == sizeof (LONGEST) we can avoid warnings from
348 picky compilers about shifts >= the size of the
350 unsigned long vbot = (unsigned long) val_long;
351 LONGEST temp = (val_long >> (sizeof (long) * HOST_CHAR_BIT - 1));
352 unsigned long vtop = temp >> 1;
353 fprintf_filtered (stream, "0x%lx%08lx", vtop, vbot);
362 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
366 fprintf_filtered (stream,
367 use_local ? local_decimal_format_custom ("ll")
369 (long long) val_long);
372 fprintf_filtered (stream, "%llu", (long long) val_long);
375 fprintf_filtered (stream,
376 use_local ? local_hex_format_custom ("ll")
378 (unsigned long long) val_long);
381 fprintf_filtered (stream,
382 use_local ? local_octal_format_custom ("ll")
384 (unsigned long long) val_long);
387 fprintf_filtered (stream, local_hex_format_custom ("02ll"), val_long);
390 fprintf_filtered (stream, local_hex_format_custom ("04ll"), val_long);
393 fprintf_filtered (stream, local_hex_format_custom ("08ll"), val_long);
396 fprintf_filtered (stream, local_hex_format_custom ("016ll"), val_long);
399 internal_error (__FILE__, __LINE__, "failed internal consistency check");
401 #else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
402 /* In the following it is important to coerce (val_long) to a long. It does
403 nothing if !LONG_LONG, but it will chop off the top half (which we know
404 we can ignore) if the host supports long longs. */
409 fprintf_filtered (stream,
410 use_local ? local_decimal_format_custom ("l")
415 fprintf_filtered (stream, "%lu", (unsigned long) val_long);
418 fprintf_filtered (stream,
419 use_local ? local_hex_format_custom ("l")
421 (unsigned long) val_long);
424 fprintf_filtered (stream,
425 use_local ? local_octal_format_custom ("l")
427 (unsigned long) val_long);
430 fprintf_filtered (stream, local_hex_format_custom ("02l"),
431 (unsigned long) val_long);
434 fprintf_filtered (stream, local_hex_format_custom ("04l"),
435 (unsigned long) val_long);
438 fprintf_filtered (stream, local_hex_format_custom ("08l"),
439 (unsigned long) val_long);
442 fprintf_filtered (stream, local_hex_format_custom ("016l"),
443 (unsigned long) val_long);
446 internal_error (__FILE__, __LINE__, "failed internal consistency check");
448 #endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
451 /* This used to be a macro, but I don't think it is called often enough
452 to merit such treatment. */
453 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
454 arguments to a function, number in a value history, register number, etc.)
455 where the value must not be larger than can fit in an int. */
458 longest_to_int (LONGEST arg)
460 /* Let the compiler do the work */
461 int rtnval = (int) arg;
463 /* Check for overflows or underflows */
464 if (sizeof (LONGEST) > sizeof (int))
468 error ("Value out of range.");
474 /* Print a floating point value of type TYPE (not always a
475 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
478 print_floating (char *valaddr, struct type *type, struct ui_file *stream)
482 const struct floatformat *fmt = NULL;
483 unsigned len = TYPE_LENGTH (type);
485 /* If it is a floating-point, check for obvious problems. */
486 if (TYPE_CODE (type) == TYPE_CODE_FLT)
487 fmt = floatformat_from_type (type);
488 if (fmt != NULL && floatformat_is_nan (fmt, valaddr))
490 if (floatformat_is_negative (fmt, valaddr))
491 fprintf_filtered (stream, "-");
492 fprintf_filtered (stream, "nan(");
493 fputs_filtered (local_hex_format_prefix (), stream);
494 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
495 fputs_filtered (local_hex_format_suffix (), stream);
496 fprintf_filtered (stream, ")");
500 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
501 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
502 needs to be used as that takes care of any necessary type
503 conversions. Such conversions are of course direct to DOUBLEST
504 and disregard any possible target floating point limitations.
505 For instance, a u64 would be converted and displayed exactly on a
506 host with 80 bit DOUBLEST but with loss of information on a host
507 with 64 bit DOUBLEST. */
509 doub = unpack_double (type, valaddr, &inv);
512 fprintf_filtered (stream, "<invalid float value>");
516 /* FIXME: kettenis/2001-01-20: The following code makes too much
517 assumptions about the host and target floating point format. */
519 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
520 not necessarially be a TYPE_CODE_FLT, the below ignores that and
521 instead uses the type's length to determine the precision of the
522 floating-point value being printed. */
524 if (len < sizeof (double))
525 fprintf_filtered (stream, "%.9g", (double) doub);
526 else if (len == sizeof (double))
527 fprintf_filtered (stream, "%.17g", (double) doub);
529 #ifdef PRINTF_HAS_LONG_DOUBLE
530 fprintf_filtered (stream, "%.35Lg", doub);
532 /* This at least wins with values that are representable as
534 fprintf_filtered (stream, "%.17g", (double) doub);
539 print_binary_chars (struct ui_file *stream, unsigned char *valaddr,
543 #define BITS_IN_BYTES 8
549 /* Declared "int" so it will be signed.
550 * This ensures that right shift will shift in zeros.
552 const int mask = 0x080;
554 /* FIXME: We should be not printing leading zeroes in most cases. */
556 fputs_filtered (local_binary_format_prefix (), stream);
557 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
563 /* Every byte has 8 binary characters; peel off
564 * and print from the MSB end.
566 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
568 if (*p & (mask >> i))
573 fprintf_filtered (stream, "%1d", b);
579 for (p = valaddr + len - 1;
583 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
585 if (*p & (mask >> i))
590 fprintf_filtered (stream, "%1d", b);
594 fputs_filtered (local_binary_format_suffix (), stream);
597 /* VALADDR points to an integer of LEN bytes.
598 * Print it in octal on stream or format it in buf.
601 print_octal_chars (struct ui_file *stream, unsigned char *valaddr, unsigned len)
604 unsigned char octa1, octa2, octa3, carry;
607 /* FIXME: We should be not printing leading zeroes in most cases. */
610 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
611 * the extra bits, which cycle every three bytes:
615 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
617 * Octal side: 0 1 carry 3 4 carry ...
619 * Cycle number: 0 1 2
621 * But of course we are printing from the high side, so we have to
622 * figure out where in the cycle we are so that we end up with no
623 * left over bits at the end.
625 #define BITS_IN_OCTAL 3
626 #define HIGH_ZERO 0340
627 #define LOW_ZERO 0016
628 #define CARRY_ZERO 0003
629 #define HIGH_ONE 0200
632 #define CARRY_ONE 0001
633 #define HIGH_TWO 0300
637 /* For 32 we start in cycle 2, with two bits and one bit carry;
638 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
640 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
643 fputs_filtered (local_octal_format_prefix (), stream);
644 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
653 /* No carry in, carry out two bits.
655 octa1 = (HIGH_ZERO & *p) >> 5;
656 octa2 = (LOW_ZERO & *p) >> 2;
657 carry = (CARRY_ZERO & *p);
658 fprintf_filtered (stream, "%o", octa1);
659 fprintf_filtered (stream, "%o", octa2);
663 /* Carry in two bits, carry out one bit.
665 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
666 octa2 = (MID_ONE & *p) >> 4;
667 octa3 = (LOW_ONE & *p) >> 1;
668 carry = (CARRY_ONE & *p);
669 fprintf_filtered (stream, "%o", octa1);
670 fprintf_filtered (stream, "%o", octa2);
671 fprintf_filtered (stream, "%o", octa3);
675 /* Carry in one bit, no carry out.
677 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
678 octa2 = (MID_TWO & *p) >> 3;
679 octa3 = (LOW_TWO & *p);
681 fprintf_filtered (stream, "%o", octa1);
682 fprintf_filtered (stream, "%o", octa2);
683 fprintf_filtered (stream, "%o", octa3);
687 error ("Internal error in octal conversion;");
691 cycle = cycle % BITS_IN_OCTAL;
696 for (p = valaddr + len - 1;
703 /* Carry out, no carry in */
704 octa1 = (HIGH_ZERO & *p) >> 5;
705 octa2 = (LOW_ZERO & *p) >> 2;
706 carry = (CARRY_ZERO & *p);
707 fprintf_filtered (stream, "%o", octa1);
708 fprintf_filtered (stream, "%o", octa2);
712 /* Carry in, carry out */
713 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
714 octa2 = (MID_ONE & *p) >> 4;
715 octa3 = (LOW_ONE & *p) >> 1;
716 carry = (CARRY_ONE & *p);
717 fprintf_filtered (stream, "%o", octa1);
718 fprintf_filtered (stream, "%o", octa2);
719 fprintf_filtered (stream, "%o", octa3);
723 /* Carry in, no carry out */
724 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
725 octa2 = (MID_TWO & *p) >> 3;
726 octa3 = (LOW_TWO & *p);
728 fprintf_filtered (stream, "%o", octa1);
729 fprintf_filtered (stream, "%o", octa2);
730 fprintf_filtered (stream, "%o", octa3);
734 error ("Internal error in octal conversion;");
738 cycle = cycle % BITS_IN_OCTAL;
742 fputs_filtered (local_octal_format_suffix (), stream);
745 /* VALADDR points to an integer of LEN bytes.
746 * Print it in decimal on stream or format it in buf.
749 print_decimal_chars (struct ui_file *stream, unsigned char *valaddr,
753 #define TWO_TO_FOURTH 16
754 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
755 #define CARRY_LEFT( x ) ((x) % TEN)
756 #define SHIFT( x ) ((x) << 4)
758 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
760 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
762 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? p++ : p-- )
763 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
764 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
767 unsigned char *digits;
770 int i, j, decimal_digits;
774 /* Base-ten number is less than twice as many digits
775 * as the base 16 number, which is 2 digits per byte.
777 decimal_len = len * 2 * 2;
778 digits = xmalloc (decimal_len);
780 for (i = 0; i < decimal_len; i++)
785 fputs_filtered (local_decimal_format_prefix (), stream);
787 /* Ok, we have an unknown number of bytes of data to be printed in
790 * Given a hex number (in nibbles) as XYZ, we start by taking X and
791 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
792 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
794 * The trick is that "digits" holds a base-10 number, but sometimes
795 * the individual digits are > 10.
797 * Outer loop is per nibble (hex digit) of input, from MSD end to
800 decimal_digits = 0; /* Number of decimal digits so far */
806 * Multiply current base-ten number by 16 in place.
807 * Each digit was between 0 and 9, now is between
810 for (j = 0; j < decimal_digits; j++)
812 digits[j] = SHIFT (digits[j]);
815 /* Take the next nibble off the input and add it to what
816 * we've got in the LSB position. Bottom 'digit' is now
819 * "flip" is used to run this loop twice for each byte.
825 digits[0] += HIGH_NIBBLE (*p);
830 /* Take low nibble and bump our pointer "p".
832 digits[0] += LOW_NIBBLE (*p);
837 /* Re-decimalize. We have to do this often enough
838 * that we don't overflow, but once per nibble is
839 * overkill. Easier this way, though. Note that the
840 * carry is often larger than 10 (e.g. max initial
841 * carry out of lowest nibble is 15, could bubble all
842 * the way up greater than 10). So we have to do
843 * the carrying beyond the last current digit.
846 for (j = 0; j < decimal_len - 1; j++)
850 /* "/" won't handle an unsigned char with
851 * a value that if signed would be negative.
852 * So extend to longword int via "dummy".
855 carry = CARRY_OUT (dummy);
856 digits[j] = CARRY_LEFT (dummy);
858 if (j >= decimal_digits && carry == 0)
861 * All higher digits are 0 and we
862 * no longer have a carry.
864 * Note: "j" is 0-based, "decimal_digits" is
867 decimal_digits = j + 1;
873 /* Ok, now "digits" is the decimal representation, with
874 * the "decimal_digits" actual digits. Print!
876 for (i = decimal_digits - 1; i >= 0; i--)
878 fprintf_filtered (stream, "%1d", digits[i]);
882 fputs_filtered (local_decimal_format_suffix (), stream);
885 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
888 print_hex_chars (struct ui_file *stream, unsigned char *valaddr, unsigned len)
892 /* FIXME: We should be not printing leading zeroes in most cases. */
894 fputs_filtered (local_hex_format_prefix (), stream);
895 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
901 fprintf_filtered (stream, "%02x", *p);
906 for (p = valaddr + len - 1;
910 fprintf_filtered (stream, "%02x", *p);
913 fputs_filtered (local_hex_format_suffix (), stream);
916 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
917 Omit any leading zero chars. */
920 print_char_chars (struct ui_file *stream, unsigned char *valaddr, unsigned len)
924 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
927 while (p < valaddr + len - 1 && *p == 0)
930 while (p < valaddr + len)
932 LA_EMIT_CHAR (*p, stream, '\'');
938 p = valaddr + len - 1;
939 while (p > valaddr && *p == 0)
944 LA_EMIT_CHAR (*p, stream, '\'');
950 /* Called by various <lang>_val_print routines to print elements of an
951 array in the form "<elem1>, <elem2>, <elem3>, ...".
953 (FIXME?) Assumes array element separator is a comma, which is correct
954 for all languages currently handled.
955 (FIXME?) Some languages have a notation for repeated array elements,
956 perhaps we should try to use that notation when appropriate.
960 val_print_array_elements (struct type *type, char *valaddr, CORE_ADDR address,
961 struct ui_file *stream, int format, int deref_ref,
962 int recurse, enum val_prettyprint pretty,
965 unsigned int things_printed = 0;
967 struct type *elttype;
969 /* Position of the array element we are examining to see
970 whether it is repeated. */
972 /* Number of repetitions we have detected so far. */
975 elttype = TYPE_TARGET_TYPE (type);
976 eltlen = TYPE_LENGTH (check_typedef (elttype));
977 len = TYPE_LENGTH (type) / eltlen;
979 annotate_array_section_begin (i, elttype);
981 for (; i < len && things_printed < print_max; i++)
985 if (prettyprint_arrays)
987 fprintf_filtered (stream, ",\n");
988 print_spaces_filtered (2 + 2 * recurse, stream);
992 fprintf_filtered (stream, ", ");
995 wrap_here (n_spaces (2 + 2 * recurse));
999 while ((rep1 < len) &&
1000 !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1006 if (reps > repeat_count_threshold)
1008 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1009 deref_ref, recurse + 1, pretty);
1010 annotate_elt_rep (reps);
1011 fprintf_filtered (stream, " <repeats %u times>", reps);
1012 annotate_elt_rep_end ();
1015 things_printed += repeat_count_threshold;
1019 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1020 deref_ref, recurse + 1, pretty);
1025 annotate_array_section_end ();
1028 fprintf_filtered (stream, "...");
1032 /* Read LEN bytes of target memory at address MEMADDR, placing the
1033 results in GDB's memory at MYADDR. Returns a count of the bytes
1034 actually read, and optionally an errno value in the location
1035 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1037 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1038 function be eliminated. */
1041 partial_memory_read (CORE_ADDR memaddr, char *myaddr, int len, int *errnoptr)
1043 int nread; /* Number of bytes actually read. */
1044 int errcode; /* Error from last read. */
1046 /* First try a complete read. */
1047 errcode = target_read_memory (memaddr, myaddr, len);
1055 /* Loop, reading one byte at a time until we get as much as we can. */
1056 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1058 errcode = target_read_memory (memaddr++, myaddr++, 1);
1060 /* If an error, the last read was unsuccessful, so adjust count. */
1066 if (errnoptr != NULL)
1068 *errnoptr = errcode;
1073 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1074 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1075 stops at the first null byte, otherwise printing proceeds (including null
1076 bytes) until either print_max or LEN characters have been printed,
1077 whichever is smaller. */
1079 /* FIXME: Use target_read_string. */
1082 val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream)
1084 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
1085 int errcode; /* Errno returned from bad reads. */
1086 unsigned int fetchlimit; /* Maximum number of chars to print. */
1087 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1088 unsigned int chunksize; /* Size of each fetch, in chars. */
1089 char *buffer = NULL; /* Dynamically growable fetch buffer. */
1090 char *bufptr; /* Pointer to next available byte in buffer. */
1091 char *limit; /* First location past end of fetch buffer. */
1092 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1093 int found_nul; /* Non-zero if we found the nul char */
1095 /* First we need to figure out the limit on the number of characters we are
1096 going to attempt to fetch and print. This is actually pretty simple. If
1097 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1098 LEN is -1, then the limit is print_max. This is true regardless of
1099 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1100 because finding the null byte (or available memory) is what actually
1101 limits the fetch. */
1103 fetchlimit = (len == -1 ? print_max : min (len, print_max));
1105 /* Now decide how large of chunks to try to read in one operation. This
1106 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1107 so we might as well read them all in one operation. If LEN is -1, we
1108 are looking for a null terminator to end the fetching, so we might as
1109 well read in blocks that are large enough to be efficient, but not so
1110 large as to be slow if fetchlimit happens to be large. So we choose the
1111 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1112 200 is way too big for remote debugging over a serial line. */
1114 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1116 /* Loop until we either have all the characters to print, or we encounter
1117 some error, such as bumping into the end of the address space. */
1120 old_chain = make_cleanup (null_cleanup, 0);
1124 buffer = (char *) xmalloc (len * width);
1126 old_chain = make_cleanup (xfree, buffer);
1128 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1130 addr += nfetch * width;
1131 bufptr += nfetch * width;
1135 unsigned long bufsize = 0;
1139 nfetch = min (chunksize, fetchlimit - bufsize);
1142 buffer = (char *) xmalloc (nfetch * width);
1145 discard_cleanups (old_chain);
1146 buffer = (char *) xrealloc (buffer, (nfetch + bufsize) * width);
1149 old_chain = make_cleanup (xfree, buffer);
1150 bufptr = buffer + bufsize * width;
1153 /* Read as much as we can. */
1154 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1157 /* Scan this chunk for the null byte that terminates the string
1158 to print. If found, we don't need to fetch any more. Note
1159 that bufptr is explicitly left pointing at the next character
1160 after the null byte, or at the next character after the end of
1163 limit = bufptr + nfetch * width;
1164 while (bufptr < limit)
1168 c = extract_unsigned_integer (bufptr, width);
1173 /* We don't care about any error which happened after
1174 the NULL terminator. */
1181 while (errcode == 0 /* no error */
1182 && bufptr - buffer < fetchlimit * width /* no overrun */
1183 && !found_nul); /* haven't found nul yet */
1186 { /* length of string is really 0! */
1187 buffer = bufptr = NULL;
1191 /* bufptr and addr now point immediately beyond the last byte which we
1192 consider part of the string (including a '\0' which ends the string). */
1194 /* We now have either successfully filled the buffer to fetchlimit, or
1195 terminated early due to an error or finding a null char when LEN is -1. */
1197 if (len == -1 && !found_nul)
1201 /* We didn't find a null terminator we were looking for. Attempt
1202 to peek at the next character. If not successful, or it is not
1203 a null byte, then force ellipsis to be printed. */
1205 peekbuf = (char *) alloca (width);
1207 if (target_read_memory (addr, peekbuf, width) == 0
1208 && extract_unsigned_integer (peekbuf, width) != 0)
1211 else if ((len >= 0 && errcode != 0) || (len > (bufptr - buffer) / width))
1213 /* Getting an error when we have a requested length, or fetching less
1214 than the number of characters actually requested, always make us
1221 /* If we get an error before fetching anything, don't print a string.
1222 But if we fetch something and then get an error, print the string
1223 and then the error message. */
1224 if (errcode == 0 || bufptr > buffer)
1228 fputs_filtered (" ", stream);
1230 LA_PRINT_STRING (stream, buffer, (bufptr - buffer) / width, width, force_ellipsis);
1237 fprintf_filtered (stream, " <Address ");
1238 print_address_numeric (addr, 1, stream);
1239 fprintf_filtered (stream, " out of bounds>");
1243 fprintf_filtered (stream, " <Error reading address ");
1244 print_address_numeric (addr, 1, stream);
1245 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1249 do_cleanups (old_chain);
1250 return ((bufptr - buffer) / width);
1254 /* Validate an input or output radix setting, and make sure the user
1255 knows what they really did here. Radix setting is confusing, e.g.
1256 setting the input radix to "10" never changes it! */
1259 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
1261 set_input_radix_1 (from_tty, input_radix);
1265 set_input_radix_1 (int from_tty, unsigned radix)
1267 /* We don't currently disallow any input radix except 0 or 1, which don't
1268 make any mathematical sense. In theory, we can deal with any input
1269 radix greater than 1, even if we don't have unique digits for every
1270 value from 0 to radix-1, but in practice we lose on large radix values.
1271 We should either fix the lossage or restrict the radix range more.
1276 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1278 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1281 input_radix = radix;
1284 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1285 radix, radix, radix);
1290 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
1292 set_output_radix_1 (from_tty, output_radix);
1296 set_output_radix_1 (int from_tty, unsigned radix)
1298 /* Validate the radix and disallow ones that we aren't prepared to
1299 handle correctly, leaving the radix unchanged. */
1303 output_format = 'x'; /* hex */
1306 output_format = 0; /* decimal */
1309 output_format = 'o'; /* octal */
1312 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1314 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1317 output_radix = radix;
1320 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1321 radix, radix, radix);
1325 /* Set both the input and output radix at once. Try to set the output radix
1326 first, since it has the most restrictive range. An radix that is valid as
1327 an output radix is also valid as an input radix.
1329 It may be useful to have an unusual input radix. If the user wishes to
1330 set an input radix that is not valid as an output radix, he needs to use
1331 the 'set input-radix' command. */
1334 set_radix (char *arg, int from_tty)
1338 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
1339 set_output_radix_1 (0, radix);
1340 set_input_radix_1 (0, radix);
1343 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1344 radix, radix, radix);
1348 /* Show both the input and output radices. */
1351 show_radix (char *arg, int from_tty)
1355 if (input_radix == output_radix)
1357 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1358 input_radix, input_radix, input_radix);
1362 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1363 input_radix, input_radix, input_radix);
1364 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1365 output_radix, output_radix, output_radix);
1372 set_print (char *arg, int from_tty)
1375 "\"set print\" must be followed by the name of a print subcommand.\n");
1376 help_list (setprintlist, "set print ", -1, gdb_stdout);
1380 show_print (char *args, int from_tty)
1382 cmd_show_list (showprintlist, from_tty, "");
1386 _initialize_valprint (void)
1388 struct cmd_list_element *c;
1390 add_prefix_cmd ("print", no_class, set_print,
1391 "Generic command for setting how things print.",
1392 &setprintlist, "set print ", 0, &setlist);
1393 add_alias_cmd ("p", "print", no_class, 1, &setlist);
1394 /* prefer set print to set prompt */
1395 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1397 add_prefix_cmd ("print", no_class, show_print,
1398 "Generic command for showing print settings.",
1399 &showprintlist, "show print ", 0, &showlist);
1400 add_alias_cmd ("p", "print", no_class, 1, &showlist);
1401 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
1404 (add_set_cmd ("elements", no_class, var_uinteger, (char *) &print_max,
1405 "Set limit on string chars or array elements to print.\n\
1406 \"set print elements 0\" causes there to be no limit.",
1411 (add_set_cmd ("null-stop", no_class, var_boolean,
1412 (char *) &stop_print_at_null,
1413 "Set printing of char arrays to stop at first null char.",
1418 (add_set_cmd ("repeats", no_class, var_uinteger,
1419 (char *) &repeat_count_threshold,
1420 "Set threshold for repeated print elements.\n\
1421 \"set print repeats 0\" causes all elements to be individually printed.",
1426 (add_set_cmd ("pretty", class_support, var_boolean,
1427 (char *) &prettyprint_structs,
1428 "Set prettyprinting of structures.",
1433 (add_set_cmd ("union", class_support, var_boolean, (char *) &unionprint,
1434 "Set printing of unions interior to structures.",
1439 (add_set_cmd ("array", class_support, var_boolean,
1440 (char *) &prettyprint_arrays,
1441 "Set prettyprinting of arrays.",
1446 (add_set_cmd ("address", class_support, var_boolean, (char *) &addressprint,
1447 "Set printing of addresses.",
1451 c = add_set_cmd ("input-radix", class_support, var_uinteger,
1452 (char *) &input_radix,
1453 "Set default input radix for entering numbers.",
1455 add_show_from_set (c, &showlist);
1456 set_cmd_sfunc (c, set_input_radix);
1458 c = add_set_cmd ("output-radix", class_support, var_uinteger,
1459 (char *) &output_radix,
1460 "Set default output radix for printing of values.",
1462 add_show_from_set (c, &showlist);
1463 set_cmd_sfunc (c, set_output_radix);
1465 /* The "set radix" and "show radix" commands are special in that they are
1466 like normal set and show commands but allow two normally independent
1467 variables to be either set or shown with a single command. So the
1468 usual add_set_cmd() and add_show_from_set() commands aren't really
1470 add_cmd ("radix", class_support, set_radix,
1471 "Set default input and output number radices.\n\
1472 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1473 Without an argument, sets both radices back to the default value of 10.",
1475 add_cmd ("radix", class_support, show_radix,
1476 "Show the default input and output number radices.\n\
1477 Use 'show input-radix' or 'show output-radix' to independently show each.",
1480 /* Give people the defaults which they are used to. */
1481 prettyprint_structs = 0;
1482 prettyprint_arrays = 0;
1485 print_max = PRINT_MAX_DEFAULT;