1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991-1994, 1998, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
38 /* Prototypes for local functions */
40 static int partial_memory_read (CORE_ADDR memaddr
, char *myaddr
,
41 int len
, int *errnoptr
);
43 static void print_hex_chars (struct ui_file
*, unsigned char *,
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 /* Default input and output radixes, and output format letter. */
74 unsigned input_radix
= 10;
75 unsigned output_radix
= 10;
76 int output_format
= 0;
78 /* Print repeat counts if there are more than this many repetitions of an
79 element in an array. Referenced by the low level language dependent
82 unsigned int repeat_count_threshold
= 10;
84 /* If nonzero, stops printing of char arrays at first null. */
86 int stop_print_at_null
;
88 /* Controls pretty printing of structures. */
90 int prettyprint_structs
;
92 /* Controls pretty printing of arrays. */
94 int prettyprint_arrays
;
96 /* If nonzero, causes unions inside structures or other unions to be
99 int unionprint
; /* Controls printing of nested unions. */
101 /* If nonzero, causes machine addresses to be printed in certain contexts. */
103 int addressprint
; /* Controls printing of machine addresses */
106 /* Print data of type TYPE located at VALADDR (within GDB), which came from
107 the inferior at address ADDRESS, onto stdio stream STREAM according to
108 FORMAT (a letter, or 0 for natural format using TYPE).
110 If DEREF_REF is nonzero, then dereference references, otherwise just print
113 The PRETTY parameter controls prettyprinting.
115 If the data are a string pointer, returns the number of string characters
118 FIXME: The data at VALADDR is in target byte order. If gdb is ever
119 enhanced to be able to debug more than the single target it was compiled
120 for (specific CPU type and thus specific target byte ordering), then
121 either the print routines are going to have to take this into account,
122 or the data is going to have to be passed into here already converted
123 to the host byte ordering, whichever is more convenient. */
127 val_print (struct type
*type
, char *valaddr
, int embedded_offset
,
128 CORE_ADDR address
, struct ui_file
*stream
, int format
, int deref_ref
,
129 int recurse
, enum val_prettyprint pretty
)
131 struct type
*real_type
= check_typedef (type
);
132 if (pretty
== Val_pretty_default
)
134 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
139 /* Ensure that the type is complete and not just a stub. If the type is
140 only a stub and we can't find and substitute its complete type, then
141 print appropriate string and return. */
143 if (TYPE_FLAGS (real_type
) & TYPE_FLAG_STUB
)
145 fprintf_filtered (stream
, "<incomplete type>");
150 return (LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
151 stream
, format
, deref_ref
, recurse
, pretty
));
154 /* Print the value VAL in C-ish syntax on stream STREAM.
155 FORMAT is a format-letter, or 0 for print in natural format of data type.
156 If the object printed is a string pointer, returns
157 the number of string bytes printed. */
160 value_print (value_ptr val
, struct ui_file
*stream
, int format
,
161 enum val_prettyprint pretty
)
165 printf_filtered ("<address of value unknown>");
168 if (VALUE_OPTIMIZED_OUT (val
))
170 printf_filtered ("<value optimized out>");
173 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
176 /* Called by various <lang>_val_print routines to print
177 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
178 value. STREAM is where to print the value. */
181 val_print_type_code_int (struct type
*type
, char *valaddr
,
182 struct ui_file
*stream
)
184 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
188 if (TYPE_UNSIGNED (type
)
189 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
192 print_longest (stream
, 'u', 0, val
);
196 /* Signed, or we couldn't turn an unsigned value into a
197 LONGEST. For signed values, one could assume two's
198 complement (a reasonable assumption, I think) and do
200 print_hex_chars (stream
, (unsigned char *) valaddr
,
206 #ifdef PRINT_TYPELESS_INTEGER
207 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
209 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
210 unpack_long (type
, valaddr
));
215 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
216 The raison d'etre of this function is to consolidate printing of
217 LONG_LONG's into this one function. Some platforms have long longs but
218 don't have a printf() that supports "ll" in the format string. We handle
219 these by seeing if the number is representable as either a signed or
220 unsigned long, depending upon what format is desired, and if not we just
221 bail out and print the number in hex.
223 The format chars b,h,w,g are from print_scalar_formatted(). If USE_LOCAL,
224 format it according to the current language (this should be used for most
225 integers which GDB prints, the exception is things like protocols where
226 the format of the integer is a protocol thing, not a user-visible thing).
229 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
230 static void print_decimal (struct ui_file
* stream
, char *sign
,
231 int use_local
, ULONGEST val_ulong
);
233 print_decimal (struct ui_file
*stream
, char *sign
, int use_local
,
236 unsigned long temp
[3];
240 temp
[i
] = val_ulong
% (1000 * 1000 * 1000);
241 val_ulong
/= (1000 * 1000 * 1000);
244 while (val_ulong
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
248 fprintf_filtered (stream
, "%s%lu",
252 fprintf_filtered (stream
, "%s%lu%09lu",
253 sign
, temp
[1], temp
[0]);
256 fprintf_filtered (stream
, "%s%lu%09lu%09lu",
257 sign
, temp
[2], temp
[1], temp
[0]);
267 print_longest (struct ui_file
*stream
, int format
, int use_local
,
270 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
271 if (sizeof (long) < sizeof (LONGEST
))
277 /* Print a signed value, that doesn't fit in a long */
278 if ((long) val_long
!= val_long
)
281 print_decimal (stream
, "-", use_local
, -val_long
);
283 print_decimal (stream
, "", use_local
, val_long
);
290 /* Print an unsigned value, that doesn't fit in a long */
291 if ((unsigned long) val_long
!= (ULONGEST
) val_long
)
293 print_decimal (stream
, "", use_local
, val_long
);
304 /* Print as unsigned value, must fit completely in unsigned long */
306 unsigned long temp
= val_long
;
307 if (temp
!= val_long
)
309 /* Urk, can't represent value in long so print in hex.
310 Do shift in two operations so that if sizeof (long)
311 == sizeof (LONGEST) we can avoid warnings from
312 picky compilers about shifts >= the size of the
314 unsigned long vbot
= (unsigned long) val_long
;
315 LONGEST temp
= (val_long
>> (sizeof (long) * HOST_CHAR_BIT
- 1));
316 unsigned long vtop
= temp
>> 1;
317 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
326 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
330 fprintf_filtered (stream
,
331 use_local
? local_decimal_format_custom ("ll")
336 fprintf_filtered (stream
, "%llu", val_long
);
339 fprintf_filtered (stream
,
340 use_local
? local_hex_format_custom ("ll")
345 fprintf_filtered (stream
,
346 use_local
? local_octal_format_custom ("ll")
351 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
354 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
357 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
360 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
365 #else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
366 /* In the following it is important to coerce (val_long) to a long. It does
367 nothing if !LONG_LONG, but it will chop off the top half (which we know
368 we can ignore) if the host supports long longs. */
373 fprintf_filtered (stream
,
374 use_local
? local_decimal_format_custom ("l")
379 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
382 fprintf_filtered (stream
,
383 use_local
? local_hex_format_custom ("l")
385 (unsigned long) val_long
);
388 fprintf_filtered (stream
,
389 use_local
? local_octal_format_custom ("l")
391 (unsigned long) val_long
);
394 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
395 (unsigned long) val_long
);
398 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
399 (unsigned long) val_long
);
402 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
403 (unsigned long) val_long
);
406 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
407 (unsigned long) val_long
);
412 #endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
417 strcat_longest (int format
, int use_local
, LONGEST val_long
, char *buf
,
420 /* FIXME: Use buflen to avoid buffer overflow. */
421 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
424 vtop
= val_long
>> (sizeof (long) * HOST_CHAR_BIT
);
425 vbot
= (long) val_long
;
427 if ((format
== 'd' && (val_long
< INT_MIN
|| val_long
> INT_MAX
))
428 || ((format
== 'u' || format
== 'x') && (unsigned long long) val_long
> UINT_MAX
))
430 sprintf (buf
, "0x%lx%08lx", vtop
, vbot
);
435 #ifdef PRINTF_HAS_LONG_LONG
440 (use_local
? local_decimal_format_custom ("ll") : "%lld"),
444 sprintf (buf
, "%llu", val_long
);
448 (use_local
? local_hex_format_custom ("ll") : "%llx"),
454 (use_local
? local_octal_format_custom ("ll") : "%llo"),
458 sprintf (buf
, local_hex_format_custom ("02ll"), val_long
);
461 sprintf (buf
, local_hex_format_custom ("04ll"), val_long
);
464 sprintf (buf
, local_hex_format_custom ("08ll"), val_long
);
467 sprintf (buf
, local_hex_format_custom ("016ll"), val_long
);
472 #else /* !PRINTF_HAS_LONG_LONG */
473 /* In the following it is important to coerce (val_long) to a long. It does
474 nothing if !LONG_LONG, but it will chop off the top half (which we know
475 we can ignore) if the host supports long longs. */
480 sprintf (buf
, (use_local
? local_decimal_format_custom ("l") : "%ld"),
484 sprintf (buf
, "%lu", ((unsigned long) val_long
));
487 sprintf (buf
, (use_local
? local_hex_format_custom ("l") : "%lx"),
491 sprintf (buf
, (use_local
? local_octal_format_custom ("l") : "%lo"),
495 sprintf (buf
, local_hex_format_custom ("02l"),
499 sprintf (buf
, local_hex_format_custom ("04l"),
503 sprintf (buf
, local_hex_format_custom ("08l"),
507 sprintf (buf
, local_hex_format_custom ("016l"),
514 #endif /* !PRINTF_HAS_LONG_LONG */
518 /* This used to be a macro, but I don't think it is called often enough
519 to merit such treatment. */
520 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
521 arguments to a function, number in a value history, register number, etc.)
522 where the value must not be larger than can fit in an int. */
525 longest_to_int (LONGEST arg
)
527 /* Let the compiler do the work */
528 int rtnval
= (int) arg
;
530 /* Check for overflows or underflows */
531 if (sizeof (LONGEST
) > sizeof (int))
535 error ("Value out of range.");
542 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
546 print_floating (char *valaddr
, struct type
*type
, struct ui_file
*stream
)
550 unsigned len
= TYPE_LENGTH (type
);
552 /* Check for NaN's. Note that this code does not depend on us being
553 on an IEEE conforming system. It only depends on the target
554 machine using IEEE representation. This means (a)
555 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
556 be non-zero for systems like the 68881, which uses IEEE
557 representation, but is not IEEE conforming. */
560 unsigned long low
, high
;
561 /* Is the sign bit 0? */
563 /* Is it is a NaN (i.e. the exponent is all ones and
564 the fraction is nonzero)? */
567 /* For lint, initialize these two variables to suppress warning: */
568 low
= high
= nonnegative
= 0;
571 /* It's single precision. */
572 /* Assume that floating point byte order is the same as
573 integer byte order. */
574 low
= extract_unsigned_integer (valaddr
, 4);
575 nonnegative
= ((low
& 0x80000000) == 0);
576 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
577 && 0 != (low
& 0x7FFFFF));
583 /* It's double precision. Get the high and low words. */
585 /* Assume that floating point byte order is the same as
586 integer byte order. */
587 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
589 low
= extract_unsigned_integer (valaddr
+ 4, 4);
590 high
= extract_unsigned_integer (valaddr
, 4);
594 low
= extract_unsigned_integer (valaddr
, 4);
595 high
= extract_unsigned_integer (valaddr
+ 4, 4);
597 nonnegative
= ((high
& 0x80000000) == 0);
598 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
599 && !((((high
& 0xfffff) == 0)) && (low
== 0)));
604 #ifdef TARGET_ANALYZE_FLOATING
605 TARGET_ANALYZE_FLOATING
;
607 /* Extended. We can't detect extended NaNs for this target.
608 Also note that currently extendeds get nuked to double in
609 REGISTER_CONVERTIBLE. */
616 /* The meaning of the sign and fraction is not defined by IEEE.
617 But the user might know what they mean. For example, they
618 (in an implementation-defined manner) distinguish between
619 signaling and quiet NaN's. */
621 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + !!nonnegative
,
624 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
629 doub
= unpack_double (type
, valaddr
, &inv
);
632 fprintf_filtered (stream
, "<invalid float value>");
636 if (len
< sizeof (double))
637 fprintf_filtered (stream
, "%.9g", (double) doub
);
638 else if (len
== sizeof (double))
639 fprintf_filtered (stream
, "%.17g", (double) doub
);
641 #ifdef PRINTF_HAS_LONG_DOUBLE
642 fprintf_filtered (stream
, "%.35Lg", doub
);
644 /* This at least wins with values that are representable as doubles */
645 fprintf_filtered (stream
, "%.17g", (double) doub
);
650 print_binary_chars (struct ui_file
*stream
, unsigned char *valaddr
,
654 #define BITS_IN_BYTES 8
660 /* Declared "int" so it will be signed.
661 * This ensures that right shift will shift in zeros.
663 const int mask
= 0x080;
665 /* FIXME: We should be not printing leading zeroes in most cases. */
667 fprintf_filtered (stream
, local_binary_format_prefix ());
668 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
674 /* Every byte has 8 binary characters; peel off
675 * and print from the MSB end.
677 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
679 if (*p
& (mask
>> i
))
684 fprintf_filtered (stream
, "%1d", b
);
690 for (p
= valaddr
+ len
- 1;
694 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
696 if (*p
& (mask
>> i
))
701 fprintf_filtered (stream
, "%1d", b
);
705 fprintf_filtered (stream
, local_binary_format_suffix ());
708 /* VALADDR points to an integer of LEN bytes.
709 * Print it in octal on stream or format it in buf.
712 print_octal_chars (struct ui_file
*stream
, unsigned char *valaddr
, unsigned len
)
715 unsigned char octa1
, octa2
, octa3
, carry
;
718 /* FIXME: We should be not printing leading zeroes in most cases. */
721 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
722 * the extra bits, which cycle every three bytes:
726 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
728 * Octal side: 0 1 carry 3 4 carry ...
730 * Cycle number: 0 1 2
732 * But of course we are printing from the high side, so we have to
733 * figure out where in the cycle we are so that we end up with no
734 * left over bits at the end.
736 #define BITS_IN_OCTAL 3
737 #define HIGH_ZERO 0340
738 #define LOW_ZERO 0016
739 #define CARRY_ZERO 0003
740 #define HIGH_ONE 0200
743 #define CARRY_ONE 0001
744 #define HIGH_TWO 0300
748 /* For 32 we start in cycle 2, with two bits and one bit carry;
749 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
751 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
754 fprintf_filtered (stream
, local_octal_format_prefix ());
755 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
764 /* No carry in, carry out two bits.
766 octa1
= (HIGH_ZERO
& *p
) >> 5;
767 octa2
= (LOW_ZERO
& *p
) >> 2;
768 carry
= (CARRY_ZERO
& *p
);
769 fprintf_filtered (stream
, "%o", octa1
);
770 fprintf_filtered (stream
, "%o", octa2
);
774 /* Carry in two bits, carry out one bit.
776 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
777 octa2
= (MID_ONE
& *p
) >> 4;
778 octa3
= (LOW_ONE
& *p
) >> 1;
779 carry
= (CARRY_ONE
& *p
);
780 fprintf_filtered (stream
, "%o", octa1
);
781 fprintf_filtered (stream
, "%o", octa2
);
782 fprintf_filtered (stream
, "%o", octa3
);
786 /* Carry in one bit, no carry out.
788 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
789 octa2
= (MID_TWO
& *p
) >> 3;
790 octa3
= (LOW_TWO
& *p
);
792 fprintf_filtered (stream
, "%o", octa1
);
793 fprintf_filtered (stream
, "%o", octa2
);
794 fprintf_filtered (stream
, "%o", octa3
);
798 error ("Internal error in octal conversion;");
802 cycle
= cycle
% BITS_IN_OCTAL
;
807 for (p
= valaddr
+ len
- 1;
814 /* Carry out, no carry in */
815 octa1
= (HIGH_ZERO
& *p
) >> 5;
816 octa2
= (LOW_ZERO
& *p
) >> 2;
817 carry
= (CARRY_ZERO
& *p
);
818 fprintf_filtered (stream
, "%o", octa1
);
819 fprintf_filtered (stream
, "%o", octa2
);
823 /* Carry in, carry out */
824 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
825 octa2
= (MID_ONE
& *p
) >> 4;
826 octa3
= (LOW_ONE
& *p
) >> 1;
827 carry
= (CARRY_ONE
& *p
);
828 fprintf_filtered (stream
, "%o", octa1
);
829 fprintf_filtered (stream
, "%o", octa2
);
830 fprintf_filtered (stream
, "%o", octa3
);
834 /* Carry in, no carry out */
835 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
836 octa2
= (MID_TWO
& *p
) >> 3;
837 octa3
= (LOW_TWO
& *p
);
839 fprintf_filtered (stream
, "%o", octa1
);
840 fprintf_filtered (stream
, "%o", octa2
);
841 fprintf_filtered (stream
, "%o", octa3
);
845 error ("Internal error in octal conversion;");
849 cycle
= cycle
% BITS_IN_OCTAL
;
853 fprintf_filtered (stream
, local_octal_format_suffix ());
856 /* VALADDR points to an integer of LEN bytes.
857 * Print it in decimal on stream or format it in buf.
860 print_decimal_chars (struct ui_file
*stream
, unsigned char *valaddr
,
864 #define TWO_TO_FOURTH 16
865 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
866 #define CARRY_LEFT( x ) ((x) % TEN)
867 #define SHIFT( x ) ((x) << 4)
869 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? valaddr : valaddr + len - 1)
871 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? (p < valaddr + len) : (p >= valaddr))
873 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? p++ : p-- )
874 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
875 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
878 unsigned char *digits
;
881 int i
, j
, decimal_digits
;
885 /* Base-ten number is less than twice as many digits
886 * as the base 16 number, which is 2 digits per byte.
888 decimal_len
= len
* 2 * 2;
889 digits
= (unsigned char *) malloc (decimal_len
);
891 error ("Can't allocate memory for conversion to decimal.");
893 for (i
= 0; i
< decimal_len
; i
++)
898 fprintf_filtered (stream
, local_decimal_format_prefix ());
900 /* Ok, we have an unknown number of bytes of data to be printed in
903 * Given a hex number (in nibbles) as XYZ, we start by taking X and
904 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
905 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
907 * The trick is that "digits" holds a base-10 number, but sometimes
908 * the individual digits are > 10.
910 * Outer loop is per nibble (hex digit) of input, from MSD end to
913 decimal_digits
= 0; /* Number of decimal digits so far */
919 * Multiply current base-ten number by 16 in place.
920 * Each digit was between 0 and 9, now is between
923 for (j
= 0; j
< decimal_digits
; j
++)
925 digits
[j
] = SHIFT (digits
[j
]);
928 /* Take the next nibble off the input and add it to what
929 * we've got in the LSB position. Bottom 'digit' is now
932 * "flip" is used to run this loop twice for each byte.
938 digits
[0] += HIGH_NIBBLE (*p
);
943 /* Take low nibble and bump our pointer "p".
945 digits
[0] += LOW_NIBBLE (*p
);
950 /* Re-decimalize. We have to do this often enough
951 * that we don't overflow, but once per nibble is
952 * overkill. Easier this way, though. Note that the
953 * carry is often larger than 10 (e.g. max initial
954 * carry out of lowest nibble is 15, could bubble all
955 * the way up greater than 10). So we have to do
956 * the carrying beyond the last current digit.
959 for (j
= 0; j
< decimal_len
- 1; j
++)
963 /* "/" won't handle an unsigned char with
964 * a value that if signed would be negative.
965 * So extend to longword int via "dummy".
968 carry
= CARRY_OUT (dummy
);
969 digits
[j
] = CARRY_LEFT (dummy
);
971 if (j
>= decimal_digits
&& carry
== 0)
974 * All higher digits are 0 and we
975 * no longer have a carry.
977 * Note: "j" is 0-based, "decimal_digits" is
980 decimal_digits
= j
+ 1;
986 /* Ok, now "digits" is the decimal representation, with
987 * the "decimal_digits" actual digits. Print!
989 for (i
= decimal_digits
- 1; i
>= 0; i
--)
991 fprintf_filtered (stream
, "%1d", digits
[i
]);
995 fprintf_filtered (stream
, local_decimal_format_suffix ());
998 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1001 print_hex_chars (struct ui_file
*stream
, unsigned char *valaddr
, unsigned len
)
1005 /* FIXME: We should be not printing leading zeroes in most cases. */
1007 fprintf_filtered (stream
, local_hex_format_prefix ());
1008 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1014 fprintf_filtered (stream
, "%02x", *p
);
1019 for (p
= valaddr
+ len
- 1;
1023 fprintf_filtered (stream
, "%02x", *p
);
1026 fprintf_filtered (stream
, local_hex_format_suffix ());
1029 /* Called by various <lang>_val_print routines to print elements of an
1030 array in the form "<elem1>, <elem2>, <elem3>, ...".
1032 (FIXME?) Assumes array element separator is a comma, which is correct
1033 for all languages currently handled.
1034 (FIXME?) Some languages have a notation for repeated array elements,
1035 perhaps we should try to use that notation when appropriate.
1039 val_print_array_elements (struct type
*type
, char *valaddr
, CORE_ADDR address
,
1040 struct ui_file
*stream
, int format
, int deref_ref
,
1041 int recurse
, enum val_prettyprint pretty
,
1044 unsigned int things_printed
= 0;
1046 struct type
*elttype
;
1048 /* Position of the array element we are examining to see
1049 whether it is repeated. */
1051 /* Number of repetitions we have detected so far. */
1054 elttype
= TYPE_TARGET_TYPE (type
);
1055 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1056 len
= TYPE_LENGTH (type
) / eltlen
;
1058 annotate_array_section_begin (i
, elttype
);
1060 for (; i
< len
&& things_printed
< print_max
; i
++)
1064 if (prettyprint_arrays
)
1066 fprintf_filtered (stream
, ",\n");
1067 print_spaces_filtered (2 + 2 * recurse
, stream
);
1071 fprintf_filtered (stream
, ", ");
1074 wrap_here (n_spaces (2 + 2 * recurse
));
1078 while ((rep1
< len
) &&
1079 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
1085 if (reps
> repeat_count_threshold
)
1087 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1088 deref_ref
, recurse
+ 1, pretty
);
1089 annotate_elt_rep (reps
);
1090 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1091 annotate_elt_rep_end ();
1094 things_printed
+= repeat_count_threshold
;
1098 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1099 deref_ref
, recurse
+ 1, pretty
);
1104 annotate_array_section_end ();
1107 fprintf_filtered (stream
, "...");
1111 /* Read LEN bytes of target memory at address MEMADDR, placing the
1112 results in GDB's memory at MYADDR. Returns a count of the bytes
1113 actually read, and optionally an errno value in the location
1114 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1116 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1117 function be eliminated. */
1120 partial_memory_read (CORE_ADDR memaddr
, char *myaddr
, int len
, int *errnoptr
)
1122 int nread
; /* Number of bytes actually read. */
1123 int errcode
; /* Error from last read. */
1125 /* First try a complete read. */
1126 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1134 /* Loop, reading one byte at a time until we get as much as we can. */
1135 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1137 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1139 /* If an error, the last read was unsuccessful, so adjust count. */
1145 if (errnoptr
!= NULL
)
1147 *errnoptr
= errcode
;
1152 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1153 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1154 stops at the first null byte, otherwise printing proceeds (including null
1155 bytes) until either print_max or LEN characters have been printed,
1156 whichever is smaller. */
1158 /* FIXME: Use target_read_string. */
1161 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
1163 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1164 int errcode
; /* Errno returned from bad reads. */
1165 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1166 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1167 unsigned int chunksize
; /* Size of each fetch, in chars. */
1168 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
1169 char *bufptr
; /* Pointer to next available byte in buffer. */
1170 char *limit
; /* First location past end of fetch buffer. */
1171 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1172 int found_nul
; /* Non-zero if we found the nul char */
1174 /* First we need to figure out the limit on the number of characters we are
1175 going to attempt to fetch and print. This is actually pretty simple. If
1176 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1177 LEN is -1, then the limit is print_max. This is true regardless of
1178 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1179 because finding the null byte (or available memory) is what actually
1180 limits the fetch. */
1182 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1184 /* Now decide how large of chunks to try to read in one operation. This
1185 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1186 so we might as well read them all in one operation. If LEN is -1, we
1187 are looking for a null terminator to end the fetching, so we might as
1188 well read in blocks that are large enough to be efficient, but not so
1189 large as to be slow if fetchlimit happens to be large. So we choose the
1190 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1191 200 is way too big for remote debugging over a serial line. */
1193 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1195 /* Loop until we either have all the characters to print, or we encounter
1196 some error, such as bumping into the end of the address space. */
1199 old_chain
= make_cleanup (null_cleanup
, 0);
1203 buffer
= (char *) xmalloc (len
* width
);
1205 old_chain
= make_cleanup (xfree
, buffer
);
1207 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1209 addr
+= nfetch
* width
;
1210 bufptr
+= nfetch
* width
;
1214 unsigned long bufsize
= 0;
1218 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1221 buffer
= (char *) xmalloc (nfetch
* width
);
1224 discard_cleanups (old_chain
);
1225 buffer
= (char *) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1228 old_chain
= make_cleanup (xfree
, buffer
);
1229 bufptr
= buffer
+ bufsize
* width
;
1232 /* Read as much as we can. */
1233 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1236 /* Scan this chunk for the null byte that terminates the string
1237 to print. If found, we don't need to fetch any more. Note
1238 that bufptr is explicitly left pointing at the next character
1239 after the null byte, or at the next character after the end of
1242 limit
= bufptr
+ nfetch
* width
;
1243 while (bufptr
< limit
)
1247 c
= extract_unsigned_integer (bufptr
, width
);
1252 /* We don't care about any error which happened after
1253 the NULL terminator. */
1260 while (errcode
== 0 /* no error */
1261 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1262 && !found_nul
); /* haven't found nul yet */
1265 { /* length of string is really 0! */
1266 buffer
= bufptr
= NULL
;
1270 /* bufptr and addr now point immediately beyond the last byte which we
1271 consider part of the string (including a '\0' which ends the string). */
1273 /* We now have either successfully filled the buffer to fetchlimit, or
1274 terminated early due to an error or finding a null char when LEN is -1. */
1276 if (len
== -1 && !found_nul
)
1280 /* We didn't find a null terminator we were looking for. Attempt
1281 to peek at the next character. If not successful, or it is not
1282 a null byte, then force ellipsis to be printed. */
1284 peekbuf
= (char *) alloca (width
);
1286 if (target_read_memory (addr
, peekbuf
, width
) == 0
1287 && extract_unsigned_integer (peekbuf
, width
) != 0)
1290 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1292 /* Getting an error when we have a requested length, or fetching less
1293 than the number of characters actually requested, always make us
1300 /* If we get an error before fetching anything, don't print a string.
1301 But if we fetch something and then get an error, print the string
1302 and then the error message. */
1303 if (errcode
== 0 || bufptr
> buffer
)
1307 fputs_filtered (" ", stream
);
1309 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1316 fprintf_filtered (stream
, " <Address ");
1317 print_address_numeric (addr
, 1, stream
);
1318 fprintf_filtered (stream
, " out of bounds>");
1322 fprintf_filtered (stream
, " <Error reading address ");
1323 print_address_numeric (addr
, 1, stream
);
1324 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1328 do_cleanups (old_chain
);
1329 return ((bufptr
- buffer
) / width
);
1333 /* Validate an input or output radix setting, and make sure the user
1334 knows what they really did here. Radix setting is confusing, e.g.
1335 setting the input radix to "10" never changes it! */
1339 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1341 set_input_radix_1 (from_tty
, *(unsigned *) c
->var
);
1346 set_input_radix_1 (int from_tty
, unsigned radix
)
1348 /* We don't currently disallow any input radix except 0 or 1, which don't
1349 make any mathematical sense. In theory, we can deal with any input
1350 radix greater than 1, even if we don't have unique digits for every
1351 value from 0 to radix-1, but in practice we lose on large radix values.
1352 We should either fix the lossage or restrict the radix range more.
1357 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1360 input_radix
= radix
;
1363 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1364 radix
, radix
, radix
);
1370 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1372 set_output_radix_1 (from_tty
, *(unsigned *) c
->var
);
1376 set_output_radix_1 (int from_tty
, unsigned radix
)
1378 /* Validate the radix and disallow ones that we aren't prepared to
1379 handle correctly, leaving the radix unchanged. */
1383 output_format
= 'x'; /* hex */
1386 output_format
= 0; /* decimal */
1389 output_format
= 'o'; /* octal */
1392 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1395 output_radix
= radix
;
1398 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1399 radix
, radix
, radix
);
1403 /* Set both the input and output radix at once. Try to set the output radix
1404 first, since it has the most restrictive range. An radix that is valid as
1405 an output radix is also valid as an input radix.
1407 It may be useful to have an unusual input radix. If the user wishes to
1408 set an input radix that is not valid as an output radix, he needs to use
1409 the 'set input-radix' command. */
1412 set_radix (char *arg
, int from_tty
)
1416 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1417 set_output_radix_1 (0, radix
);
1418 set_input_radix_1 (0, radix
);
1421 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1422 radix
, radix
, radix
);
1426 /* Show both the input and output radices. */
1430 show_radix (char *arg
, int from_tty
)
1434 if (input_radix
== output_radix
)
1436 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1437 input_radix
, input_radix
, input_radix
);
1441 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1442 input_radix
, input_radix
, input_radix
);
1443 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1444 output_radix
, output_radix
, output_radix
);
1452 set_print (char *arg
, int from_tty
)
1455 "\"set print\" must be followed by the name of a print subcommand.\n");
1456 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1461 show_print (char *args
, int from_tty
)
1463 cmd_show_list (showprintlist
, from_tty
, "");
1467 _initialize_valprint (void)
1469 struct cmd_list_element
*c
;
1471 add_prefix_cmd ("print", no_class
, set_print
,
1472 "Generic command for setting how things print.",
1473 &setprintlist
, "set print ", 0, &setlist
);
1474 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1475 /* prefer set print to set prompt */
1476 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1478 add_prefix_cmd ("print", no_class
, show_print
,
1479 "Generic command for showing print settings.",
1480 &showprintlist
, "show print ", 0, &showlist
);
1481 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1482 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1485 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *) &print_max
,
1486 "Set limit on string chars or array elements to print.\n\
1487 \"set print elements 0\" causes there to be no limit.",
1492 (add_set_cmd ("null-stop", no_class
, var_boolean
,
1493 (char *) &stop_print_at_null
,
1494 "Set printing of char arrays to stop at first null char.",
1499 (add_set_cmd ("repeats", no_class
, var_uinteger
,
1500 (char *) &repeat_count_threshold
,
1501 "Set threshold for repeated print elements.\n\
1502 \"set print repeats 0\" causes all elements to be individually printed.",
1507 (add_set_cmd ("pretty", class_support
, var_boolean
,
1508 (char *) &prettyprint_structs
,
1509 "Set prettyprinting of structures.",
1514 (add_set_cmd ("union", class_support
, var_boolean
, (char *) &unionprint
,
1515 "Set printing of unions interior to structures.",
1520 (add_set_cmd ("array", class_support
, var_boolean
,
1521 (char *) &prettyprint_arrays
,
1522 "Set prettyprinting of arrays.",
1527 (add_set_cmd ("address", class_support
, var_boolean
, (char *) &addressprint
,
1528 "Set printing of addresses.",
1532 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1533 (char *) &input_radix
,
1534 "Set default input radix for entering numbers.",
1536 add_show_from_set (c
, &showlist
);
1537 c
->function
.sfunc
= set_input_radix
;
1539 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1540 (char *) &output_radix
,
1541 "Set default output radix for printing of values.",
1543 add_show_from_set (c
, &showlist
);
1544 c
->function
.sfunc
= set_output_radix
;
1546 /* The "set radix" and "show radix" commands are special in that they are
1547 like normal set and show commands but allow two normally independent
1548 variables to be either set or shown with a single command. So the
1549 usual add_set_cmd() and add_show_from_set() commands aren't really
1551 add_cmd ("radix", class_support
, set_radix
,
1552 "Set default input and output number radices.\n\
1553 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1554 Without an argument, sets both radices back to the default value of 10.",
1556 add_cmd ("radix", class_support
, show_radix
,
1557 "Show the default input and output number radices.\n\
1558 Use 'show input-radix' or 'show output-radix' to independently show each.",
1561 /* Give people the defaults which they are used to. */
1562 prettyprint_structs
= 0;
1563 prettyprint_arrays
= 0;
1566 print_max
= PRINT_MAX_DEFAULT
;
This page took 0.060241 seconds and 4 git commands to generate.