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, 2005 Free Software
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 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 /* Print repeat counts if there are more than this many repetitions of an
104 element in an array. Referenced by the low level language dependent
107 unsigned int repeat_count_threshold
= 10;
109 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
110 struct cmd_list_element
*c
, const char *value
)
112 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
116 /* If nonzero, stops printing of char arrays at first null. */
118 int stop_print_at_null
;
120 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
, const char *value
)
123 fprintf_filtered (file
, _("\
124 Printing of char arrays to stop at first null char is %s.\n"),
128 /* Controls pretty printing of structures. */
130 int prettyprint_structs
;
132 show_prettyprint_structs (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
, const char *value
)
135 fprintf_filtered (file
, _("Prettyprinting of structures is %s.\n"), value
);
138 /* Controls pretty printing of arrays. */
140 int prettyprint_arrays
;
142 show_prettyprint_arrays (struct ui_file
*file
, int from_tty
,
143 struct cmd_list_element
*c
, const char *value
)
145 fprintf_filtered (file
, _("Prettyprinting of arrays is %s.\n"), value
);
148 /* If nonzero, causes unions inside structures or other unions to be
151 int unionprint
; /* Controls printing of nested unions. */
153 show_unionprint (struct ui_file
*file
, int from_tty
,
154 struct cmd_list_element
*c
, const char *value
)
156 fprintf_filtered (file
, _("\
157 Printing of unions interior to structures is %s.\n"),
161 /* If nonzero, causes machine addresses to be printed in certain contexts. */
163 int addressprint
; /* Controls printing of machine addresses */
165 show_addressprint (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
172 /* Print data of type TYPE located at VALADDR (within GDB), which came from
173 the inferior at address ADDRESS, onto stdio stream STREAM according to
174 FORMAT (a letter, or 0 for natural format using TYPE).
176 If DEREF_REF is nonzero, then dereference references, otherwise just print
179 The PRETTY parameter controls prettyprinting.
181 If the data are a string pointer, returns the number of string characters
184 FIXME: The data at VALADDR is in target byte order. If gdb is ever
185 enhanced to be able to debug more than the single target it was compiled
186 for (specific CPU type and thus specific target byte ordering), then
187 either the print routines are going to have to take this into account,
188 or the data is going to have to be passed into here already converted
189 to the host byte ordering, whichever is more convenient. */
193 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
194 CORE_ADDR address
, struct ui_file
*stream
, int format
,
195 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
197 struct type
*real_type
= check_typedef (type
);
198 if (pretty
== Val_pretty_default
)
200 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
205 /* Ensure that the type is complete and not just a stub. If the type is
206 only a stub and we can't find and substitute its complete type, then
207 print appropriate string and return. */
209 if (TYPE_STUB (real_type
))
211 fprintf_filtered (stream
, "<incomplete type>");
216 return (LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
217 stream
, format
, deref_ref
, recurse
, pretty
));
220 /* Check whether the value VAL is printable. Return 1 if it is;
221 return 0 and print an appropriate error message to STREAM if it
225 value_check_printable (struct value
*val
, struct ui_file
*stream
)
229 fprintf_filtered (stream
, _("<address of value unknown>"));
233 if (value_optimized_out (val
))
235 fprintf_filtered (stream
, _("<value optimized out>"));
242 /* Print the value VAL onto stream STREAM according to FORMAT (a
243 letter, or 0 for natural format using TYPE).
245 If DEREF_REF is nonzero, then dereference references, otherwise just print
248 The PRETTY parameter controls prettyprinting.
250 If the data are a string pointer, returns the number of string characters
253 This is a preferable interface to val_print, above, because it uses
254 GDB's value mechanism. */
257 common_val_print (struct value
*val
, struct ui_file
*stream
, int format
,
258 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
260 if (!value_check_printable (val
, stream
))
263 return val_print (value_type (val
), value_contents_all (val
),
264 value_embedded_offset (val
), VALUE_ADDRESS (val
),
265 stream
, format
, deref_ref
, recurse
, pretty
);
268 /* Print the value VAL in C-ish syntax on stream STREAM.
269 FORMAT is a format-letter, or 0 for print in natural format of data type.
270 If the object printed is a string pointer, returns
271 the number of string bytes printed. */
274 value_print (struct value
*val
, struct ui_file
*stream
, int format
,
275 enum val_prettyprint pretty
)
277 if (!value_check_printable (val
, stream
))
280 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
283 /* Called by various <lang>_val_print routines to print
284 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
285 value. STREAM is where to print the value. */
288 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
289 struct ui_file
*stream
)
291 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
295 if (TYPE_UNSIGNED (type
)
296 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
299 print_longest (stream
, 'u', 0, val
);
303 /* Signed, or we couldn't turn an unsigned value into a
304 LONGEST. For signed values, one could assume two's
305 complement (a reasonable assumption, I think) and do
307 print_hex_chars (stream
, (unsigned char *) valaddr
,
313 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
314 unpack_long (type
, valaddr
));
318 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
319 The raison d'etre of this function is to consolidate printing of
320 LONG_LONG's into this one function. The format chars b,h,w,g are
321 from print_scalar_formatted(). Numbers are printed using C
324 USE_C_FORMAT means to use C format in all cases. Without it,
325 'o' and 'x' format do not include the standard C radix prefix
328 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
329 and was intended to request formating according to the current
330 language and would be used for most integers that GDB prints. The
331 exceptional cases were things like protocols where the format of
332 the integer is a protocol thing, not a user-visible thing). The
333 parameter remains to preserve the information of what things might
334 be printed with language-specific format, should we ever resurrect
338 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
346 val
= int_string (val_long
, 10, 1, 0, 1); break;
348 val
= int_string (val_long
, 10, 0, 0, 1); break;
350 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
352 val
= int_string (val_long
, 16, 0, 2, 1); break;
354 val
= int_string (val_long
, 16, 0, 4, 1); break;
356 val
= int_string (val_long
, 16, 0, 8, 1); break;
358 val
= int_string (val_long
, 16, 0, 16, 1); break;
361 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
363 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
365 fputs_filtered (val
, stream
);
368 /* This used to be a macro, but I don't think it is called often enough
369 to merit such treatment. */
370 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
371 arguments to a function, number in a value history, register number, etc.)
372 where the value must not be larger than can fit in an int. */
375 longest_to_int (LONGEST arg
)
377 /* Let the compiler do the work */
378 int rtnval
= (int) arg
;
380 /* Check for overflows or underflows */
381 if (sizeof (LONGEST
) > sizeof (int))
385 error (_("Value out of range."));
391 /* Print a floating point value of type TYPE (not always a
392 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
395 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
396 struct ui_file
*stream
)
400 const struct floatformat
*fmt
= NULL
;
401 unsigned len
= TYPE_LENGTH (type
);
403 /* If it is a floating-point, check for obvious problems. */
404 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
405 fmt
= floatformat_from_type (type
);
406 if (fmt
!= NULL
&& floatformat_is_nan (fmt
, valaddr
))
408 if (floatformat_is_negative (fmt
, valaddr
))
409 fprintf_filtered (stream
, "-");
410 fprintf_filtered (stream
, "nan(");
411 fputs_filtered ("0x", stream
);
412 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
413 fprintf_filtered (stream
, ")");
417 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
418 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
419 needs to be used as that takes care of any necessary type
420 conversions. Such conversions are of course direct to DOUBLEST
421 and disregard any possible target floating point limitations.
422 For instance, a u64 would be converted and displayed exactly on a
423 host with 80 bit DOUBLEST but with loss of information on a host
424 with 64 bit DOUBLEST. */
426 doub
= unpack_double (type
, valaddr
, &inv
);
429 fprintf_filtered (stream
, "<invalid float value>");
433 /* FIXME: kettenis/2001-01-20: The following code makes too much
434 assumptions about the host and target floating point format. */
436 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
437 not necessarially be a TYPE_CODE_FLT, the below ignores that and
438 instead uses the type's length to determine the precision of the
439 floating-point value being printed. */
441 if (len
< sizeof (double))
442 fprintf_filtered (stream
, "%.9g", (double) doub
);
443 else if (len
== sizeof (double))
444 fprintf_filtered (stream
, "%.17g", (double) doub
);
446 #ifdef PRINTF_HAS_LONG_DOUBLE
447 fprintf_filtered (stream
, "%.35Lg", doub
);
449 /* This at least wins with values that are representable as
451 fprintf_filtered (stream
, "%.17g", (double) doub
);
456 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
460 #define BITS_IN_BYTES 8
466 /* Declared "int" so it will be signed.
467 * This ensures that right shift will shift in zeros.
469 const int mask
= 0x080;
471 /* FIXME: We should be not printing leading zeroes in most cases. */
473 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
479 /* Every byte has 8 binary characters; peel off
480 * and print from the MSB end.
482 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
484 if (*p
& (mask
>> i
))
489 fprintf_filtered (stream
, "%1d", b
);
495 for (p
= valaddr
+ len
- 1;
499 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
501 if (*p
& (mask
>> i
))
506 fprintf_filtered (stream
, "%1d", b
);
512 /* VALADDR points to an integer of LEN bytes.
513 * Print it in octal on stream or format it in buf.
516 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
520 unsigned char octa1
, octa2
, octa3
, carry
;
523 /* FIXME: We should be not printing leading zeroes in most cases. */
526 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
527 * the extra bits, which cycle every three bytes:
531 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
533 * Octal side: 0 1 carry 3 4 carry ...
535 * Cycle number: 0 1 2
537 * But of course we are printing from the high side, so we have to
538 * figure out where in the cycle we are so that we end up with no
539 * left over bits at the end.
541 #define BITS_IN_OCTAL 3
542 #define HIGH_ZERO 0340
543 #define LOW_ZERO 0016
544 #define CARRY_ZERO 0003
545 #define HIGH_ONE 0200
548 #define CARRY_ONE 0001
549 #define HIGH_TWO 0300
553 /* For 32 we start in cycle 2, with two bits and one bit carry;
554 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
556 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
559 fputs_filtered ("0", stream
);
560 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
569 /* No carry in, carry out two bits.
571 octa1
= (HIGH_ZERO
& *p
) >> 5;
572 octa2
= (LOW_ZERO
& *p
) >> 2;
573 carry
= (CARRY_ZERO
& *p
);
574 fprintf_filtered (stream
, "%o", octa1
);
575 fprintf_filtered (stream
, "%o", octa2
);
579 /* Carry in two bits, carry out one bit.
581 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
582 octa2
= (MID_ONE
& *p
) >> 4;
583 octa3
= (LOW_ONE
& *p
) >> 1;
584 carry
= (CARRY_ONE
& *p
);
585 fprintf_filtered (stream
, "%o", octa1
);
586 fprintf_filtered (stream
, "%o", octa2
);
587 fprintf_filtered (stream
, "%o", octa3
);
591 /* Carry in one bit, no carry out.
593 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
594 octa2
= (MID_TWO
& *p
) >> 3;
595 octa3
= (LOW_TWO
& *p
);
597 fprintf_filtered (stream
, "%o", octa1
);
598 fprintf_filtered (stream
, "%o", octa2
);
599 fprintf_filtered (stream
, "%o", octa3
);
603 error (_("Internal error in octal conversion;"));
607 cycle
= cycle
% BITS_IN_OCTAL
;
612 for (p
= valaddr
+ len
- 1;
619 /* Carry out, no carry in */
620 octa1
= (HIGH_ZERO
& *p
) >> 5;
621 octa2
= (LOW_ZERO
& *p
) >> 2;
622 carry
= (CARRY_ZERO
& *p
);
623 fprintf_filtered (stream
, "%o", octa1
);
624 fprintf_filtered (stream
, "%o", octa2
);
628 /* Carry in, carry out */
629 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
630 octa2
= (MID_ONE
& *p
) >> 4;
631 octa3
= (LOW_ONE
& *p
) >> 1;
632 carry
= (CARRY_ONE
& *p
);
633 fprintf_filtered (stream
, "%o", octa1
);
634 fprintf_filtered (stream
, "%o", octa2
);
635 fprintf_filtered (stream
, "%o", octa3
);
639 /* Carry in, no carry out */
640 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
641 octa2
= (MID_TWO
& *p
) >> 3;
642 octa3
= (LOW_TWO
& *p
);
644 fprintf_filtered (stream
, "%o", octa1
);
645 fprintf_filtered (stream
, "%o", octa2
);
646 fprintf_filtered (stream
, "%o", octa3
);
650 error (_("Internal error in octal conversion;"));
654 cycle
= cycle
% BITS_IN_OCTAL
;
660 /* VALADDR points to an integer of LEN bytes.
661 * Print it in decimal on stream or format it in buf.
664 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
668 #define TWO_TO_FOURTH 16
669 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
670 #define CARRY_LEFT( x ) ((x) % TEN)
671 #define SHIFT( x ) ((x) << 4)
673 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
675 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
677 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? p++ : p-- )
678 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
679 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
682 unsigned char *digits
;
685 int i
, j
, decimal_digits
;
689 /* Base-ten number is less than twice as many digits
690 * as the base 16 number, which is 2 digits per byte.
692 decimal_len
= len
* 2 * 2;
693 digits
= xmalloc (decimal_len
);
695 for (i
= 0; i
< decimal_len
; i
++)
700 /* Ok, we have an unknown number of bytes of data to be printed in
703 * Given a hex number (in nibbles) as XYZ, we start by taking X and
704 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
705 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
707 * The trick is that "digits" holds a base-10 number, but sometimes
708 * the individual digits are > 10.
710 * Outer loop is per nibble (hex digit) of input, from MSD end to
713 decimal_digits
= 0; /* Number of decimal digits so far */
719 * Multiply current base-ten number by 16 in place.
720 * Each digit was between 0 and 9, now is between
723 for (j
= 0; j
< decimal_digits
; j
++)
725 digits
[j
] = SHIFT (digits
[j
]);
728 /* Take the next nibble off the input and add it to what
729 * we've got in the LSB position. Bottom 'digit' is now
732 * "flip" is used to run this loop twice for each byte.
738 digits
[0] += HIGH_NIBBLE (*p
);
743 /* Take low nibble and bump our pointer "p".
745 digits
[0] += LOW_NIBBLE (*p
);
750 /* Re-decimalize. We have to do this often enough
751 * that we don't overflow, but once per nibble is
752 * overkill. Easier this way, though. Note that the
753 * carry is often larger than 10 (e.g. max initial
754 * carry out of lowest nibble is 15, could bubble all
755 * the way up greater than 10). So we have to do
756 * the carrying beyond the last current digit.
759 for (j
= 0; j
< decimal_len
- 1; j
++)
763 /* "/" won't handle an unsigned char with
764 * a value that if signed would be negative.
765 * So extend to longword int via "dummy".
768 carry
= CARRY_OUT (dummy
);
769 digits
[j
] = CARRY_LEFT (dummy
);
771 if (j
>= decimal_digits
&& carry
== 0)
774 * All higher digits are 0 and we
775 * no longer have a carry.
777 * Note: "j" is 0-based, "decimal_digits" is
780 decimal_digits
= j
+ 1;
786 /* Ok, now "digits" is the decimal representation, with
787 * the "decimal_digits" actual digits. Print!
789 for (i
= decimal_digits
- 1; i
>= 0; i
--)
791 fprintf_filtered (stream
, "%1d", digits
[i
]);
796 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
799 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
804 /* FIXME: We should be not printing leading zeroes in most cases. */
806 fputs_filtered ("0x", stream
);
807 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
813 fprintf_filtered (stream
, "%02x", *p
);
818 for (p
= valaddr
+ len
- 1;
822 fprintf_filtered (stream
, "%02x", *p
);
827 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
828 Omit any leading zero chars. */
831 print_char_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
836 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
839 while (p
< valaddr
+ len
- 1 && *p
== 0)
842 while (p
< valaddr
+ len
)
844 LA_EMIT_CHAR (*p
, stream
, '\'');
850 p
= valaddr
+ len
- 1;
851 while (p
> valaddr
&& *p
== 0)
856 LA_EMIT_CHAR (*p
, stream
, '\'');
862 /* Called by various <lang>_val_print routines to print elements of an
863 array in the form "<elem1>, <elem2>, <elem3>, ...".
865 (FIXME?) Assumes array element separator is a comma, which is correct
866 for all languages currently handled.
867 (FIXME?) Some languages have a notation for repeated array elements,
868 perhaps we should try to use that notation when appropriate.
872 val_print_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
873 CORE_ADDR address
, struct ui_file
*stream
,
874 int format
, int deref_ref
,
875 int recurse
, enum val_prettyprint pretty
,
878 unsigned int things_printed
= 0;
880 struct type
*elttype
;
882 /* Position of the array element we are examining to see
883 whether it is repeated. */
885 /* Number of repetitions we have detected so far. */
888 elttype
= TYPE_TARGET_TYPE (type
);
889 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
890 len
= TYPE_LENGTH (type
) / eltlen
;
892 annotate_array_section_begin (i
, elttype
);
894 for (; i
< len
&& things_printed
< print_max
; i
++)
898 if (prettyprint_arrays
)
900 fprintf_filtered (stream
, ",\n");
901 print_spaces_filtered (2 + 2 * recurse
, stream
);
905 fprintf_filtered (stream
, ", ");
908 wrap_here (n_spaces (2 + 2 * recurse
));
912 while ((rep1
< len
) &&
913 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
919 if (reps
> repeat_count_threshold
)
921 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
922 deref_ref
, recurse
+ 1, pretty
);
923 annotate_elt_rep (reps
);
924 fprintf_filtered (stream
, " <repeats %u times>", reps
);
925 annotate_elt_rep_end ();
928 things_printed
+= repeat_count_threshold
;
932 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
933 deref_ref
, recurse
+ 1, pretty
);
938 annotate_array_section_end ();
941 fprintf_filtered (stream
, "...");
945 /* Read LEN bytes of target memory at address MEMADDR, placing the
946 results in GDB's memory at MYADDR. Returns a count of the bytes
947 actually read, and optionally an errno value in the location
948 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
950 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
951 function be eliminated. */
954 partial_memory_read (CORE_ADDR memaddr
, char *myaddr
, int len
, int *errnoptr
)
956 int nread
; /* Number of bytes actually read. */
957 int errcode
; /* Error from last read. */
959 /* First try a complete read. */
960 errcode
= target_read_memory (memaddr
, myaddr
, len
);
968 /* Loop, reading one byte at a time until we get as much as we can. */
969 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
971 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
973 /* If an error, the last read was unsuccessful, so adjust count. */
979 if (errnoptr
!= NULL
)
986 /* Print a string from the inferior, starting at ADDR and printing up to LEN
987 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
988 stops at the first null byte, otherwise printing proceeds (including null
989 bytes) until either print_max or LEN characters have been printed,
990 whichever is smaller. */
992 /* FIXME: Use target_read_string. */
995 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
997 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
998 int errcode
; /* Errno returned from bad reads. */
999 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1000 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1001 unsigned int chunksize
; /* Size of each fetch, in chars. */
1002 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
1003 char *bufptr
; /* Pointer to next available byte in buffer. */
1004 char *limit
; /* First location past end of fetch buffer. */
1005 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1006 int found_nul
; /* Non-zero if we found the nul char */
1008 /* First we need to figure out the limit on the number of characters we are
1009 going to attempt to fetch and print. This is actually pretty simple. If
1010 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1011 LEN is -1, then the limit is print_max. This is true regardless of
1012 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1013 because finding the null byte (or available memory) is what actually
1014 limits the fetch. */
1016 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1018 /* Now decide how large of chunks to try to read in one operation. This
1019 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1020 so we might as well read them all in one operation. If LEN is -1, we
1021 are looking for a null terminator to end the fetching, so we might as
1022 well read in blocks that are large enough to be efficient, but not so
1023 large as to be slow if fetchlimit happens to be large. So we choose the
1024 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1025 200 is way too big for remote debugging over a serial line. */
1027 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1029 /* Loop until we either have all the characters to print, or we encounter
1030 some error, such as bumping into the end of the address space. */
1033 old_chain
= make_cleanup (null_cleanup
, 0);
1037 buffer
= (char *) xmalloc (len
* width
);
1039 old_chain
= make_cleanup (xfree
, buffer
);
1041 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1043 addr
+= nfetch
* width
;
1044 bufptr
+= nfetch
* width
;
1048 unsigned long bufsize
= 0;
1052 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1055 buffer
= (char *) xmalloc (nfetch
* width
);
1058 discard_cleanups (old_chain
);
1059 buffer
= (char *) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1062 old_chain
= make_cleanup (xfree
, buffer
);
1063 bufptr
= buffer
+ bufsize
* width
;
1066 /* Read as much as we can. */
1067 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1070 /* Scan this chunk for the null byte that terminates the string
1071 to print. If found, we don't need to fetch any more. Note
1072 that bufptr is explicitly left pointing at the next character
1073 after the null byte, or at the next character after the end of
1076 limit
= bufptr
+ nfetch
* width
;
1077 while (bufptr
< limit
)
1081 c
= extract_unsigned_integer (bufptr
, width
);
1086 /* We don't care about any error which happened after
1087 the NULL terminator. */
1094 while (errcode
== 0 /* no error */
1095 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1096 && !found_nul
); /* haven't found nul yet */
1099 { /* length of string is really 0! */
1100 buffer
= bufptr
= NULL
;
1104 /* bufptr and addr now point immediately beyond the last byte which we
1105 consider part of the string (including a '\0' which ends the string). */
1107 /* We now have either successfully filled the buffer to fetchlimit, or
1108 terminated early due to an error or finding a null char when LEN is -1. */
1110 if (len
== -1 && !found_nul
)
1114 /* We didn't find a null terminator we were looking for. Attempt
1115 to peek at the next character. If not successful, or it is not
1116 a null byte, then force ellipsis to be printed. */
1118 peekbuf
= (char *) alloca (width
);
1120 if (target_read_memory (addr
, peekbuf
, width
) == 0
1121 && extract_unsigned_integer (peekbuf
, width
) != 0)
1124 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1126 /* Getting an error when we have a requested length, or fetching less
1127 than the number of characters actually requested, always make us
1134 /* If we get an error before fetching anything, don't print a string.
1135 But if we fetch something and then get an error, print the string
1136 and then the error message. */
1137 if (errcode
== 0 || bufptr
> buffer
)
1141 fputs_filtered (" ", stream
);
1143 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1150 fprintf_filtered (stream
, " <Address ");
1151 deprecated_print_address_numeric (addr
, 1, stream
);
1152 fprintf_filtered (stream
, " out of bounds>");
1156 fprintf_filtered (stream
, " <Error reading address ");
1157 deprecated_print_address_numeric (addr
, 1, stream
);
1158 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1162 do_cleanups (old_chain
);
1163 return ((bufptr
- buffer
) / width
);
1167 /* Validate an input or output radix setting, and make sure the user
1168 knows what they really did here. Radix setting is confusing, e.g.
1169 setting the input radix to "10" never changes it! */
1172 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1174 set_input_radix_1 (from_tty
, input_radix
);
1178 set_input_radix_1 (int from_tty
, unsigned radix
)
1180 /* We don't currently disallow any input radix except 0 or 1, which don't
1181 make any mathematical sense. In theory, we can deal with any input
1182 radix greater than 1, even if we don't have unique digits for every
1183 value from 0 to radix-1, but in practice we lose on large radix values.
1184 We should either fix the lossage or restrict the radix range more.
1189 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1191 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1194 input_radix
= radix
;
1197 printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1198 radix
, radix
, radix
);
1203 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1205 set_output_radix_1 (from_tty
, output_radix
);
1209 set_output_radix_1 (int from_tty
, unsigned radix
)
1211 /* Validate the radix and disallow ones that we aren't prepared to
1212 handle correctly, leaving the radix unchanged. */
1216 output_format
= 'x'; /* hex */
1219 output_format
= 0; /* decimal */
1222 output_format
= 'o'; /* octal */
1225 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1227 error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1230 output_radix
= radix
;
1233 printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1234 radix
, radix
, radix
);
1238 /* Set both the input and output radix at once. Try to set the output radix
1239 first, since it has the most restrictive range. An radix that is valid as
1240 an output radix is also valid as an input radix.
1242 It may be useful to have an unusual input radix. If the user wishes to
1243 set an input radix that is not valid as an output radix, he needs to use
1244 the 'set input-radix' command. */
1247 set_radix (char *arg
, int from_tty
)
1251 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1252 set_output_radix_1 (0, radix
);
1253 set_input_radix_1 (0, radix
);
1256 printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1257 radix
, radix
, radix
);
1261 /* Show both the input and output radices. */
1264 show_radix (char *arg
, int from_tty
)
1268 if (input_radix
== output_radix
)
1270 printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1271 input_radix
, input_radix
, input_radix
);
1275 printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1276 input_radix
, input_radix
, input_radix
);
1277 printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1278 output_radix
, output_radix
, output_radix
);
1285 set_print (char *arg
, int from_tty
)
1288 "\"set print\" must be followed by the name of a print subcommand.\n");
1289 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1293 show_print (char *args
, int from_tty
)
1295 cmd_show_list (showprintlist
, from_tty
, "");
1299 _initialize_valprint (void)
1301 struct cmd_list_element
*c
;
1303 add_prefix_cmd ("print", no_class
, set_print
,
1304 _("Generic command for setting how things print."),
1305 &setprintlist
, "set print ", 0, &setlist
);
1306 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1307 /* prefer set print to set prompt */
1308 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1310 add_prefix_cmd ("print", no_class
, show_print
,
1311 _("Generic command for showing print settings."),
1312 &showprintlist
, "show print ", 0, &showlist
);
1313 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1314 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1316 add_setshow_uinteger_cmd ("elements", no_class
, &print_max
, _("\
1317 Set limit on string chars or array elements to print."), _("\
1318 Show limit on string chars or array elements to print."), _("\
1319 \"set print elements 0\" causes there to be no limit."),
1322 &setprintlist
, &showprintlist
);
1324 add_setshow_boolean_cmd ("null-stop", no_class
, &stop_print_at_null
, _("\
1325 Set printing of char arrays to stop at first null char."), _("\
1326 Show printing of char arrays to stop at first null char."), NULL
,
1328 show_stop_print_at_null
,
1329 &setprintlist
, &showprintlist
);
1331 add_setshow_uinteger_cmd ("repeats", no_class
,
1332 &repeat_count_threshold
, _("\
1333 Set threshold for repeated print elements."), _("\
1334 Show threshold for repeated print elements."), _("\
1335 \"set print repeats 0\" causes all elements to be individually printed."),
1337 show_repeat_count_threshold
,
1338 &setprintlist
, &showprintlist
);
1340 add_setshow_boolean_cmd ("pretty", class_support
, &prettyprint_structs
, _("\
1341 Set prettyprinting of structures."), _("\
1342 Show prettyprinting of structures."), NULL
,
1344 show_prettyprint_structs
,
1345 &setprintlist
, &showprintlist
);
1347 add_setshow_boolean_cmd ("union", class_support
, &unionprint
, _("\
1348 Set printing of unions interior to structures."), _("\
1349 Show printing of unions interior to structures."), NULL
,
1352 &setprintlist
, &showprintlist
);
1354 add_setshow_boolean_cmd ("array", class_support
, &prettyprint_arrays
, _("\
1355 Set prettyprinting of arrays."), _("\
1356 Show prettyprinting of arrays."), NULL
,
1358 show_prettyprint_arrays
,
1359 &setprintlist
, &showprintlist
);
1361 add_setshow_boolean_cmd ("address", class_support
, &addressprint
, _("\
1362 Set printing of addresses."), _("\
1363 Show printing of addresses."), NULL
,
1366 &setprintlist
, &showprintlist
);
1368 add_setshow_uinteger_cmd ("input-radix", class_support
, &input_radix
, _("\
1369 Set default input radix for entering numbers."), _("\
1370 Show default input radix for entering numbers."), NULL
,
1373 &setlist
, &showlist
);
1375 add_setshow_uinteger_cmd ("output-radix", class_support
, &output_radix
, _("\
1376 Set default output radix for printing of values."), _("\
1377 Show default output radix for printing of values."), NULL
,
1380 &setlist
, &showlist
);
1382 /* The "set radix" and "show radix" commands are special in that
1383 they are like normal set and show commands but allow two normally
1384 independent variables to be either set or shown with a single
1385 command. So the usual deprecated_add_set_cmd() and [deleted]
1386 add_show_from_set() commands aren't really appropriate. */
1387 /* FIXME: i18n: With the new add_setshow_integer command, that is no
1388 longer true - show can display anything. */
1389 add_cmd ("radix", class_support
, set_radix
, _("\
1390 Set default input and output number radices.\n\
1391 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1392 Without an argument, sets both radices back to the default value of 10."),
1394 add_cmd ("radix", class_support
, show_radix
, _("\
1395 Show the default input and output number radices.\n\
1396 Use 'show input-radix' or 'show output-radix' to independently show each."),
1399 /* Give people the defaults which they are used to. */
1400 prettyprint_structs
= 0;
1401 prettyprint_arrays
= 0;
1404 print_max
= PRINT_MAX_DEFAULT
;