1 /* Print values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
35 #include "floatformat.h"
40 /* Prototypes for local functions */
42 static int partial_memory_read (CORE_ADDR memaddr
, char *myaddr
,
43 int len
, int *errnoptr
);
45 static void show_print (char *, int);
47 static void set_print (char *, int);
49 static void set_radix (char *, int);
51 static void show_radix (char *, int);
53 static void set_input_radix (char *, int, struct cmd_list_element
*);
55 static void set_input_radix_1 (int, unsigned);
57 static void set_output_radix (char *, int, struct cmd_list_element
*);
59 static void set_output_radix_1 (int, unsigned);
61 void _initialize_valprint (void);
63 /* Maximum number of chars to print for a string pointer value or vector
64 contents, or UINT_MAX for no limit. Note that "set print elements 0"
65 stores UINT_MAX in print_max, which displays in a show command as
68 unsigned int print_max
;
69 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
71 /* Default input and output radixes, and output format letter. */
73 unsigned input_radix
= 10;
74 unsigned output_radix
= 10;
75 int output_format
= 0;
77 /* Print repeat counts if there are more than this many repetitions of an
78 element in an array. Referenced by the low level language dependent
81 unsigned int repeat_count_threshold
= 10;
83 /* If nonzero, stops printing of char arrays at first null. */
85 int stop_print_at_null
;
87 /* Controls pretty printing of structures. */
89 int prettyprint_structs
;
91 /* Controls pretty printing of arrays. */
93 int prettyprint_arrays
;
95 /* If nonzero, causes unions inside structures or other unions to be
98 int unionprint
; /* Controls printing of nested unions. */
100 /* If nonzero, causes machine addresses to be printed in certain contexts. */
102 int addressprint
; /* Controls printing of machine addresses */
105 /* Print data of type TYPE located at VALADDR (within GDB), which came from
106 the inferior at address ADDRESS, onto stdio stream STREAM according to
107 FORMAT (a letter, or 0 for natural format using TYPE).
109 If DEREF_REF is nonzero, then dereference references, otherwise just print
112 The PRETTY parameter controls prettyprinting.
114 If the data are a string pointer, returns the number of string characters
117 FIXME: The data at VALADDR is in target byte order. If gdb is ever
118 enhanced to be able to debug more than the single target it was compiled
119 for (specific CPU type and thus specific target byte ordering), then
120 either the print routines are going to have to take this into account,
121 or the data is going to have to be passed into here already converted
122 to the host byte ordering, whichever is more convenient. */
126 val_print (struct type
*type
, char *valaddr
, int embedded_offset
,
127 CORE_ADDR address
, struct ui_file
*stream
, int format
, int deref_ref
,
128 int recurse
, enum val_prettyprint pretty
)
130 struct type
*real_type
= check_typedef (type
);
131 if (pretty
== Val_pretty_default
)
133 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
138 /* Ensure that the type is complete and not just a stub. If the type is
139 only a stub and we can't find and substitute its complete type, then
140 print appropriate string and return. */
142 if (TYPE_STUB (real_type
))
144 fprintf_filtered (stream
, "<incomplete type>");
149 return (LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
150 stream
, format
, deref_ref
, recurse
, pretty
));
153 /* Print the value VAL in C-ish syntax on stream STREAM.
154 FORMAT is a format-letter, or 0 for print in natural format of data type.
155 If the object printed is a string pointer, returns
156 the number of string bytes printed. */
159 value_print (struct value
*val
, struct ui_file
*stream
, int format
,
160 enum val_prettyprint pretty
)
164 printf_filtered ("<address of value unknown>");
167 if (VALUE_OPTIMIZED_OUT (val
))
169 printf_filtered ("<value optimized out>");
172 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
175 /* Called by various <lang>_val_print routines to print
176 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
177 value. STREAM is where to print the value. */
180 val_print_type_code_int (struct type
*type
, char *valaddr
,
181 struct ui_file
*stream
)
183 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
187 if (TYPE_UNSIGNED (type
)
188 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
191 print_longest (stream
, 'u', 0, val
);
195 /* Signed, or we couldn't turn an unsigned value into a
196 LONGEST. For signed values, one could assume two's
197 complement (a reasonable assumption, I think) and do
199 print_hex_chars (stream
, (unsigned char *) valaddr
,
205 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
206 unpack_long (type
, valaddr
));
210 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
211 The raison d'etre of this function is to consolidate printing of
212 LONG_LONG's into this one function. Some platforms have long longs but
213 don't have a printf() that supports "ll" in the format string. We handle
214 these by seeing if the number is representable as either a signed or
215 unsigned long, depending upon what format is desired, and if not we just
216 bail out and print the number in hex.
218 The format chars b,h,w,g are from print_scalar_formatted(). If USE_LOCAL,
219 format it according to the current language (this should be used for most
220 integers which GDB prints, the exception is things like protocols where
221 the format of the integer is a protocol thing, not a user-visible thing).
224 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
225 static void print_decimal (struct ui_file
* stream
, char *sign
,
226 int use_local
, ULONGEST val_ulong
);
228 print_decimal (struct ui_file
*stream
, char *sign
, int use_local
,
231 unsigned long temp
[3];
235 temp
[i
] = val_ulong
% (1000 * 1000 * 1000);
236 val_ulong
/= (1000 * 1000 * 1000);
239 while (val_ulong
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
243 fprintf_filtered (stream
, "%s%lu",
247 fprintf_filtered (stream
, "%s%lu%09lu",
248 sign
, temp
[1], temp
[0]);
251 fprintf_filtered (stream
, "%s%lu%09lu%09lu",
252 sign
, temp
[2], temp
[1], temp
[0]);
255 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
262 print_longest (struct ui_file
*stream
, int format
, int use_local
,
265 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
266 if (sizeof (long) < sizeof (LONGEST
))
272 /* Print a signed value, that doesn't fit in a long */
273 if ((long) val_long
!= val_long
)
276 print_decimal (stream
, "-", use_local
, -val_long
);
278 print_decimal (stream
, "", use_local
, val_long
);
285 /* Print an unsigned value, that doesn't fit in a long */
286 if ((unsigned long) val_long
!= (ULONGEST
) val_long
)
288 print_decimal (stream
, "", use_local
, val_long
);
299 /* Print as unsigned value, must fit completely in unsigned long */
301 unsigned long temp
= val_long
;
302 if (temp
!= val_long
)
304 /* Urk, can't represent value in long so print in hex.
305 Do shift in two operations so that if sizeof (long)
306 == sizeof (LONGEST) we can avoid warnings from
307 picky compilers about shifts >= the size of the
309 unsigned long vbot
= (unsigned long) val_long
;
310 LONGEST temp
= (val_long
>> (sizeof (long) * HOST_CHAR_BIT
- 1));
311 unsigned long vtop
= temp
>> 1;
312 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
321 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
325 fprintf_filtered (stream
,
326 use_local
? local_decimal_format_custom ("ll")
328 (long long) val_long
);
331 fprintf_filtered (stream
, "%llu", (long long) val_long
);
334 fprintf_filtered (stream
,
335 use_local
? local_hex_format_custom ("ll")
337 (unsigned long long) val_long
);
340 fprintf_filtered (stream
,
341 use_local
? local_octal_format_custom ("ll")
343 (unsigned long long) val_long
);
346 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
349 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
352 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
355 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
358 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
360 #else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
361 /* In the following it is important to coerce (val_long) to a long. It does
362 nothing if !LONG_LONG, but it will chop off the top half (which we know
363 we can ignore) if the host supports long longs. */
368 fprintf_filtered (stream
,
369 use_local
? local_decimal_format_custom ("l")
374 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
377 fprintf_filtered (stream
,
378 use_local
? local_hex_format_custom ("l")
380 (unsigned long) val_long
);
383 fprintf_filtered (stream
,
384 use_local
? local_octal_format_custom ("l")
386 (unsigned long) val_long
);
389 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
390 (unsigned long) val_long
);
393 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
394 (unsigned long) val_long
);
397 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
398 (unsigned long) val_long
);
401 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
402 (unsigned long) val_long
);
405 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
407 #endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
410 /* This used to be a macro, but I don't think it is called often enough
411 to merit such treatment. */
412 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
413 arguments to a function, number in a value history, register number, etc.)
414 where the value must not be larger than can fit in an int. */
417 longest_to_int (LONGEST arg
)
419 /* Let the compiler do the work */
420 int rtnval
= (int) arg
;
422 /* Check for overflows or underflows */
423 if (sizeof (LONGEST
) > sizeof (int))
427 error ("Value out of range.");
433 /* Print a floating point value of type TYPE (not always a
434 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
437 print_floating (char *valaddr
, struct type
*type
, struct ui_file
*stream
)
441 const struct floatformat
*fmt
= NULL
;
442 unsigned len
= TYPE_LENGTH (type
);
444 /* If it is a floating-point, check for obvious problems. */
445 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
446 fmt
= floatformat_from_type (type
);
447 if (fmt
!= NULL
&& floatformat_is_nan (fmt
, valaddr
))
449 if (floatformat_is_negative (fmt
, valaddr
))
450 fprintf_filtered (stream
, "-");
451 fprintf_filtered (stream
, "nan(");
452 fputs_filtered (local_hex_format_prefix (), stream
);
453 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
454 fputs_filtered (local_hex_format_suffix (), stream
);
455 fprintf_filtered (stream
, ")");
459 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
460 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
461 needs to be used as that takes care of any necessary type
462 conversions. Such conversions are of course direct to DOUBLEST
463 and disregard any possible target floating point limitations.
464 For instance, a u64 would be converted and displayed exactly on a
465 host with 80 bit DOUBLEST but with loss of information on a host
466 with 64 bit DOUBLEST. */
468 doub
= unpack_double (type
, valaddr
, &inv
);
471 fprintf_filtered (stream
, "<invalid float value>");
475 /* FIXME: kettenis/2001-01-20: The following code makes too much
476 assumptions about the host and target floating point format. */
478 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
479 not necessarially be a TYPE_CODE_FLT, the below ignores that and
480 instead uses the type's length to determine the precision of the
481 floating-point value being printed. */
483 if (len
< sizeof (double))
484 fprintf_filtered (stream
, "%.9g", (double) doub
);
485 else if (len
== sizeof (double))
486 fprintf_filtered (stream
, "%.17g", (double) doub
);
488 #ifdef PRINTF_HAS_LONG_DOUBLE
489 fprintf_filtered (stream
, "%.35Lg", doub
);
491 /* This at least wins with values that are representable as
493 fprintf_filtered (stream
, "%.17g", (double) doub
);
498 print_binary_chars (struct ui_file
*stream
, unsigned char *valaddr
,
502 #define BITS_IN_BYTES 8
508 /* Declared "int" so it will be signed.
509 * This ensures that right shift will shift in zeros.
511 const int mask
= 0x080;
513 /* FIXME: We should be not printing leading zeroes in most cases. */
515 fputs_filtered (local_binary_format_prefix (), stream
);
516 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
522 /* Every byte has 8 binary characters; peel off
523 * and print from the MSB end.
525 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
527 if (*p
& (mask
>> i
))
532 fprintf_filtered (stream
, "%1d", b
);
538 for (p
= valaddr
+ len
- 1;
542 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
544 if (*p
& (mask
>> i
))
549 fprintf_filtered (stream
, "%1d", b
);
553 fputs_filtered (local_binary_format_suffix (), stream
);
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
, unsigned char *valaddr
, unsigned len
)
563 unsigned char octa1
, octa2
, octa3
, carry
;
566 /* FIXME: We should be not printing leading zeroes in most cases. */
569 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
570 * the extra bits, which cycle every three bytes:
574 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
576 * Octal side: 0 1 carry 3 4 carry ...
578 * Cycle number: 0 1 2
580 * But of course we are printing from the high side, so we have to
581 * figure out where in the cycle we are so that we end up with no
582 * left over bits at the end.
584 #define BITS_IN_OCTAL 3
585 #define HIGH_ZERO 0340
586 #define LOW_ZERO 0016
587 #define CARRY_ZERO 0003
588 #define HIGH_ONE 0200
591 #define CARRY_ONE 0001
592 #define HIGH_TWO 0300
596 /* For 32 we start in cycle 2, with two bits and one bit carry;
597 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
599 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
602 fputs_filtered (local_octal_format_prefix (), stream
);
603 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
612 /* No carry in, carry out two bits.
614 octa1
= (HIGH_ZERO
& *p
) >> 5;
615 octa2
= (LOW_ZERO
& *p
) >> 2;
616 carry
= (CARRY_ZERO
& *p
);
617 fprintf_filtered (stream
, "%o", octa1
);
618 fprintf_filtered (stream
, "%o", octa2
);
622 /* Carry in two bits, carry out one bit.
624 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
625 octa2
= (MID_ONE
& *p
) >> 4;
626 octa3
= (LOW_ONE
& *p
) >> 1;
627 carry
= (CARRY_ONE
& *p
);
628 fprintf_filtered (stream
, "%o", octa1
);
629 fprintf_filtered (stream
, "%o", octa2
);
630 fprintf_filtered (stream
, "%o", octa3
);
634 /* Carry in one bit, no carry out.
636 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
637 octa2
= (MID_TWO
& *p
) >> 3;
638 octa3
= (LOW_TWO
& *p
);
640 fprintf_filtered (stream
, "%o", octa1
);
641 fprintf_filtered (stream
, "%o", octa2
);
642 fprintf_filtered (stream
, "%o", octa3
);
646 error ("Internal error in octal conversion;");
650 cycle
= cycle
% BITS_IN_OCTAL
;
655 for (p
= valaddr
+ len
- 1;
662 /* Carry out, no carry in */
663 octa1
= (HIGH_ZERO
& *p
) >> 5;
664 octa2
= (LOW_ZERO
& *p
) >> 2;
665 carry
= (CARRY_ZERO
& *p
);
666 fprintf_filtered (stream
, "%o", octa1
);
667 fprintf_filtered (stream
, "%o", octa2
);
671 /* Carry in, carry out */
672 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
673 octa2
= (MID_ONE
& *p
) >> 4;
674 octa3
= (LOW_ONE
& *p
) >> 1;
675 carry
= (CARRY_ONE
& *p
);
676 fprintf_filtered (stream
, "%o", octa1
);
677 fprintf_filtered (stream
, "%o", octa2
);
678 fprintf_filtered (stream
, "%o", octa3
);
682 /* Carry in, no carry out */
683 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
684 octa2
= (MID_TWO
& *p
) >> 3;
685 octa3
= (LOW_TWO
& *p
);
687 fprintf_filtered (stream
, "%o", octa1
);
688 fprintf_filtered (stream
, "%o", octa2
);
689 fprintf_filtered (stream
, "%o", octa3
);
693 error ("Internal error in octal conversion;");
697 cycle
= cycle
% BITS_IN_OCTAL
;
701 fputs_filtered (local_octal_format_suffix (), stream
);
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
, unsigned char *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 fputs_filtered (local_decimal_format_prefix (), stream
);
746 /* Ok, we have an unknown number of bytes of data to be printed in
749 * Given a hex number (in nibbles) as XYZ, we start by taking X and
750 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
751 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
753 * The trick is that "digits" holds a base-10 number, but sometimes
754 * the individual digits are > 10.
756 * Outer loop is per nibble (hex digit) of input, from MSD end to
759 decimal_digits
= 0; /* Number of decimal digits so far */
765 * Multiply current base-ten number by 16 in place.
766 * Each digit was between 0 and 9, now is between
769 for (j
= 0; j
< decimal_digits
; j
++)
771 digits
[j
] = SHIFT (digits
[j
]);
774 /* Take the next nibble off the input and add it to what
775 * we've got in the LSB position. Bottom 'digit' is now
778 * "flip" is used to run this loop twice for each byte.
784 digits
[0] += HIGH_NIBBLE (*p
);
789 /* Take low nibble and bump our pointer "p".
791 digits
[0] += LOW_NIBBLE (*p
);
796 /* Re-decimalize. We have to do this often enough
797 * that we don't overflow, but once per nibble is
798 * overkill. Easier this way, though. Note that the
799 * carry is often larger than 10 (e.g. max initial
800 * carry out of lowest nibble is 15, could bubble all
801 * the way up greater than 10). So we have to do
802 * the carrying beyond the last current digit.
805 for (j
= 0; j
< decimal_len
- 1; j
++)
809 /* "/" won't handle an unsigned char with
810 * a value that if signed would be negative.
811 * So extend to longword int via "dummy".
814 carry
= CARRY_OUT (dummy
);
815 digits
[j
] = CARRY_LEFT (dummy
);
817 if (j
>= decimal_digits
&& carry
== 0)
820 * All higher digits are 0 and we
821 * no longer have a carry.
823 * Note: "j" is 0-based, "decimal_digits" is
826 decimal_digits
= j
+ 1;
832 /* Ok, now "digits" is the decimal representation, with
833 * the "decimal_digits" actual digits. Print!
835 for (i
= decimal_digits
- 1; i
>= 0; i
--)
837 fprintf_filtered (stream
, "%1d", digits
[i
]);
841 fputs_filtered (local_decimal_format_suffix (), stream
);
844 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
847 print_hex_chars (struct ui_file
*stream
, unsigned char *valaddr
, unsigned len
)
851 /* FIXME: We should be not printing leading zeroes in most cases. */
853 fputs_filtered (local_hex_format_prefix (), stream
);
854 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
860 fprintf_filtered (stream
, "%02x", *p
);
865 for (p
= valaddr
+ len
- 1;
869 fprintf_filtered (stream
, "%02x", *p
);
872 fputs_filtered (local_hex_format_suffix (), stream
);
875 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
876 Omit any leading zero chars. */
879 print_char_chars (struct ui_file
*stream
, unsigned char *valaddr
, unsigned len
)
883 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
886 while (p
< valaddr
+ len
- 1 && *p
== 0)
889 while (p
< valaddr
+ len
)
891 LA_EMIT_CHAR (*p
, stream
, '\'');
897 p
= valaddr
+ len
- 1;
898 while (p
> valaddr
&& *p
== 0)
903 LA_EMIT_CHAR (*p
, stream
, '\'');
909 /* Called by various <lang>_val_print routines to print elements of an
910 array in the form "<elem1>, <elem2>, <elem3>, ...".
912 (FIXME?) Assumes array element separator is a comma, which is correct
913 for all languages currently handled.
914 (FIXME?) Some languages have a notation for repeated array elements,
915 perhaps we should try to use that notation when appropriate.
919 val_print_array_elements (struct type
*type
, char *valaddr
, CORE_ADDR address
,
920 struct ui_file
*stream
, int format
, int deref_ref
,
921 int recurse
, enum val_prettyprint pretty
,
924 unsigned int things_printed
= 0;
926 struct type
*elttype
;
928 /* Position of the array element we are examining to see
929 whether it is repeated. */
931 /* Number of repetitions we have detected so far. */
934 elttype
= TYPE_TARGET_TYPE (type
);
935 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
936 len
= TYPE_LENGTH (type
) / eltlen
;
938 annotate_array_section_begin (i
, elttype
);
940 for (; i
< len
&& things_printed
< print_max
; i
++)
944 if (prettyprint_arrays
)
946 fprintf_filtered (stream
, ",\n");
947 print_spaces_filtered (2 + 2 * recurse
, stream
);
951 fprintf_filtered (stream
, ", ");
954 wrap_here (n_spaces (2 + 2 * recurse
));
958 while ((rep1
< len
) &&
959 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
965 if (reps
> repeat_count_threshold
)
967 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
968 deref_ref
, recurse
+ 1, pretty
);
969 annotate_elt_rep (reps
);
970 fprintf_filtered (stream
, " <repeats %u times>", reps
);
971 annotate_elt_rep_end ();
974 things_printed
+= repeat_count_threshold
;
978 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
979 deref_ref
, recurse
+ 1, pretty
);
984 annotate_array_section_end ();
987 fprintf_filtered (stream
, "...");
991 /* Read LEN bytes of target memory at address MEMADDR, placing the
992 results in GDB's memory at MYADDR. Returns a count of the bytes
993 actually read, and optionally an errno value in the location
994 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
996 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
997 function be eliminated. */
1000 partial_memory_read (CORE_ADDR memaddr
, char *myaddr
, int len
, int *errnoptr
)
1002 int nread
; /* Number of bytes actually read. */
1003 int errcode
; /* Error from last read. */
1005 /* First try a complete read. */
1006 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1014 /* Loop, reading one byte at a time until we get as much as we can. */
1015 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1017 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1019 /* If an error, the last read was unsuccessful, so adjust count. */
1025 if (errnoptr
!= NULL
)
1027 *errnoptr
= errcode
;
1032 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1033 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1034 stops at the first null byte, otherwise printing proceeds (including null
1035 bytes) until either print_max or LEN characters have been printed,
1036 whichever is smaller. */
1038 /* FIXME: Use target_read_string. */
1041 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
1043 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1044 int errcode
; /* Errno returned from bad reads. */
1045 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1046 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1047 unsigned int chunksize
; /* Size of each fetch, in chars. */
1048 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
1049 char *bufptr
; /* Pointer to next available byte in buffer. */
1050 char *limit
; /* First location past end of fetch buffer. */
1051 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1052 int found_nul
; /* Non-zero if we found the nul char */
1054 /* First we need to figure out the limit on the number of characters we are
1055 going to attempt to fetch and print. This is actually pretty simple. If
1056 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1057 LEN is -1, then the limit is print_max. This is true regardless of
1058 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1059 because finding the null byte (or available memory) is what actually
1060 limits the fetch. */
1062 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1064 /* Now decide how large of chunks to try to read in one operation. This
1065 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1066 so we might as well read them all in one operation. If LEN is -1, we
1067 are looking for a null terminator to end the fetching, so we might as
1068 well read in blocks that are large enough to be efficient, but not so
1069 large as to be slow if fetchlimit happens to be large. So we choose the
1070 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1071 200 is way too big for remote debugging over a serial line. */
1073 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1075 /* Loop until we either have all the characters to print, or we encounter
1076 some error, such as bumping into the end of the address space. */
1079 old_chain
= make_cleanup (null_cleanup
, 0);
1083 buffer
= (char *) xmalloc (len
* width
);
1085 old_chain
= make_cleanup (xfree
, buffer
);
1087 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1089 addr
+= nfetch
* width
;
1090 bufptr
+= nfetch
* width
;
1094 unsigned long bufsize
= 0;
1098 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1101 buffer
= (char *) xmalloc (nfetch
* width
);
1104 discard_cleanups (old_chain
);
1105 buffer
= (char *) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1108 old_chain
= make_cleanup (xfree
, buffer
);
1109 bufptr
= buffer
+ bufsize
* width
;
1112 /* Read as much as we can. */
1113 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1116 /* Scan this chunk for the null byte that terminates the string
1117 to print. If found, we don't need to fetch any more. Note
1118 that bufptr is explicitly left pointing at the next character
1119 after the null byte, or at the next character after the end of
1122 limit
= bufptr
+ nfetch
* width
;
1123 while (bufptr
< limit
)
1127 c
= extract_unsigned_integer (bufptr
, width
);
1132 /* We don't care about any error which happened after
1133 the NULL terminator. */
1140 while (errcode
== 0 /* no error */
1141 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1142 && !found_nul
); /* haven't found nul yet */
1145 { /* length of string is really 0! */
1146 buffer
= bufptr
= NULL
;
1150 /* bufptr and addr now point immediately beyond the last byte which we
1151 consider part of the string (including a '\0' which ends the string). */
1153 /* We now have either successfully filled the buffer to fetchlimit, or
1154 terminated early due to an error or finding a null char when LEN is -1. */
1156 if (len
== -1 && !found_nul
)
1160 /* We didn't find a null terminator we were looking for. Attempt
1161 to peek at the next character. If not successful, or it is not
1162 a null byte, then force ellipsis to be printed. */
1164 peekbuf
= (char *) alloca (width
);
1166 if (target_read_memory (addr
, peekbuf
, width
) == 0
1167 && extract_unsigned_integer (peekbuf
, width
) != 0)
1170 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1172 /* Getting an error when we have a requested length, or fetching less
1173 than the number of characters actually requested, always make us
1180 /* If we get an error before fetching anything, don't print a string.
1181 But if we fetch something and then get an error, print the string
1182 and then the error message. */
1183 if (errcode
== 0 || bufptr
> buffer
)
1187 fputs_filtered (" ", stream
);
1189 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1196 fprintf_filtered (stream
, " <Address ");
1197 print_address_numeric (addr
, 1, stream
);
1198 fprintf_filtered (stream
, " out of bounds>");
1202 fprintf_filtered (stream
, " <Error reading address ");
1203 print_address_numeric (addr
, 1, stream
);
1204 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1208 do_cleanups (old_chain
);
1209 return ((bufptr
- buffer
) / width
);
1213 /* Validate an input or output radix setting, and make sure the user
1214 knows what they really did here. Radix setting is confusing, e.g.
1215 setting the input radix to "10" never changes it! */
1218 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1220 set_input_radix_1 (from_tty
, input_radix
);
1224 set_input_radix_1 (int from_tty
, unsigned radix
)
1226 /* We don't currently disallow any input radix except 0 or 1, which don't
1227 make any mathematical sense. In theory, we can deal with any input
1228 radix greater than 1, even if we don't have unique digits for every
1229 value from 0 to radix-1, but in practice we lose on large radix values.
1230 We should either fix the lossage or restrict the radix range more.
1235 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1237 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1240 input_radix
= radix
;
1243 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1244 radix
, radix
, radix
);
1249 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1251 set_output_radix_1 (from_tty
, output_radix
);
1255 set_output_radix_1 (int from_tty
, unsigned radix
)
1257 /* Validate the radix and disallow ones that we aren't prepared to
1258 handle correctly, leaving the radix unchanged. */
1262 output_format
= 'x'; /* hex */
1265 output_format
= 0; /* decimal */
1268 output_format
= 'o'; /* octal */
1271 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1273 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1276 output_radix
= radix
;
1279 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1280 radix
, radix
, radix
);
1284 /* Set both the input and output radix at once. Try to set the output radix
1285 first, since it has the most restrictive range. An radix that is valid as
1286 an output radix is also valid as an input radix.
1288 It may be useful to have an unusual input radix. If the user wishes to
1289 set an input radix that is not valid as an output radix, he needs to use
1290 the 'set input-radix' command. */
1293 set_radix (char *arg
, int from_tty
)
1297 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1298 set_output_radix_1 (0, radix
);
1299 set_input_radix_1 (0, radix
);
1302 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1303 radix
, radix
, radix
);
1307 /* Show both the input and output radices. */
1310 show_radix (char *arg
, int from_tty
)
1314 if (input_radix
== output_radix
)
1316 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1317 input_radix
, input_radix
, input_radix
);
1321 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1322 input_radix
, input_radix
, input_radix
);
1323 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1324 output_radix
, output_radix
, output_radix
);
1331 set_print (char *arg
, int from_tty
)
1334 "\"set print\" must be followed by the name of a print subcommand.\n");
1335 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1339 show_print (char *args
, int from_tty
)
1341 cmd_show_list (showprintlist
, from_tty
, "");
1345 _initialize_valprint (void)
1347 struct cmd_list_element
*c
;
1349 add_prefix_cmd ("print", no_class
, set_print
,
1350 "Generic command for setting how things print.",
1351 &setprintlist
, "set print ", 0, &setlist
);
1352 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1353 /* prefer set print to set prompt */
1354 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1356 add_prefix_cmd ("print", no_class
, show_print
,
1357 "Generic command for showing print settings.",
1358 &showprintlist
, "show print ", 0, &showlist
);
1359 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1360 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1363 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *) &print_max
,
1364 "Set limit on string chars or array elements to print.\n\
1365 \"set print elements 0\" causes there to be no limit.",
1370 (add_set_cmd ("null-stop", no_class
, var_boolean
,
1371 (char *) &stop_print_at_null
,
1372 "Set printing of char arrays to stop at first null char.",
1377 (add_set_cmd ("repeats", no_class
, var_uinteger
,
1378 (char *) &repeat_count_threshold
,
1379 "Set threshold for repeated print elements.\n\
1380 \"set print repeats 0\" causes all elements to be individually printed.",
1385 (add_set_cmd ("pretty", class_support
, var_boolean
,
1386 (char *) &prettyprint_structs
,
1387 "Set prettyprinting of structures.",
1392 (add_set_cmd ("union", class_support
, var_boolean
, (char *) &unionprint
,
1393 "Set printing of unions interior to structures.",
1398 (add_set_cmd ("array", class_support
, var_boolean
,
1399 (char *) &prettyprint_arrays
,
1400 "Set prettyprinting of arrays.",
1405 (add_set_cmd ("address", class_support
, var_boolean
, (char *) &addressprint
,
1406 "Set printing of addresses.",
1410 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1411 (char *) &input_radix
,
1412 "Set default input radix for entering numbers.",
1414 add_show_from_set (c
, &showlist
);
1415 set_cmd_sfunc (c
, set_input_radix
);
1417 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1418 (char *) &output_radix
,
1419 "Set default output radix for printing of values.",
1421 add_show_from_set (c
, &showlist
);
1422 set_cmd_sfunc (c
, set_output_radix
);
1424 /* The "set radix" and "show radix" commands are special in that they are
1425 like normal set and show commands but allow two normally independent
1426 variables to be either set or shown with a single command. So the
1427 usual add_set_cmd() and add_show_from_set() commands aren't really
1429 add_cmd ("radix", class_support
, set_radix
,
1430 "Set default input and output number radices.\n\
1431 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1432 Without an argument, sets both radices back to the default value of 10.",
1434 add_cmd ("radix", class_support
, show_radix
,
1435 "Show the default input and output number radices.\n\
1436 Use 'show input-radix' or 'show output-radix' to independently show each.",
1439 /* Give people the defaults which they are used to. */
1440 prettyprint_structs
= 0;
1441 prettyprint_arrays
= 0;
1444 print_max
= PRINT_MAX_DEFAULT
;
This page took 0.058976 seconds and 4 git commands to generate.