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"
37 #include "exceptions.h"
41 /* Prototypes for local functions */
43 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
44 int len
, int *errnoptr
);
46 static void show_print (char *, int);
48 static void set_print (char *, int);
50 static void set_radix (char *, int);
52 static void show_radix (char *, int);
54 static void set_input_radix (char *, int, struct cmd_list_element
*);
56 static void set_input_radix_1 (int, unsigned);
58 static void set_output_radix (char *, int, struct cmd_list_element
*);
60 static void set_output_radix_1 (int, unsigned);
62 void _initialize_valprint (void);
64 /* Maximum number of chars to print for a string pointer value or vector
65 contents, or UINT_MAX for no limit. Note that "set print elements 0"
66 stores UINT_MAX in print_max, which displays in a show command as
69 unsigned int print_max
;
70 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
72 show_print_max (struct ui_file
*file
, int from_tty
,
73 struct cmd_list_element
*c
, const char *value
)
75 fprintf_filtered (file
, _("\
76 Limit on string chars or array elements to print is %s.\n"),
81 /* Default input and output radixes, and output format letter. */
83 unsigned input_radix
= 10;
85 show_input_radix (struct ui_file
*file
, int from_tty
,
86 struct cmd_list_element
*c
, const char *value
)
88 fprintf_filtered (file
, _("\
89 Default input radix for entering numbers is %s.\n"),
93 unsigned output_radix
= 10;
95 show_output_radix (struct ui_file
*file
, int from_tty
,
96 struct cmd_list_element
*c
, const char *value
)
98 fprintf_filtered (file
, _("\
99 Default output radix for printing of values is %s.\n"),
102 int output_format
= 0;
104 /* By default we print arrays without printing the index of each element in
105 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
107 static int print_array_indexes
= 0;
109 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
110 struct cmd_list_element
*c
, const char *value
)
112 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
115 /* Print repeat counts if there are more than this many repetitions of an
116 element in an array. Referenced by the low level language dependent
119 unsigned int repeat_count_threshold
= 10;
121 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
, const char *value
)
124 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
128 /* If nonzero, stops printing of char arrays at first null. */
130 int stop_print_at_null
;
132 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
, const char *value
)
135 fprintf_filtered (file
, _("\
136 Printing of char arrays to stop at first null char is %s.\n"),
140 /* Controls pretty printing of structures. */
142 int prettyprint_structs
;
144 show_prettyprint_structs (struct ui_file
*file
, int from_tty
,
145 struct cmd_list_element
*c
, const char *value
)
147 fprintf_filtered (file
, _("Prettyprinting of structures is %s.\n"), value
);
150 /* Controls pretty printing of arrays. */
152 int prettyprint_arrays
;
154 show_prettyprint_arrays (struct ui_file
*file
, int from_tty
,
155 struct cmd_list_element
*c
, const char *value
)
157 fprintf_filtered (file
, _("Prettyprinting of arrays is %s.\n"), value
);
160 /* If nonzero, causes unions inside structures or other unions to be
163 int unionprint
; /* Controls printing of nested unions. */
165 show_unionprint (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 fprintf_filtered (file
, _("\
169 Printing of unions interior to structures is %s.\n"),
173 /* If nonzero, causes machine addresses to be printed in certain contexts. */
175 int addressprint
; /* Controls printing of machine addresses */
177 show_addressprint (struct ui_file
*file
, int from_tty
,
178 struct cmd_list_element
*c
, const char *value
)
180 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
184 /* Print data of type TYPE located at VALADDR (within GDB), which came from
185 the inferior at address ADDRESS, onto stdio stream STREAM according to
186 FORMAT (a letter, or 0 for natural format using TYPE).
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
)
209 volatile struct gdb_exception except
;
212 struct type
*real_type
= check_typedef (type
);
213 if (pretty
== Val_pretty_default
)
215 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
= LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
234 stream
, format
, deref_ref
, recurse
, pretty
);
236 if (except
.reason
< 0)
237 fprintf_filtered (stream
, _("<error reading variable>"));
242 /* Check whether the value VAL is printable. Return 1 if it is;
243 return 0 and print an appropriate error message to STREAM if it
247 value_check_printable (struct value
*val
, struct ui_file
*stream
)
251 fprintf_filtered (stream
, _("<address of value unknown>"));
255 if (value_optimized_out (val
))
257 fprintf_filtered (stream
, _("<value optimized out>"));
264 /* Print the value VAL onto stream STREAM according to FORMAT (a
265 letter, or 0 for natural format using TYPE).
267 If DEREF_REF is nonzero, then dereference references, otherwise just print
270 The PRETTY parameter controls prettyprinting.
272 If the data are a string pointer, returns the number of string characters
275 This is a preferable interface to val_print, above, because it uses
276 GDB's value mechanism. */
279 common_val_print (struct value
*val
, struct ui_file
*stream
, int format
,
280 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
282 if (!value_check_printable (val
, stream
))
285 return val_print (value_type (val
), value_contents_all (val
),
286 value_embedded_offset (val
), VALUE_ADDRESS (val
),
287 stream
, format
, deref_ref
, recurse
, pretty
);
290 /* Print the value VAL in C-ish syntax on stream STREAM.
291 FORMAT is a format-letter, or 0 for print in natural format of data type.
292 If the object printed is a string pointer, returns
293 the number of string bytes printed. */
296 value_print (struct value
*val
, struct ui_file
*stream
, int format
,
297 enum val_prettyprint pretty
)
299 if (!value_check_printable (val
, stream
))
302 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
305 /* Called by various <lang>_val_print routines to print
306 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
307 value. STREAM is where to print the value. */
310 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
311 struct ui_file
*stream
)
313 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
317 if (TYPE_UNSIGNED (type
)
318 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
321 print_longest (stream
, 'u', 0, val
);
325 /* Signed, or we couldn't turn an unsigned value into a
326 LONGEST. For signed values, one could assume two's
327 complement (a reasonable assumption, I think) and do
329 print_hex_chars (stream
, (unsigned char *) valaddr
,
335 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
336 unpack_long (type
, valaddr
));
341 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
342 struct ui_file
*stream
)
344 ULONGEST val
= unpack_long (type
, valaddr
);
345 int bitpos
, nfields
= TYPE_NFIELDS (type
);
347 fputs_filtered ("[ ", stream
);
348 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
350 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
351 && (val
& ((ULONGEST
)1 << bitpos
)))
353 if (TYPE_FIELD_NAME (type
, bitpos
))
354 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
356 fprintf_filtered (stream
, "#%d ", bitpos
);
359 fputs_filtered ("]", stream
);
362 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
363 The raison d'etre of this function is to consolidate printing of
364 LONG_LONG's into this one function. The format chars b,h,w,g are
365 from print_scalar_formatted(). Numbers are printed using C
368 USE_C_FORMAT means to use C format in all cases. Without it,
369 'o' and 'x' format do not include the standard C radix prefix
372 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
373 and was intended to request formating according to the current
374 language and would be used for most integers that GDB prints. The
375 exceptional cases were things like protocols where the format of
376 the integer is a protocol thing, not a user-visible thing). The
377 parameter remains to preserve the information of what things might
378 be printed with language-specific format, should we ever resurrect
382 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
390 val
= int_string (val_long
, 10, 1, 0, 1); break;
392 val
= int_string (val_long
, 10, 0, 0, 1); break;
394 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
396 val
= int_string (val_long
, 16, 0, 2, 1); break;
398 val
= int_string (val_long
, 16, 0, 4, 1); break;
400 val
= int_string (val_long
, 16, 0, 8, 1); break;
402 val
= int_string (val_long
, 16, 0, 16, 1); break;
405 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
407 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
409 fputs_filtered (val
, stream
);
412 /* This used to be a macro, but I don't think it is called often enough
413 to merit such treatment. */
414 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
415 arguments to a function, number in a value history, register number, etc.)
416 where the value must not be larger than can fit in an int. */
419 longest_to_int (LONGEST arg
)
421 /* Let the compiler do the work */
422 int rtnval
= (int) arg
;
424 /* Check for overflows or underflows */
425 if (sizeof (LONGEST
) > sizeof (int))
429 error (_("Value out of range."));
435 /* Print a floating point value of type TYPE (not always a
436 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
439 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
440 struct ui_file
*stream
)
444 const struct floatformat
*fmt
= NULL
;
445 unsigned len
= TYPE_LENGTH (type
);
447 /* If it is a floating-point, check for obvious problems. */
448 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
449 fmt
= floatformat_from_type (type
);
450 if (fmt
!= NULL
&& floatformat_is_nan (fmt
, valaddr
))
452 if (floatformat_is_negative (fmt
, valaddr
))
453 fprintf_filtered (stream
, "-");
454 fprintf_filtered (stream
, "nan(");
455 fputs_filtered ("0x", stream
);
456 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
457 fprintf_filtered (stream
, ")");
461 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
462 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
463 needs to be used as that takes care of any necessary type
464 conversions. Such conversions are of course direct to DOUBLEST
465 and disregard any possible target floating point limitations.
466 For instance, a u64 would be converted and displayed exactly on a
467 host with 80 bit DOUBLEST but with loss of information on a host
468 with 64 bit DOUBLEST. */
470 doub
= unpack_double (type
, valaddr
, &inv
);
473 fprintf_filtered (stream
, "<invalid float value>");
477 /* FIXME: kettenis/2001-01-20: The following code makes too much
478 assumptions about the host and target floating point format. */
480 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
481 not necessarily be a TYPE_CODE_FLT, the below ignores that and
482 instead uses the type's length to determine the precision of the
483 floating-point value being printed. */
485 if (len
< sizeof (double))
486 fprintf_filtered (stream
, "%.9g", (double) doub
);
487 else if (len
== sizeof (double))
488 fprintf_filtered (stream
, "%.17g", (double) doub
);
490 #ifdef PRINTF_HAS_LONG_DOUBLE
491 fprintf_filtered (stream
, "%.35Lg", doub
);
493 /* This at least wins with values that are representable as
495 fprintf_filtered (stream
, "%.17g", (double) doub
);
500 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
504 #define BITS_IN_BYTES 8
510 /* Declared "int" so it will be signed.
511 * This ensures that right shift will shift in zeros.
513 const int mask
= 0x080;
515 /* FIXME: We should be not printing leading zeroes in most cases. */
517 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
523 /* Every byte has 8 binary characters; peel off
524 * and print from the MSB end.
526 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
528 if (*p
& (mask
>> i
))
533 fprintf_filtered (stream
, "%1d", b
);
539 for (p
= valaddr
+ len
- 1;
543 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
545 if (*p
& (mask
>> i
))
550 fprintf_filtered (stream
, "%1d", b
);
556 /* VALADDR points to an integer of LEN bytes.
557 * Print it in octal on stream or format it in buf.
560 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
564 unsigned char octa1
, octa2
, octa3
, carry
;
567 /* FIXME: We should be not printing leading zeroes in most cases. */
570 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
571 * the extra bits, which cycle every three bytes:
575 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
577 * Octal side: 0 1 carry 3 4 carry ...
579 * Cycle number: 0 1 2
581 * But of course we are printing from the high side, so we have to
582 * figure out where in the cycle we are so that we end up with no
583 * left over bits at the end.
585 #define BITS_IN_OCTAL 3
586 #define HIGH_ZERO 0340
587 #define LOW_ZERO 0016
588 #define CARRY_ZERO 0003
589 #define HIGH_ONE 0200
592 #define CARRY_ONE 0001
593 #define HIGH_TWO 0300
597 /* For 32 we start in cycle 2, with two bits and one bit carry;
598 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
600 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
603 fputs_filtered ("0", stream
);
604 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
613 /* No carry in, carry out two bits.
615 octa1
= (HIGH_ZERO
& *p
) >> 5;
616 octa2
= (LOW_ZERO
& *p
) >> 2;
617 carry
= (CARRY_ZERO
& *p
);
618 fprintf_filtered (stream
, "%o", octa1
);
619 fprintf_filtered (stream
, "%o", octa2
);
623 /* Carry in two bits, carry out one bit.
625 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
626 octa2
= (MID_ONE
& *p
) >> 4;
627 octa3
= (LOW_ONE
& *p
) >> 1;
628 carry
= (CARRY_ONE
& *p
);
629 fprintf_filtered (stream
, "%o", octa1
);
630 fprintf_filtered (stream
, "%o", octa2
);
631 fprintf_filtered (stream
, "%o", octa3
);
635 /* Carry in one bit, no carry out.
637 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
638 octa2
= (MID_TWO
& *p
) >> 3;
639 octa3
= (LOW_TWO
& *p
);
641 fprintf_filtered (stream
, "%o", octa1
);
642 fprintf_filtered (stream
, "%o", octa2
);
643 fprintf_filtered (stream
, "%o", octa3
);
647 error (_("Internal error in octal conversion;"));
651 cycle
= cycle
% BITS_IN_OCTAL
;
656 for (p
= valaddr
+ len
- 1;
663 /* Carry out, no carry in */
664 octa1
= (HIGH_ZERO
& *p
) >> 5;
665 octa2
= (LOW_ZERO
& *p
) >> 2;
666 carry
= (CARRY_ZERO
& *p
);
667 fprintf_filtered (stream
, "%o", octa1
);
668 fprintf_filtered (stream
, "%o", octa2
);
672 /* Carry in, carry out */
673 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
674 octa2
= (MID_ONE
& *p
) >> 4;
675 octa3
= (LOW_ONE
& *p
) >> 1;
676 carry
= (CARRY_ONE
& *p
);
677 fprintf_filtered (stream
, "%o", octa1
);
678 fprintf_filtered (stream
, "%o", octa2
);
679 fprintf_filtered (stream
, "%o", octa3
);
683 /* Carry in, no carry out */
684 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
685 octa2
= (MID_TWO
& *p
) >> 3;
686 octa3
= (LOW_TWO
& *p
);
688 fprintf_filtered (stream
, "%o", octa1
);
689 fprintf_filtered (stream
, "%o", octa2
);
690 fprintf_filtered (stream
, "%o", octa3
);
694 error (_("Internal error in octal conversion;"));
698 cycle
= cycle
% BITS_IN_OCTAL
;
704 /* VALADDR points to an integer of LEN bytes.
705 * Print it in decimal on stream or format it in buf.
708 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
712 #define TWO_TO_FOURTH 16
713 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
714 #define CARRY_LEFT( x ) ((x) % TEN)
715 #define SHIFT( x ) ((x) << 4)
717 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
719 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
721 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? p++ : p-- )
722 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
723 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
726 unsigned char *digits
;
729 int i
, j
, decimal_digits
;
733 /* Base-ten number is less than twice as many digits
734 * as the base 16 number, which is 2 digits per byte.
736 decimal_len
= len
* 2 * 2;
737 digits
= xmalloc (decimal_len
);
739 for (i
= 0; i
< decimal_len
; i
++)
744 /* Ok, we have an unknown number of bytes of data to be printed in
747 * Given a hex number (in nibbles) as XYZ, we start by taking X and
748 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
749 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
751 * The trick is that "digits" holds a base-10 number, but sometimes
752 * the individual digits are > 10.
754 * Outer loop is per nibble (hex digit) of input, from MSD end to
757 decimal_digits
= 0; /* Number of decimal digits so far */
763 * Multiply current base-ten number by 16 in place.
764 * Each digit was between 0 and 9, now is between
767 for (j
= 0; j
< decimal_digits
; j
++)
769 digits
[j
] = SHIFT (digits
[j
]);
772 /* Take the next nibble off the input and add it to what
773 * we've got in the LSB position. Bottom 'digit' is now
776 * "flip" is used to run this loop twice for each byte.
782 digits
[0] += HIGH_NIBBLE (*p
);
787 /* Take low nibble and bump our pointer "p".
789 digits
[0] += LOW_NIBBLE (*p
);
794 /* Re-decimalize. We have to do this often enough
795 * that we don't overflow, but once per nibble is
796 * overkill. Easier this way, though. Note that the
797 * carry is often larger than 10 (e.g. max initial
798 * carry out of lowest nibble is 15, could bubble all
799 * the way up greater than 10). So we have to do
800 * the carrying beyond the last current digit.
803 for (j
= 0; j
< decimal_len
- 1; j
++)
807 /* "/" won't handle an unsigned char with
808 * a value that if signed would be negative.
809 * So extend to longword int via "dummy".
812 carry
= CARRY_OUT (dummy
);
813 digits
[j
] = CARRY_LEFT (dummy
);
815 if (j
>= decimal_digits
&& carry
== 0)
818 * All higher digits are 0 and we
819 * no longer have a carry.
821 * Note: "j" is 0-based, "decimal_digits" is
824 decimal_digits
= j
+ 1;
830 /* Ok, now "digits" is the decimal representation, with
831 * the "decimal_digits" actual digits. Print!
833 for (i
= decimal_digits
- 1; i
>= 0; i
--)
835 fprintf_filtered (stream
, "%1d", digits
[i
]);
840 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
843 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
848 /* FIXME: We should be not printing leading zeroes in most cases. */
850 fputs_filtered ("0x", stream
);
851 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
857 fprintf_filtered (stream
, "%02x", *p
);
862 for (p
= valaddr
+ len
- 1;
866 fprintf_filtered (stream
, "%02x", *p
);
871 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
872 Omit any leading zero chars. */
875 print_char_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
880 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
883 while (p
< valaddr
+ len
- 1 && *p
== 0)
886 while (p
< valaddr
+ len
)
888 LA_EMIT_CHAR (*p
, stream
, '\'');
894 p
= valaddr
+ len
- 1;
895 while (p
> valaddr
&& *p
== 0)
900 LA_EMIT_CHAR (*p
, stream
, '\'');
906 /* Return non-zero if the debugger should print the index of each element
907 when printing array values. */
910 print_array_indexes_p (void)
912 return print_array_indexes
;
915 /* Assuming TYPE is a simple, non-empty array type, compute its lower bound.
916 Save it into LOW_BOUND if not NULL.
918 Return 1 if the operation was successful. Return zero otherwise,
919 in which case the value of LOW_BOUND is unmodified.
921 Computing the array lower bound is pretty easy, but this function
922 does some additional verifications before returning the low bound.
923 If something incorrect is detected, it is better to return a status
924 rather than throwing an error, making it easier for the caller to
925 implement an error-recovery plan. For instance, it may decide to
926 warn the user that the bound was not found and then use a default
930 get_array_low_bound (struct type
*type
, long *low_bound
)
932 struct type
*index
= TYPE_INDEX_TYPE (type
);
938 if (TYPE_CODE (index
) != TYPE_CODE_RANGE
939 && TYPE_CODE (index
) != TYPE_CODE_ENUM
)
942 low
= TYPE_LOW_BOUND (index
);
943 if (low
> TYPE_HIGH_BOUND (index
))
952 /* Print on STREAM using the given FORMAT the index for the element
953 at INDEX of an array whose index type is INDEX_TYPE. */
956 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
957 struct ui_file
*stream
, int format
,
958 enum val_prettyprint pretty
)
960 struct value
*index_value
;
962 if (!print_array_indexes
)
965 index_value
= value_from_longest (index_type
, index
);
967 LA_PRINT_ARRAY_INDEX (index_value
, stream
, format
, pretty
);
970 /* Called by various <lang>_val_print routines to print elements of an
971 array in the form "<elem1>, <elem2>, <elem3>, ...".
973 (FIXME?) Assumes array element separator is a comma, which is correct
974 for all languages currently handled.
975 (FIXME?) Some languages have a notation for repeated array elements,
976 perhaps we should try to use that notation when appropriate.
980 val_print_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
981 CORE_ADDR address
, struct ui_file
*stream
,
982 int format
, int deref_ref
,
983 int recurse
, enum val_prettyprint pretty
,
986 unsigned int things_printed
= 0;
988 struct type
*elttype
, *index_type
;
990 /* Position of the array element we are examining to see
991 whether it is repeated. */
993 /* Number of repetitions we have detected so far. */
995 long low_bound_index
= 0;
997 elttype
= TYPE_TARGET_TYPE (type
);
998 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
999 len
= TYPE_LENGTH (type
) / eltlen
;
1000 index_type
= TYPE_INDEX_TYPE (type
);
1002 /* Get the array low bound. This only makes sense if the array
1003 has one or more element in it. */
1004 if (len
> 0 && !get_array_low_bound (type
, &low_bound_index
))
1006 warning ("unable to get low bound of array, using zero as default");
1007 low_bound_index
= 0;
1010 annotate_array_section_begin (i
, elttype
);
1012 for (; i
< len
&& things_printed
< print_max
; i
++)
1016 if (prettyprint_arrays
)
1018 fprintf_filtered (stream
, ",\n");
1019 print_spaces_filtered (2 + 2 * recurse
, stream
);
1023 fprintf_filtered (stream
, ", ");
1026 wrap_here (n_spaces (2 + 2 * recurse
));
1027 maybe_print_array_index (index_type
, i
+ low_bound_index
,
1028 stream
, format
, pretty
);
1032 while ((rep1
< len
) &&
1033 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
1039 if (reps
> repeat_count_threshold
)
1041 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1042 deref_ref
, recurse
+ 1, pretty
);
1043 annotate_elt_rep (reps
);
1044 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1045 annotate_elt_rep_end ();
1048 things_printed
+= repeat_count_threshold
;
1052 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1053 deref_ref
, recurse
+ 1, pretty
);
1058 annotate_array_section_end ();
1061 fprintf_filtered (stream
, "...");
1065 /* Read LEN bytes of target memory at address MEMADDR, placing the
1066 results in GDB's memory at MYADDR. Returns a count of the bytes
1067 actually read, and optionally an errno value in the location
1068 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1070 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1071 function be eliminated. */
1074 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int *errnoptr
)
1076 int nread
; /* Number of bytes actually read. */
1077 int errcode
; /* Error from last read. */
1079 /* First try a complete read. */
1080 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1088 /* Loop, reading one byte at a time until we get as much as we can. */
1089 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1091 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1093 /* If an error, the last read was unsuccessful, so adjust count. */
1099 if (errnoptr
!= NULL
)
1101 *errnoptr
= errcode
;
1106 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1107 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1108 stops at the first null byte, otherwise printing proceeds (including null
1109 bytes) until either print_max or LEN characters have been printed,
1110 whichever is smaller. */
1112 /* FIXME: Use target_read_string. */
1115 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
1117 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1118 int errcode
; /* Errno returned from bad reads. */
1119 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1120 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1121 unsigned int chunksize
; /* Size of each fetch, in chars. */
1122 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
1123 gdb_byte
*bufptr
; /* Pointer to next available byte in buffer. */
1124 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1125 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1126 int found_nul
; /* Non-zero if we found the nul char */
1128 /* First we need to figure out the limit on the number of characters we are
1129 going to attempt to fetch and print. This is actually pretty simple. If
1130 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1131 LEN is -1, then the limit is print_max. This is true regardless of
1132 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1133 because finding the null byte (or available memory) is what actually
1134 limits the fetch. */
1136 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1138 /* Now decide how large of chunks to try to read in one operation. This
1139 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1140 so we might as well read them all in one operation. If LEN is -1, we
1141 are looking for a null terminator to end the fetching, so we might as
1142 well read in blocks that are large enough to be efficient, but not so
1143 large as to be slow if fetchlimit happens to be large. So we choose the
1144 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1145 200 is way too big for remote debugging over a serial line. */
1147 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1149 /* Loop until we either have all the characters to print, or we encounter
1150 some error, such as bumping into the end of the address space. */
1153 old_chain
= make_cleanup (null_cleanup
, 0);
1157 buffer
= (gdb_byte
*) xmalloc (len
* width
);
1159 old_chain
= make_cleanup (xfree
, buffer
);
1161 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1163 addr
+= nfetch
* width
;
1164 bufptr
+= nfetch
* width
;
1168 unsigned long bufsize
= 0;
1172 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1175 buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1178 discard_cleanups (old_chain
);
1179 buffer
= (gdb_byte
*) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1182 old_chain
= make_cleanup (xfree
, buffer
);
1183 bufptr
= buffer
+ bufsize
* width
;
1186 /* Read as much as we can. */
1187 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1190 /* Scan this chunk for the null byte that terminates the string
1191 to print. If found, we don't need to fetch any more. Note
1192 that bufptr is explicitly left pointing at the next character
1193 after the null byte, or at the next character after the end of
1196 limit
= bufptr
+ nfetch
* width
;
1197 while (bufptr
< limit
)
1201 c
= extract_unsigned_integer (bufptr
, width
);
1206 /* We don't care about any error which happened after
1207 the NULL terminator. */
1214 while (errcode
== 0 /* no error */
1215 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1216 && !found_nul
); /* haven't found nul yet */
1219 { /* length of string is really 0! */
1220 buffer
= bufptr
= NULL
;
1224 /* bufptr and addr now point immediately beyond the last byte which we
1225 consider part of the string (including a '\0' which ends the string). */
1227 /* We now have either successfully filled the buffer to fetchlimit, or
1228 terminated early due to an error or finding a null char when LEN is -1. */
1230 if (len
== -1 && !found_nul
)
1234 /* We didn't find a null terminator we were looking for. Attempt
1235 to peek at the next character. If not successful, or it is not
1236 a null byte, then force ellipsis to be printed. */
1238 peekbuf
= (gdb_byte
*) alloca (width
);
1240 if (target_read_memory (addr
, peekbuf
, width
) == 0
1241 && extract_unsigned_integer (peekbuf
, width
) != 0)
1244 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1246 /* Getting an error when we have a requested length, or fetching less
1247 than the number of characters actually requested, always make us
1254 /* If we get an error before fetching anything, don't print a string.
1255 But if we fetch something and then get an error, print the string
1256 and then the error message. */
1257 if (errcode
== 0 || bufptr
> buffer
)
1261 fputs_filtered (" ", stream
);
1263 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1270 fprintf_filtered (stream
, " <Address ");
1271 deprecated_print_address_numeric (addr
, 1, stream
);
1272 fprintf_filtered (stream
, " out of bounds>");
1276 fprintf_filtered (stream
, " <Error reading address ");
1277 deprecated_print_address_numeric (addr
, 1, stream
);
1278 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1282 do_cleanups (old_chain
);
1283 return ((bufptr
- buffer
) / width
);
1287 /* Validate an input or output radix setting, and make sure the user
1288 knows what they really did here. Radix setting is confusing, e.g.
1289 setting the input radix to "10" never changes it! */
1292 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1294 set_input_radix_1 (from_tty
, input_radix
);
1298 set_input_radix_1 (int from_tty
, unsigned radix
)
1300 /* We don't currently disallow any input radix except 0 or 1, which don't
1301 make any mathematical sense. In theory, we can deal with any input
1302 radix greater than 1, even if we don't have unique digits for every
1303 value from 0 to radix-1, but in practice we lose on large radix values.
1304 We should either fix the lossage or restrict the radix range more.
1309 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1311 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1314 input_radix
= radix
;
1317 printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1318 radix
, radix
, radix
);
1323 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1325 set_output_radix_1 (from_tty
, output_radix
);
1329 set_output_radix_1 (int from_tty
, unsigned radix
)
1331 /* Validate the radix and disallow ones that we aren't prepared to
1332 handle correctly, leaving the radix unchanged. */
1336 output_format
= 'x'; /* hex */
1339 output_format
= 0; /* decimal */
1342 output_format
= 'o'; /* octal */
1345 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1347 error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1350 output_radix
= radix
;
1353 printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1354 radix
, radix
, radix
);
1358 /* Set both the input and output radix at once. Try to set the output radix
1359 first, since it has the most restrictive range. An radix that is valid as
1360 an output radix is also valid as an input radix.
1362 It may be useful to have an unusual input radix. If the user wishes to
1363 set an input radix that is not valid as an output radix, he needs to use
1364 the 'set input-radix' command. */
1367 set_radix (char *arg
, int from_tty
)
1371 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1372 set_output_radix_1 (0, radix
);
1373 set_input_radix_1 (0, radix
);
1376 printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1377 radix
, radix
, radix
);
1381 /* Show both the input and output radices. */
1384 show_radix (char *arg
, int from_tty
)
1388 if (input_radix
== output_radix
)
1390 printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1391 input_radix
, input_radix
, input_radix
);
1395 printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1396 input_radix
, input_radix
, input_radix
);
1397 printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1398 output_radix
, output_radix
, output_radix
);
1405 set_print (char *arg
, int from_tty
)
1408 "\"set print\" must be followed by the name of a print subcommand.\n");
1409 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1413 show_print (char *args
, int from_tty
)
1415 cmd_show_list (showprintlist
, from_tty
, "");
1419 _initialize_valprint (void)
1421 struct cmd_list_element
*c
;
1423 add_prefix_cmd ("print", no_class
, set_print
,
1424 _("Generic command for setting how things print."),
1425 &setprintlist
, "set print ", 0, &setlist
);
1426 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1427 /* prefer set print to set prompt */
1428 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1430 add_prefix_cmd ("print", no_class
, show_print
,
1431 _("Generic command for showing print settings."),
1432 &showprintlist
, "show print ", 0, &showlist
);
1433 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1434 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1436 add_setshow_uinteger_cmd ("elements", no_class
, &print_max
, _("\
1437 Set limit on string chars or array elements to print."), _("\
1438 Show limit on string chars or array elements to print."), _("\
1439 \"set print elements 0\" causes there to be no limit."),
1442 &setprintlist
, &showprintlist
);
1444 add_setshow_boolean_cmd ("null-stop", no_class
, &stop_print_at_null
, _("\
1445 Set printing of char arrays to stop at first null char."), _("\
1446 Show printing of char arrays to stop at first null char."), NULL
,
1448 show_stop_print_at_null
,
1449 &setprintlist
, &showprintlist
);
1451 add_setshow_uinteger_cmd ("repeats", no_class
,
1452 &repeat_count_threshold
, _("\
1453 Set threshold for repeated print elements."), _("\
1454 Show threshold for repeated print elements."), _("\
1455 \"set print repeats 0\" causes all elements to be individually printed."),
1457 show_repeat_count_threshold
,
1458 &setprintlist
, &showprintlist
);
1460 add_setshow_boolean_cmd ("pretty", class_support
, &prettyprint_structs
, _("\
1461 Set prettyprinting of structures."), _("\
1462 Show prettyprinting of structures."), NULL
,
1464 show_prettyprint_structs
,
1465 &setprintlist
, &showprintlist
);
1467 add_setshow_boolean_cmd ("union", class_support
, &unionprint
, _("\
1468 Set printing of unions interior to structures."), _("\
1469 Show printing of unions interior to structures."), NULL
,
1472 &setprintlist
, &showprintlist
);
1474 add_setshow_boolean_cmd ("array", class_support
, &prettyprint_arrays
, _("\
1475 Set prettyprinting of arrays."), _("\
1476 Show prettyprinting of arrays."), NULL
,
1478 show_prettyprint_arrays
,
1479 &setprintlist
, &showprintlist
);
1481 add_setshow_boolean_cmd ("address", class_support
, &addressprint
, _("\
1482 Set printing of addresses."), _("\
1483 Show printing of addresses."), NULL
,
1486 &setprintlist
, &showprintlist
);
1488 add_setshow_uinteger_cmd ("input-radix", class_support
, &input_radix
, _("\
1489 Set default input radix for entering numbers."), _("\
1490 Show default input radix for entering numbers."), NULL
,
1493 &setlist
, &showlist
);
1495 add_setshow_uinteger_cmd ("output-radix", class_support
, &output_radix
, _("\
1496 Set default output radix for printing of values."), _("\
1497 Show default output radix for printing of values."), NULL
,
1500 &setlist
, &showlist
);
1502 /* The "set radix" and "show radix" commands are special in that
1503 they are like normal set and show commands but allow two normally
1504 independent variables to be either set or shown with a single
1505 command. So the usual deprecated_add_set_cmd() and [deleted]
1506 add_show_from_set() commands aren't really appropriate. */
1507 /* FIXME: i18n: With the new add_setshow_integer command, that is no
1508 longer true - show can display anything. */
1509 add_cmd ("radix", class_support
, set_radix
, _("\
1510 Set default input and output number radices.\n\
1511 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1512 Without an argument, sets both radices back to the default value of 10."),
1514 add_cmd ("radix", class_support
, show_radix
, _("\
1515 Show the default input and output number radices.\n\
1516 Use 'show input-radix' or 'show output-radix' to independently show each."),
1519 add_setshow_boolean_cmd ("array-indexes", class_support
,
1520 &print_array_indexes
, _("\
1521 Set printing of array indexes."), _("\
1522 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
1523 &setprintlist
, &showprintlist
);
1525 /* Give people the defaults which they are used to. */
1526 prettyprint_structs
= 0;
1527 prettyprint_arrays
= 0;
1530 print_max
= PRINT_MAX_DEFAULT
;