1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
33 #include "floatformat.h"
35 #include "exceptions.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 using the given LANGUAGE the data of type TYPE located at VALADDR
184 (within GDB), which came from the inferior at address ADDRESS, onto
185 stdio stream STREAM according to FORMAT (a letter, or 0 for natural
188 If DEREF_REF is nonzero, then dereference references, otherwise just print
191 The PRETTY parameter controls prettyprinting.
193 If the data are a string pointer, returns the number of string characters
196 FIXME: The data at VALADDR is in target byte order. If gdb is ever
197 enhanced to be able to debug more than the single target it was compiled
198 for (specific CPU type and thus specific target byte ordering), then
199 either the print routines are going to have to take this into account,
200 or the data is going to have to be passed into here already converted
201 to the host byte ordering, whichever is more convenient. */
205 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
206 CORE_ADDR address
, struct ui_file
*stream
, int format
,
207 int deref_ref
, int recurse
, enum val_prettyprint pretty
,
208 const struct language_defn
*language
)
210 volatile struct gdb_exception except
;
211 volatile enum val_prettyprint real_pretty
= pretty
;
214 struct type
*real_type
= check_typedef (type
);
215 if (pretty
== Val_pretty_default
)
216 real_pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
220 /* Ensure that the type is complete and not just a stub. If the type is
221 only a stub and we can't find and substitute its complete type, then
222 print appropriate string and return. */
224 if (TYPE_STUB (real_type
))
226 fprintf_filtered (stream
, "<incomplete type>");
231 TRY_CATCH (except
, RETURN_MASK_ERROR
)
233 ret
= language
->la_val_print (type
, valaddr
, embedded_offset
, address
,
234 stream
, format
, deref_ref
, recurse
,
237 if (except
.reason
< 0)
238 fprintf_filtered (stream
, _("<error reading variable>"));
243 /* Check whether the value VAL is printable. Return 1 if it is;
244 return 0 and print an appropriate error message to STREAM if it
248 value_check_printable (struct value
*val
, struct ui_file
*stream
)
252 fprintf_filtered (stream
, _("<address of value unknown>"));
256 if (value_optimized_out (val
))
258 fprintf_filtered (stream
, _("<value optimized out>"));
265 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
266 to FORMAT (a letter, or 0 for natural format using TYPE).
268 If DEREF_REF is nonzero, then dereference references, otherwise just print
271 The PRETTY parameter controls prettyprinting.
273 If the data are a string pointer, returns the number of string characters
276 This is a preferable interface to val_print, above, because it uses
277 GDB's value mechanism. */
280 common_val_print (struct value
*val
, struct ui_file
*stream
, int format
,
281 int deref_ref
, int recurse
, enum val_prettyprint pretty
,
282 const struct language_defn
*language
)
284 if (!value_check_printable (val
, stream
))
287 return val_print (value_type (val
), value_contents_all (val
),
288 value_embedded_offset (val
), VALUE_ADDRESS (val
),
289 stream
, format
, deref_ref
, recurse
, pretty
,
293 /* Print the value VAL in C-ish syntax on stream STREAM.
294 FORMAT is a format-letter, or 0 for print in natural format of data type.
295 If the object printed is a string pointer, returns
296 the number of string bytes printed. */
299 value_print (struct value
*val
, struct ui_file
*stream
, int format
,
300 enum val_prettyprint pretty
)
302 if (!value_check_printable (val
, stream
))
305 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
308 /* Called by various <lang>_val_print routines to print
309 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
310 value. STREAM is where to print the value. */
313 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
314 struct ui_file
*stream
)
316 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
320 if (TYPE_UNSIGNED (type
)
321 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
324 print_longest (stream
, 'u', 0, val
);
328 /* Signed, or we couldn't turn an unsigned value into a
329 LONGEST. For signed values, one could assume two's
330 complement (a reasonable assumption, I think) and do
332 print_hex_chars (stream
, (unsigned char *) valaddr
,
338 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
339 unpack_long (type
, valaddr
));
344 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
345 struct ui_file
*stream
)
347 ULONGEST val
= unpack_long (type
, valaddr
);
348 int bitpos
, nfields
= TYPE_NFIELDS (type
);
350 fputs_filtered ("[ ", stream
);
351 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
353 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
354 && (val
& ((ULONGEST
)1 << bitpos
)))
356 if (TYPE_FIELD_NAME (type
, bitpos
))
357 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
359 fprintf_filtered (stream
, "#%d ", bitpos
);
362 fputs_filtered ("]", stream
);
365 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
366 The raison d'etre of this function is to consolidate printing of
367 LONG_LONG's into this one function. The format chars b,h,w,g are
368 from print_scalar_formatted(). Numbers are printed using C
371 USE_C_FORMAT means to use C format in all cases. Without it,
372 'o' and 'x' format do not include the standard C radix prefix
375 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
376 and was intended to request formating according to the current
377 language and would be used for most integers that GDB prints. The
378 exceptional cases were things like protocols where the format of
379 the integer is a protocol thing, not a user-visible thing). The
380 parameter remains to preserve the information of what things might
381 be printed with language-specific format, should we ever resurrect
385 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
393 val
= int_string (val_long
, 10, 1, 0, 1); break;
395 val
= int_string (val_long
, 10, 0, 0, 1); break;
397 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
399 val
= int_string (val_long
, 16, 0, 2, 1); break;
401 val
= int_string (val_long
, 16, 0, 4, 1); break;
403 val
= int_string (val_long
, 16, 0, 8, 1); break;
405 val
= int_string (val_long
, 16, 0, 16, 1); break;
408 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
410 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
412 fputs_filtered (val
, stream
);
415 /* This used to be a macro, but I don't think it is called often enough
416 to merit such treatment. */
417 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
418 arguments to a function, number in a value history, register number, etc.)
419 where the value must not be larger than can fit in an int. */
422 longest_to_int (LONGEST arg
)
424 /* Let the compiler do the work */
425 int rtnval
= (int) arg
;
427 /* Check for overflows or underflows */
428 if (sizeof (LONGEST
) > sizeof (int))
432 error (_("Value out of range."));
438 /* Print a floating point value of type TYPE (not always a
439 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
442 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
443 struct ui_file
*stream
)
447 const struct floatformat
*fmt
= NULL
;
448 unsigned len
= TYPE_LENGTH (type
);
449 enum float_kind kind
;
451 /* If it is a floating-point, check for obvious problems. */
452 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
453 fmt
= floatformat_from_type (type
);
456 kind
= floatformat_classify (fmt
, valaddr
);
457 if (kind
== float_nan
)
459 if (floatformat_is_negative (fmt
, valaddr
))
460 fprintf_filtered (stream
, "-");
461 fprintf_filtered (stream
, "nan(");
462 fputs_filtered ("0x", stream
);
463 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
464 fprintf_filtered (stream
, ")");
467 else if (kind
== float_infinite
)
469 if (floatformat_is_negative (fmt
, valaddr
))
470 fputs_filtered ("-", stream
);
471 fputs_filtered ("inf", stream
);
476 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
477 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
478 needs to be used as that takes care of any necessary type
479 conversions. Such conversions are of course direct to DOUBLEST
480 and disregard any possible target floating point limitations.
481 For instance, a u64 would be converted and displayed exactly on a
482 host with 80 bit DOUBLEST but with loss of information on a host
483 with 64 bit DOUBLEST. */
485 doub
= unpack_double (type
, valaddr
, &inv
);
488 fprintf_filtered (stream
, "<invalid float value>");
492 /* FIXME: kettenis/2001-01-20: The following code makes too much
493 assumptions about the host and target floating point format. */
495 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
496 not necessarily be a TYPE_CODE_FLT, the below ignores that and
497 instead uses the type's length to determine the precision of the
498 floating-point value being printed. */
500 if (len
< sizeof (double))
501 fprintf_filtered (stream
, "%.9g", (double) doub
);
502 else if (len
== sizeof (double))
503 fprintf_filtered (stream
, "%.17g", (double) doub
);
505 #ifdef PRINTF_HAS_LONG_DOUBLE
506 fprintf_filtered (stream
, "%.35Lg", doub
);
508 /* This at least wins with values that are representable as
510 fprintf_filtered (stream
, "%.17g", (double) doub
);
515 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
516 struct ui_file
*stream
)
518 char decstr
[MAX_DECIMAL_STRING
];
519 unsigned len
= TYPE_LENGTH (type
);
521 decimal_to_string (valaddr
, len
, decstr
);
522 fputs_filtered (decstr
, stream
);
527 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
531 #define BITS_IN_BYTES 8
537 /* Declared "int" so it will be signed.
538 * This ensures that right shift will shift in zeros.
540 const int mask
= 0x080;
542 /* FIXME: We should be not printing leading zeroes in most cases. */
544 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
)
550 /* Every byte has 8 binary characters; peel off
551 * and print from the MSB end.
553 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
555 if (*p
& (mask
>> i
))
560 fprintf_filtered (stream
, "%1d", b
);
566 for (p
= valaddr
+ len
- 1;
570 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
572 if (*p
& (mask
>> i
))
577 fprintf_filtered (stream
, "%1d", b
);
583 /* VALADDR points to an integer of LEN bytes.
584 * Print it in octal on stream or format it in buf.
587 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
591 unsigned char octa1
, octa2
, octa3
, carry
;
594 /* FIXME: We should be not printing leading zeroes in most cases. */
597 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
598 * the extra bits, which cycle every three bytes:
602 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
604 * Octal side: 0 1 carry 3 4 carry ...
606 * Cycle number: 0 1 2
608 * But of course we are printing from the high side, so we have to
609 * figure out where in the cycle we are so that we end up with no
610 * left over bits at the end.
612 #define BITS_IN_OCTAL 3
613 #define HIGH_ZERO 0340
614 #define LOW_ZERO 0016
615 #define CARRY_ZERO 0003
616 #define HIGH_ONE 0200
619 #define CARRY_ONE 0001
620 #define HIGH_TWO 0300
624 /* For 32 we start in cycle 2, with two bits and one bit carry;
625 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
627 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
630 fputs_filtered ("0", stream
);
631 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
)
640 /* No carry in, carry out two bits.
642 octa1
= (HIGH_ZERO
& *p
) >> 5;
643 octa2
= (LOW_ZERO
& *p
) >> 2;
644 carry
= (CARRY_ZERO
& *p
);
645 fprintf_filtered (stream
, "%o", octa1
);
646 fprintf_filtered (stream
, "%o", octa2
);
650 /* Carry in two bits, carry out one bit.
652 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
653 octa2
= (MID_ONE
& *p
) >> 4;
654 octa3
= (LOW_ONE
& *p
) >> 1;
655 carry
= (CARRY_ONE
& *p
);
656 fprintf_filtered (stream
, "%o", octa1
);
657 fprintf_filtered (stream
, "%o", octa2
);
658 fprintf_filtered (stream
, "%o", octa3
);
662 /* Carry in one bit, no carry out.
664 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
665 octa2
= (MID_TWO
& *p
) >> 3;
666 octa3
= (LOW_TWO
& *p
);
668 fprintf_filtered (stream
, "%o", octa1
);
669 fprintf_filtered (stream
, "%o", octa2
);
670 fprintf_filtered (stream
, "%o", octa3
);
674 error (_("Internal error in octal conversion;"));
678 cycle
= cycle
% BITS_IN_OCTAL
;
683 for (p
= valaddr
+ len
- 1;
690 /* Carry out, no carry in */
691 octa1
= (HIGH_ZERO
& *p
) >> 5;
692 octa2
= (LOW_ZERO
& *p
) >> 2;
693 carry
= (CARRY_ZERO
& *p
);
694 fprintf_filtered (stream
, "%o", octa1
);
695 fprintf_filtered (stream
, "%o", octa2
);
699 /* Carry in, carry out */
700 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
701 octa2
= (MID_ONE
& *p
) >> 4;
702 octa3
= (LOW_ONE
& *p
) >> 1;
703 carry
= (CARRY_ONE
& *p
);
704 fprintf_filtered (stream
, "%o", octa1
);
705 fprintf_filtered (stream
, "%o", octa2
);
706 fprintf_filtered (stream
, "%o", octa3
);
710 /* Carry in, no carry out */
711 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
712 octa2
= (MID_TWO
& *p
) >> 3;
713 octa3
= (LOW_TWO
& *p
);
715 fprintf_filtered (stream
, "%o", octa1
);
716 fprintf_filtered (stream
, "%o", octa2
);
717 fprintf_filtered (stream
, "%o", octa3
);
721 error (_("Internal error in octal conversion;"));
725 cycle
= cycle
% BITS_IN_OCTAL
;
731 /* VALADDR points to an integer of LEN bytes.
732 * Print it in decimal on stream or format it in buf.
735 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
739 #define TWO_TO_FOURTH 16
740 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
741 #define CARRY_LEFT( x ) ((x) % TEN)
742 #define SHIFT( x ) ((x) << 4)
744 ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
746 ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
748 ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) ? p++ : p-- )
749 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
750 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
753 unsigned char *digits
;
756 int i
, j
, decimal_digits
;
760 /* Base-ten number is less than twice as many digits
761 * as the base 16 number, which is 2 digits per byte.
763 decimal_len
= len
* 2 * 2;
764 digits
= xmalloc (decimal_len
);
766 for (i
= 0; i
< decimal_len
; i
++)
771 /* Ok, we have an unknown number of bytes of data to be printed in
774 * Given a hex number (in nibbles) as XYZ, we start by taking X and
775 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
776 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
778 * The trick is that "digits" holds a base-10 number, but sometimes
779 * the individual digits are > 10.
781 * Outer loop is per nibble (hex digit) of input, from MSD end to
784 decimal_digits
= 0; /* Number of decimal digits so far */
790 * Multiply current base-ten number by 16 in place.
791 * Each digit was between 0 and 9, now is between
794 for (j
= 0; j
< decimal_digits
; j
++)
796 digits
[j
] = SHIFT (digits
[j
]);
799 /* Take the next nibble off the input and add it to what
800 * we've got in the LSB position. Bottom 'digit' is now
803 * "flip" is used to run this loop twice for each byte.
809 digits
[0] += HIGH_NIBBLE (*p
);
814 /* Take low nibble and bump our pointer "p".
816 digits
[0] += LOW_NIBBLE (*p
);
821 /* Re-decimalize. We have to do this often enough
822 * that we don't overflow, but once per nibble is
823 * overkill. Easier this way, though. Note that the
824 * carry is often larger than 10 (e.g. max initial
825 * carry out of lowest nibble is 15, could bubble all
826 * the way up greater than 10). So we have to do
827 * the carrying beyond the last current digit.
830 for (j
= 0; j
< decimal_len
- 1; j
++)
834 /* "/" won't handle an unsigned char with
835 * a value that if signed would be negative.
836 * So extend to longword int via "dummy".
839 carry
= CARRY_OUT (dummy
);
840 digits
[j
] = CARRY_LEFT (dummy
);
842 if (j
>= decimal_digits
&& carry
== 0)
845 * All higher digits are 0 and we
846 * no longer have a carry.
848 * Note: "j" is 0-based, "decimal_digits" is
851 decimal_digits
= j
+ 1;
857 /* Ok, now "digits" is the decimal representation, with
858 * the "decimal_digits" actual digits. Print!
860 for (i
= decimal_digits
- 1; i
>= 0; i
--)
862 fprintf_filtered (stream
, "%1d", digits
[i
]);
867 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
870 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
875 /* FIXME: We should be not printing leading zeroes in most cases. */
877 fputs_filtered ("0x", stream
);
878 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
)
884 fprintf_filtered (stream
, "%02x", *p
);
889 for (p
= valaddr
+ len
- 1;
893 fprintf_filtered (stream
, "%02x", *p
);
898 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
899 Omit any leading zero chars. */
902 print_char_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
907 if (gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
)
910 while (p
< valaddr
+ len
- 1 && *p
== 0)
913 while (p
< valaddr
+ len
)
915 LA_EMIT_CHAR (*p
, stream
, '\'');
921 p
= valaddr
+ len
- 1;
922 while (p
> valaddr
&& *p
== 0)
927 LA_EMIT_CHAR (*p
, stream
, '\'');
933 /* Return non-zero if the debugger should print the index of each element
934 when printing array values. */
937 print_array_indexes_p (void)
939 return print_array_indexes
;
942 /* Assuming TYPE is a simple, non-empty array type, compute its lower bound.
943 Save it into LOW_BOUND if not NULL.
945 Return 1 if the operation was successful. Return zero otherwise,
946 in which case the value of LOW_BOUND is unmodified.
948 Computing the array lower bound is pretty easy, but this function
949 does some additional verifications before returning the low bound.
950 If something incorrect is detected, it is better to return a status
951 rather than throwing an error, making it easier for the caller to
952 implement an error-recovery plan. For instance, it may decide to
953 warn the user that the bound was not found and then use a default
957 get_array_low_bound (struct type
*type
, long *low_bound
)
959 struct type
*index
= TYPE_INDEX_TYPE (type
);
965 if (TYPE_CODE (index
) != TYPE_CODE_RANGE
966 && TYPE_CODE (index
) != TYPE_CODE_ENUM
)
969 low
= TYPE_LOW_BOUND (index
);
970 if (low
> TYPE_HIGH_BOUND (index
))
979 /* Print on STREAM using the given FORMAT the index for the element
980 at INDEX of an array whose index type is INDEX_TYPE. */
983 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
984 struct ui_file
*stream
, int format
,
985 enum val_prettyprint pretty
)
987 struct value
*index_value
;
989 if (!print_array_indexes
)
992 index_value
= value_from_longest (index_type
, index
);
994 LA_PRINT_ARRAY_INDEX (index_value
, stream
, format
, pretty
);
997 /* Called by various <lang>_val_print routines to print elements of an
998 array in the form "<elem1>, <elem2>, <elem3>, ...".
1000 (FIXME?) Assumes array element separator is a comma, which is correct
1001 for all languages currently handled.
1002 (FIXME?) Some languages have a notation for repeated array elements,
1003 perhaps we should try to use that notation when appropriate.
1007 val_print_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
1008 CORE_ADDR address
, struct ui_file
*stream
,
1009 int format
, int deref_ref
,
1010 int recurse
, enum val_prettyprint pretty
,
1013 unsigned int things_printed
= 0;
1015 struct type
*elttype
, *index_type
;
1017 /* Position of the array element we are examining to see
1018 whether it is repeated. */
1020 /* Number of repetitions we have detected so far. */
1022 long low_bound_index
= 0;
1024 elttype
= TYPE_TARGET_TYPE (type
);
1025 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1026 len
= TYPE_LENGTH (type
) / eltlen
;
1027 index_type
= TYPE_INDEX_TYPE (type
);
1029 /* Get the array low bound. This only makes sense if the array
1030 has one or more element in it. */
1031 if (len
> 0 && !get_array_low_bound (type
, &low_bound_index
))
1033 warning ("unable to get low bound of array, using zero as default");
1034 low_bound_index
= 0;
1037 annotate_array_section_begin (i
, elttype
);
1039 for (; i
< len
&& things_printed
< print_max
; i
++)
1043 if (prettyprint_arrays
)
1045 fprintf_filtered (stream
, ",\n");
1046 print_spaces_filtered (2 + 2 * recurse
, stream
);
1050 fprintf_filtered (stream
, ", ");
1053 wrap_here (n_spaces (2 + 2 * recurse
));
1054 maybe_print_array_index (index_type
, i
+ low_bound_index
,
1055 stream
, format
, pretty
);
1059 while ((rep1
< len
) &&
1060 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
1066 if (reps
> repeat_count_threshold
)
1068 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1069 deref_ref
, recurse
+ 1, pretty
, current_language
);
1070 annotate_elt_rep (reps
);
1071 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1072 annotate_elt_rep_end ();
1075 things_printed
+= repeat_count_threshold
;
1079 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1080 deref_ref
, recurse
+ 1, pretty
, current_language
);
1085 annotate_array_section_end ();
1088 fprintf_filtered (stream
, "...");
1092 /* Read LEN bytes of target memory at address MEMADDR, placing the
1093 results in GDB's memory at MYADDR. Returns a count of the bytes
1094 actually read, and optionally an errno value in the location
1095 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1097 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1098 function be eliminated. */
1101 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int *errnoptr
)
1103 int nread
; /* Number of bytes actually read. */
1104 int errcode
; /* Error from last read. */
1106 /* First try a complete read. */
1107 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1115 /* Loop, reading one byte at a time until we get as much as we can. */
1116 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1118 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1120 /* If an error, the last read was unsuccessful, so adjust count. */
1126 if (errnoptr
!= NULL
)
1128 *errnoptr
= errcode
;
1133 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1134 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1135 stops at the first null byte, otherwise printing proceeds (including null
1136 bytes) until either print_max or LEN characters have been printed,
1137 whichever is smaller. */
1139 /* FIXME: Use target_read_string. */
1142 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
1144 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1145 int errcode
; /* Errno returned from bad reads. */
1146 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1147 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1148 unsigned int chunksize
; /* Size of each fetch, in chars. */
1149 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
1150 gdb_byte
*bufptr
; /* Pointer to next available byte in buffer. */
1151 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1152 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1153 int found_nul
; /* Non-zero if we found the nul char */
1155 /* First we need to figure out the limit on the number of characters we are
1156 going to attempt to fetch and print. This is actually pretty simple. If
1157 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1158 LEN is -1, then the limit is print_max. This is true regardless of
1159 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1160 because finding the null byte (or available memory) is what actually
1161 limits the fetch. */
1163 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1165 /* Now decide how large of chunks to try to read in one operation. This
1166 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1167 so we might as well read them all in one operation. If LEN is -1, we
1168 are looking for a null terminator to end the fetching, so we might as
1169 well read in blocks that are large enough to be efficient, but not so
1170 large as to be slow if fetchlimit happens to be large. So we choose the
1171 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1172 200 is way too big for remote debugging over a serial line. */
1174 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1176 /* Loop until we either have all the characters to print, or we encounter
1177 some error, such as bumping into the end of the address space. */
1180 old_chain
= make_cleanup (null_cleanup
, 0);
1184 buffer
= (gdb_byte
*) xmalloc (len
* width
);
1186 old_chain
= make_cleanup (xfree
, buffer
);
1188 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1190 addr
+= nfetch
* width
;
1191 bufptr
+= nfetch
* width
;
1195 unsigned long bufsize
= 0;
1199 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1202 buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1205 discard_cleanups (old_chain
);
1206 buffer
= (gdb_byte
*) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1209 old_chain
= make_cleanup (xfree
, buffer
);
1210 bufptr
= buffer
+ bufsize
* width
;
1213 /* Read as much as we can. */
1214 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1217 /* Scan this chunk for the null byte that terminates the string
1218 to print. If found, we don't need to fetch any more. Note
1219 that bufptr is explicitly left pointing at the next character
1220 after the null byte, or at the next character after the end of
1223 limit
= bufptr
+ nfetch
* width
;
1224 while (bufptr
< limit
)
1228 c
= extract_unsigned_integer (bufptr
, width
);
1233 /* We don't care about any error which happened after
1234 the NULL terminator. */
1241 while (errcode
== 0 /* no error */
1242 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1243 && !found_nul
); /* haven't found nul yet */
1246 { /* length of string is really 0! */
1247 buffer
= bufptr
= NULL
;
1251 /* bufptr and addr now point immediately beyond the last byte which we
1252 consider part of the string (including a '\0' which ends the string). */
1254 /* We now have either successfully filled the buffer to fetchlimit, or
1255 terminated early due to an error or finding a null char when LEN is -1. */
1257 if (len
== -1 && !found_nul
)
1261 /* We didn't find a null terminator we were looking for. Attempt
1262 to peek at the next character. If not successful, or it is not
1263 a null byte, then force ellipsis to be printed. */
1265 peekbuf
= (gdb_byte
*) alloca (width
);
1267 if (target_read_memory (addr
, peekbuf
, width
) == 0
1268 && extract_unsigned_integer (peekbuf
, width
) != 0)
1271 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1273 /* Getting an error when we have a requested length, or fetching less
1274 than the number of characters actually requested, always make us
1281 /* If we get an error before fetching anything, don't print a string.
1282 But if we fetch something and then get an error, print the string
1283 and then the error message. */
1284 if (errcode
== 0 || bufptr
> buffer
)
1288 fputs_filtered (" ", stream
);
1290 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1297 fprintf_filtered (stream
, " <Address ");
1298 fputs_filtered (paddress (addr
), stream
);
1299 fprintf_filtered (stream
, " out of bounds>");
1303 fprintf_filtered (stream
, " <Error reading address ");
1304 fputs_filtered (paddress (addr
), stream
);
1305 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1309 do_cleanups (old_chain
);
1310 return ((bufptr
- buffer
) / width
);
1314 /* Validate an input or output radix setting, and make sure the user
1315 knows what they really did here. Radix setting is confusing, e.g.
1316 setting the input radix to "10" never changes it! */
1319 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1321 set_input_radix_1 (from_tty
, input_radix
);
1325 set_input_radix_1 (int from_tty
, unsigned radix
)
1327 /* We don't currently disallow any input radix except 0 or 1, which don't
1328 make any mathematical sense. In theory, we can deal with any input
1329 radix greater than 1, even if we don't have unique digits for every
1330 value from 0 to radix-1, but in practice we lose on large radix values.
1331 We should either fix the lossage or restrict the radix range more.
1336 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1338 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1341 input_radix
= radix
;
1344 printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1345 radix
, radix
, radix
);
1350 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1352 set_output_radix_1 (from_tty
, output_radix
);
1356 set_output_radix_1 (int from_tty
, unsigned radix
)
1358 /* Validate the radix and disallow ones that we aren't prepared to
1359 handle correctly, leaving the radix unchanged. */
1363 output_format
= 'x'; /* hex */
1366 output_format
= 0; /* decimal */
1369 output_format
= 'o'; /* octal */
1372 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1374 error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1377 output_radix
= radix
;
1380 printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1381 radix
, radix
, radix
);
1385 /* Set both the input and output radix at once. Try to set the output radix
1386 first, since it has the most restrictive range. An radix that is valid as
1387 an output radix is also valid as an input radix.
1389 It may be useful to have an unusual input radix. If the user wishes to
1390 set an input radix that is not valid as an output radix, he needs to use
1391 the 'set input-radix' command. */
1394 set_radix (char *arg
, int from_tty
)
1398 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1399 set_output_radix_1 (0, radix
);
1400 set_input_radix_1 (0, radix
);
1403 printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1404 radix
, radix
, radix
);
1408 /* Show both the input and output radices. */
1411 show_radix (char *arg
, int from_tty
)
1415 if (input_radix
== output_radix
)
1417 printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1418 input_radix
, input_radix
, input_radix
);
1422 printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1423 input_radix
, input_radix
, input_radix
);
1424 printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1425 output_radix
, output_radix
, output_radix
);
1432 set_print (char *arg
, int from_tty
)
1435 "\"set print\" must be followed by the name of a print subcommand.\n");
1436 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1440 show_print (char *args
, int from_tty
)
1442 cmd_show_list (showprintlist
, from_tty
, "");
1446 _initialize_valprint (void)
1448 struct cmd_list_element
*c
;
1450 add_prefix_cmd ("print", no_class
, set_print
,
1451 _("Generic command for setting how things print."),
1452 &setprintlist
, "set print ", 0, &setlist
);
1453 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1454 /* prefer set print to set prompt */
1455 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1457 add_prefix_cmd ("print", no_class
, show_print
,
1458 _("Generic command for showing print settings."),
1459 &showprintlist
, "show print ", 0, &showlist
);
1460 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1461 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1463 add_setshow_uinteger_cmd ("elements", no_class
, &print_max
, _("\
1464 Set limit on string chars or array elements to print."), _("\
1465 Show limit on string chars or array elements to print."), _("\
1466 \"set print elements 0\" causes there to be no limit."),
1469 &setprintlist
, &showprintlist
);
1471 add_setshow_boolean_cmd ("null-stop", no_class
, &stop_print_at_null
, _("\
1472 Set printing of char arrays to stop at first null char."), _("\
1473 Show printing of char arrays to stop at first null char."), NULL
,
1475 show_stop_print_at_null
,
1476 &setprintlist
, &showprintlist
);
1478 add_setshow_uinteger_cmd ("repeats", no_class
,
1479 &repeat_count_threshold
, _("\
1480 Set threshold for repeated print elements."), _("\
1481 Show threshold for repeated print elements."), _("\
1482 \"set print repeats 0\" causes all elements to be individually printed."),
1484 show_repeat_count_threshold
,
1485 &setprintlist
, &showprintlist
);
1487 add_setshow_boolean_cmd ("pretty", class_support
, &prettyprint_structs
, _("\
1488 Set prettyprinting of structures."), _("\
1489 Show prettyprinting of structures."), NULL
,
1491 show_prettyprint_structs
,
1492 &setprintlist
, &showprintlist
);
1494 add_setshow_boolean_cmd ("union", class_support
, &unionprint
, _("\
1495 Set printing of unions interior to structures."), _("\
1496 Show printing of unions interior to structures."), NULL
,
1499 &setprintlist
, &showprintlist
);
1501 add_setshow_boolean_cmd ("array", class_support
, &prettyprint_arrays
, _("\
1502 Set prettyprinting of arrays."), _("\
1503 Show prettyprinting of arrays."), NULL
,
1505 show_prettyprint_arrays
,
1506 &setprintlist
, &showprintlist
);
1508 add_setshow_boolean_cmd ("address", class_support
, &addressprint
, _("\
1509 Set printing of addresses."), _("\
1510 Show printing of addresses."), NULL
,
1513 &setprintlist
, &showprintlist
);
1515 add_setshow_uinteger_cmd ("input-radix", class_support
, &input_radix
, _("\
1516 Set default input radix for entering numbers."), _("\
1517 Show default input radix for entering numbers."), NULL
,
1520 &setlist
, &showlist
);
1522 add_setshow_uinteger_cmd ("output-radix", class_support
, &output_radix
, _("\
1523 Set default output radix for printing of values."), _("\
1524 Show default output radix for printing of values."), NULL
,
1527 &setlist
, &showlist
);
1529 /* The "set radix" and "show radix" commands are special in that
1530 they are like normal set and show commands but allow two normally
1531 independent variables to be either set or shown with a single
1532 command. So the usual deprecated_add_set_cmd() and [deleted]
1533 add_show_from_set() commands aren't really appropriate. */
1534 /* FIXME: i18n: With the new add_setshow_integer command, that is no
1535 longer true - show can display anything. */
1536 add_cmd ("radix", class_support
, set_radix
, _("\
1537 Set default input and output number radices.\n\
1538 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1539 Without an argument, sets both radices back to the default value of 10."),
1541 add_cmd ("radix", class_support
, show_radix
, _("\
1542 Show the default input and output number radices.\n\
1543 Use 'show input-radix' or 'show output-radix' to independently show each."),
1546 add_setshow_boolean_cmd ("array-indexes", class_support
,
1547 &print_array_indexes
, _("\
1548 Set printing of array indexes."), _("\
1549 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
1550 &setprintlist
, &showprintlist
);
1552 /* Give people the defaults which they are used to. */
1553 prettyprint_structs
= 0;
1554 prettyprint_arrays
= 0;
1557 print_max
= PRINT_MAX_DEFAULT
;