1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1998
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 void print_hex_chars
PARAMS ((GDB_FILE
*, unsigned char *,
43 static void show_print
PARAMS ((char *, int));
45 static void set_print
PARAMS ((char *, int));
47 static void set_radix
PARAMS ((char *, int));
49 static void show_radix
PARAMS ((char *, int));
51 static void set_input_radix
PARAMS ((char *, int, struct cmd_list_element
*));
53 static void set_input_radix_1
PARAMS ((int, unsigned));
55 static void set_output_radix
PARAMS ((char *, int, struct cmd_list_element
*));
57 static void set_output_radix_1
PARAMS ((int, unsigned));
59 void _initialize_valprint
PARAMS ((void));
61 /* Maximum number of chars to print for a string pointer value or vector
62 contents, or UINT_MAX for no limit. Note that "set print elements 0"
63 stores UINT_MAX in print_max, which displays in a show command as
66 unsigned int print_max
;
67 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
69 /* Default input and output radixes, and output format letter. */
71 unsigned input_radix
= 10;
72 unsigned output_radix
= 10;
73 int output_format
= 0;
75 /* Print repeat counts if there are more than this many repetitions of an
76 element in an array. Referenced by the low level language dependent
79 unsigned int repeat_count_threshold
= 10;
81 /* If nonzero, stops printing of char arrays at first null. */
83 int stop_print_at_null
;
85 /* Controls pretty printing of structures. */
87 int prettyprint_structs
;
89 /* Controls pretty printing of arrays. */
91 int prettyprint_arrays
;
93 /* If nonzero, causes unions inside structures or other unions to be
96 int unionprint
; /* Controls printing of nested unions. */
98 /* If nonzero, causes machine addresses to be printed in certain contexts. */
100 int addressprint
; /* Controls printing of machine addresses */
103 /* Print data of type TYPE located at VALADDR (within GDB), which came from
104 the inferior at address ADDRESS, onto stdio stream STREAM according to
105 FORMAT (a letter, or 0 for natural format using TYPE).
107 If DEREF_REF is nonzero, then dereference references, otherwise just print
110 The PRETTY parameter controls prettyprinting.
112 If the data are a string pointer, returns the number of string characters
115 FIXME: The data at VALADDR is in target byte order. If gdb is ever
116 enhanced to be able to debug more than the single target it was compiled
117 for (specific CPU type and thus specific target byte ordering), then
118 either the print routines are going to have to take this into account,
119 or the data is going to have to be passed into here already converted
120 to the host byte ordering, whichever is more convenient. */
124 val_print (type
, valaddr
, embedded_offset
, address
,
125 stream
, format
, deref_ref
, recurse
, pretty
)
134 enum val_prettyprint pretty
;
136 struct type
*real_type
= check_typedef (type
);
137 if (pretty
== Val_pretty_default
)
139 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
144 /* Ensure that the type is complete and not just a stub. If the type is
145 only a stub and we can't find and substitute its complete type, then
146 print appropriate string and return. */
148 if (TYPE_FLAGS (real_type
) & TYPE_FLAG_STUB
)
150 fprintf_filtered (stream
, "<incomplete type>");
155 return (LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
156 stream
, format
, deref_ref
, recurse
, pretty
));
159 /* Print the value VAL in C-ish syntax on stream STREAM.
160 FORMAT is a format-letter, or 0 for print in natural format of data type.
161 If the object printed is a string pointer, returns
162 the number of string bytes printed. */
165 value_print (val
, stream
, format
, pretty
)
169 enum val_prettyprint pretty
;
173 printf_filtered ("<address of value unknown>");
176 if (VALUE_OPTIMIZED_OUT (val
))
178 printf_filtered ("<value optimized out>");
181 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
184 /* Called by various <lang>_val_print routines to print
185 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
186 value. STREAM is where to print the value. */
189 val_print_type_code_int (type
, valaddr
, stream
)
194 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
198 if (TYPE_UNSIGNED (type
)
199 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
202 print_longest (stream
, 'u', 0, val
);
206 /* Signed, or we couldn't turn an unsigned value into a
207 LONGEST. For signed values, one could assume two's
208 complement (a reasonable assumption, I think) and do
210 print_hex_chars (stream
, (unsigned char *) valaddr
,
216 #ifdef PRINT_TYPELESS_INTEGER
217 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
219 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
220 unpack_long (type
, valaddr
));
225 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
226 The raison d'etre of this function is to consolidate printing of
227 LONG_LONG's into this one function. Some platforms have long longs but
228 don't have a printf() that supports "ll" in the format string. We handle
229 these by seeing if the number is representable as either a signed or
230 unsigned long, depending upon what format is desired, and if not we just
231 bail out and print the number in hex.
233 The format chars b,h,w,g are from print_scalar_formatted(). If USE_LOCAL,
234 format it according to the current language (this should be used for most
235 integers which GDB prints, the exception is things like protocols where
236 the format of the integer is a protocol thing, not a user-visible thing).
239 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
240 static void print_decimal
PARAMS ((GDB_FILE
* stream
, char *sign
, int use_local
, ULONGEST val_ulong
));
242 print_decimal (stream
, sign
, use_local
, val_ulong
)
248 unsigned long temp
[3];
252 temp
[i
] = val_ulong
% (1000 * 1000 * 1000);
253 val_ulong
/= (1000 * 1000 * 1000);
256 while (val_ulong
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
260 fprintf_filtered (stream
, "%s%lu",
264 fprintf_filtered (stream
, "%s%lu%09lu",
265 sign
, temp
[1], temp
[0]);
268 fprintf_filtered (stream
, "%s%lu%09lu%09lu",
269 sign
, temp
[2], temp
[1], temp
[0]);
279 print_longest (stream
, format
, use_local
, val_long
)
285 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
286 if (sizeof (long) < sizeof (LONGEST
))
292 /* Print a signed value, that doesn't fit in a long */
293 if ((long) val_long
!= val_long
)
296 print_decimal (stream
, "-", use_local
, -val_long
);
298 print_decimal (stream
, "", use_local
, val_long
);
305 /* Print an unsigned value, that doesn't fit in a long */
306 if ((unsigned long) val_long
!= (ULONGEST
) val_long
)
308 print_decimal (stream
, "", use_local
, val_long
);
319 /* Print as unsigned value, must fit completely in unsigned long */
321 unsigned long temp
= val_long
;
322 if (temp
!= val_long
)
324 /* Urk, can't represent value in long so print in hex.
325 Do shift in two operations so that if sizeof (long)
326 == sizeof (LONGEST) we can avoid warnings from
327 picky compilers about shifts >= the size of the
329 unsigned long vbot
= (unsigned long) val_long
;
330 LONGEST temp
= (val_long
>> (sizeof (long) * HOST_CHAR_BIT
- 1));
331 unsigned long vtop
= temp
>> 1;
332 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
341 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
345 fprintf_filtered (stream
,
346 use_local
? local_decimal_format_custom ("ll")
351 fprintf_filtered (stream
, "%llu", val_long
);
354 fprintf_filtered (stream
,
355 use_local
? local_hex_format_custom ("ll")
360 fprintf_filtered (stream
,
361 use_local
? local_octal_format_custom ("ll")
366 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
369 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
372 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
375 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
380 #else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
381 /* In the following it is important to coerce (val_long) to a long. It does
382 nothing if !LONG_LONG, but it will chop off the top half (which we know
383 we can ignore) if the host supports long longs. */
388 fprintf_filtered (stream
,
389 use_local
? local_decimal_format_custom ("l")
394 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
397 fprintf_filtered (stream
,
398 use_local
? local_hex_format_custom ("l")
400 (unsigned long) val_long
);
403 fprintf_filtered (stream
,
404 use_local
? local_octal_format_custom ("l")
406 (unsigned long) val_long
);
409 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
410 (unsigned long) val_long
);
413 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
414 (unsigned long) val_long
);
417 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
418 (unsigned long) val_long
);
421 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
422 (unsigned long) val_long
);
427 #endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
432 strcat_longest (format
, use_local
, val_long
, buf
, buflen
)
437 int buflen
; /* ignored, for now */
439 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
442 vtop
= val_long
>> (sizeof (long) * HOST_CHAR_BIT
);
443 vbot
= (long) val_long
;
445 if ((format
== 'd' && (val_long
< INT_MIN
|| val_long
> INT_MAX
))
446 || ((format
== 'u' || format
== 'x') && (unsigned long long) val_long
> UINT_MAX
))
448 sprintf (buf
, "0x%lx%08lx", vtop
, vbot
);
453 #ifdef PRINTF_HAS_LONG_LONG
458 (use_local
? local_decimal_format_custom ("ll") : "%lld"),
462 sprintf (buf
, "%llu", val_long
);
466 (use_local
? local_hex_format_custom ("ll") : "%llx"),
472 (use_local
? local_octal_format_custom ("ll") : "%llo"),
476 sprintf (buf
, local_hex_format_custom ("02ll"), val_long
);
479 sprintf (buf
, local_hex_format_custom ("04ll"), val_long
);
482 sprintf (buf
, local_hex_format_custom ("08ll"), val_long
);
485 sprintf (buf
, local_hex_format_custom ("016ll"), val_long
);
490 #else /* !PRINTF_HAS_LONG_LONG */
491 /* In the following it is important to coerce (val_long) to a long. It does
492 nothing if !LONG_LONG, but it will chop off the top half (which we know
493 we can ignore) if the host supports long longs. */
498 sprintf (buf
, (use_local
? local_decimal_format_custom ("l") : "%ld"),
502 sprintf (buf
, "%lu", ((unsigned long) val_long
));
505 sprintf (buf
, (use_local
? local_hex_format_custom ("l") : "%lx"),
509 sprintf (buf
, (use_local
? local_octal_format_custom ("l") : "%lo"),
513 sprintf (buf
, local_hex_format_custom ("02l"),
517 sprintf (buf
, local_hex_format_custom ("04l"),
521 sprintf (buf
, local_hex_format_custom ("08l"),
525 sprintf (buf
, local_hex_format_custom ("016l"),
532 #endif /* !PRINTF_HAS_LONG_LONG */
536 /* This used to be a macro, but I don't think it is called often enough
537 to merit such treatment. */
538 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
539 arguments to a function, number in a value history, register number, etc.)
540 where the value must not be larger than can fit in an int. */
546 /* Let the compiler do the work */
547 int rtnval
= (int) arg
;
549 /* Check for overflows or underflows */
550 if (sizeof (LONGEST
) > sizeof (int))
554 error ("Value out of range.");
560 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
564 print_floating (valaddr
, type
, stream
)
571 unsigned len
= TYPE_LENGTH (type
);
573 #if defined (IEEE_FLOAT)
575 /* Check for NaN's. Note that this code does not depend on us being
576 on an IEEE conforming system. It only depends on the target
577 machine using IEEE representation. This means (a)
578 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
579 be defined for systems like the 68881, which uses IEEE
580 representation, but is not IEEE conforming. */
583 unsigned long low
, high
;
584 /* Is the sign bit 0? */
586 /* Is it is a NaN (i.e. the exponent is all ones and
587 the fraction is nonzero)? */
590 /* For lint, initialize these two variables to suppress warning: */
591 low
= high
= nonnegative
= 0;
594 /* It's single precision. */
595 /* Assume that floating point byte order is the same as
596 integer byte order. */
597 low
= extract_unsigned_integer (valaddr
, 4);
598 nonnegative
= ((low
& 0x80000000) == 0);
599 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
600 && 0 != (low
& 0x7FFFFF));
606 /* It's double precision. Get the high and low words. */
608 /* Assume that floating point byte order is the same as
609 integer byte order. */
610 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
612 low
= extract_unsigned_integer (valaddr
+ 4, 4);
613 high
= extract_unsigned_integer (valaddr
, 4);
617 low
= extract_unsigned_integer (valaddr
, 4);
618 high
= extract_unsigned_integer (valaddr
+ 4, 4);
620 nonnegative
= ((high
& 0x80000000) == 0);
621 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
622 && !((((high
& 0xfffff) == 0)) && (low
== 0)));
627 #ifdef TARGET_ANALYZE_FLOATING
628 TARGET_ANALYZE_FLOATING
;
630 /* Extended. We can't detect extended NaNs for this target.
631 Also note that currently extendeds get nuked to double in
632 REGISTER_CONVERTIBLE. */
639 /* The meaning of the sign and fraction is not defined by IEEE.
640 But the user might know what they mean. For example, they
641 (in an implementation-defined manner) distinguish between
642 signaling and quiet NaN's. */
644 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + !!nonnegative
,
647 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
651 #endif /* IEEE_FLOAT. */
653 doub
= unpack_double (type
, valaddr
, &inv
);
656 fprintf_filtered (stream
, "<invalid float value>");
660 if (len
< sizeof (double))
661 fprintf_filtered (stream
, "%.9g", (double) doub
);
662 else if (len
== sizeof (double))
663 fprintf_filtered (stream
, "%.17g", (double) doub
);
665 #ifdef PRINTF_HAS_LONG_DOUBLE
666 fprintf_filtered (stream
, "%.35Lg", doub
);
668 /* This at least wins with values that are representable as doubles */
669 fprintf_filtered (stream
, "%.17g", (double) doub
);
674 print_binary_chars (stream
, valaddr
, len
)
676 unsigned char *valaddr
;
680 #define BITS_IN_BYTES 8
686 /* Declared "int" so it will be signed.
687 * This ensures that right shift will shift in zeros.
689 const int mask
= 0x080;
691 /* FIXME: We should be not printing leading zeroes in most cases. */
693 fprintf_filtered (stream
, local_binary_format_prefix ());
694 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
700 /* Every byte has 8 binary characters; peel off
701 * and print from the MSB end.
703 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
705 if (*p
& (mask
>> i
))
710 fprintf_filtered (stream
, "%1d", b
);
716 for (p
= valaddr
+ len
- 1;
720 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
722 if (*p
& (mask
>> i
))
727 fprintf_filtered (stream
, "%1d", b
);
731 fprintf_filtered (stream
, local_binary_format_suffix ());
734 /* VALADDR points to an integer of LEN bytes.
735 * Print it in octal on stream or format it in buf.
738 print_octal_chars (stream
, valaddr
, len
)
740 unsigned char *valaddr
;
744 unsigned char octa1
, octa2
, octa3
, carry
;
747 /* FIXME: We should be not printing leading zeroes in most cases. */
750 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
751 * the extra bits, which cycle every three bytes:
755 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
757 * Octal side: 0 1 carry 3 4 carry ...
759 * Cycle number: 0 1 2
761 * But of course we are printing from the high side, so we have to
762 * figure out where in the cycle we are so that we end up with no
763 * left over bits at the end.
765 #define BITS_IN_OCTAL 3
766 #define HIGH_ZERO 0340
767 #define LOW_ZERO 0016
768 #define CARRY_ZERO 0003
769 #define HIGH_ONE 0200
772 #define CARRY_ONE 0001
773 #define HIGH_TWO 0300
777 /* For 32 we start in cycle 2, with two bits and one bit carry;
778 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
780 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
783 fprintf_filtered (stream
, local_octal_format_prefix ());
784 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
793 /* No carry in, carry out two bits.
795 octa1
= (HIGH_ZERO
& *p
) >> 5;
796 octa2
= (LOW_ZERO
& *p
) >> 2;
797 carry
= (CARRY_ZERO
& *p
);
798 fprintf_filtered (stream
, "%o", octa1
);
799 fprintf_filtered (stream
, "%o", octa2
);
803 /* Carry in two bits, carry out one bit.
805 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
806 octa2
= (MID_ONE
& *p
) >> 4;
807 octa3
= (LOW_ONE
& *p
) >> 1;
808 carry
= (CARRY_ONE
& *p
);
809 fprintf_filtered (stream
, "%o", octa1
);
810 fprintf_filtered (stream
, "%o", octa2
);
811 fprintf_filtered (stream
, "%o", octa3
);
815 /* Carry in one bit, no carry out.
817 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
818 octa2
= (MID_TWO
& *p
) >> 3;
819 octa3
= (LOW_TWO
& *p
);
821 fprintf_filtered (stream
, "%o", octa1
);
822 fprintf_filtered (stream
, "%o", octa2
);
823 fprintf_filtered (stream
, "%o", octa3
);
827 error ("Internal error in octal conversion;");
831 cycle
= cycle
% BITS_IN_OCTAL
;
836 for (p
= valaddr
+ len
- 1;
843 /* Carry out, no carry in */
844 octa1
= (HIGH_ZERO
& *p
) >> 5;
845 octa2
= (LOW_ZERO
& *p
) >> 2;
846 carry
= (CARRY_ZERO
& *p
);
847 fprintf_filtered (stream
, "%o", octa1
);
848 fprintf_filtered (stream
, "%o", octa2
);
852 /* Carry in, carry out */
853 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
854 octa2
= (MID_ONE
& *p
) >> 4;
855 octa3
= (LOW_ONE
& *p
) >> 1;
856 carry
= (CARRY_ONE
& *p
);
857 fprintf_filtered (stream
, "%o", octa1
);
858 fprintf_filtered (stream
, "%o", octa2
);
859 fprintf_filtered (stream
, "%o", octa3
);
863 /* Carry in, no carry out */
864 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
865 octa2
= (MID_TWO
& *p
) >> 3;
866 octa3
= (LOW_TWO
& *p
);
868 fprintf_filtered (stream
, "%o", octa1
);
869 fprintf_filtered (stream
, "%o", octa2
);
870 fprintf_filtered (stream
, "%o", octa3
);
874 error ("Internal error in octal conversion;");
878 cycle
= cycle
% BITS_IN_OCTAL
;
882 fprintf_filtered (stream
, local_octal_format_suffix ());
885 /* VALADDR points to an integer of LEN bytes.
886 * Print it in decimal on stream or format it in buf.
889 print_decimal_chars (stream
, valaddr
, len
)
891 unsigned char *valaddr
;
895 #define TWO_TO_FOURTH 16
896 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
897 #define CARRY_LEFT( x ) ((x) % TEN)
898 #define SHIFT( x ) ((x) << 4)
900 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? valaddr : valaddr + len - 1)
902 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? (p < valaddr + len) : (p >= valaddr))
904 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? p++ : p-- )
905 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
906 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
909 unsigned char *digits
;
912 int i
, j
, decimal_digits
;
916 /* Base-ten number is less than twice as many digits
917 * as the base 16 number, which is 2 digits per byte.
919 decimal_len
= len
* 2 * 2;
920 digits
= (unsigned char *) malloc (decimal_len
);
922 error ("Can't allocate memory for conversion to decimal.");
924 for (i
= 0; i
< decimal_len
; i
++)
929 fprintf_filtered (stream
, local_decimal_format_prefix ());
931 /* Ok, we have an unknown number of bytes of data to be printed in
934 * Given a hex number (in nibbles) as XYZ, we start by taking X and
935 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
936 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
938 * The trick is that "digits" holds a base-10 number, but sometimes
939 * the individual digits are > 10.
941 * Outer loop is per nibble (hex digit) of input, from MSD end to
944 decimal_digits
= 0; /* Number of decimal digits so far */
950 * Multiply current base-ten number by 16 in place.
951 * Each digit was between 0 and 9, now is between
954 for (j
= 0; j
< decimal_digits
; j
++)
956 digits
[j
] = SHIFT (digits
[j
]);
959 /* Take the next nibble off the input and add it to what
960 * we've got in the LSB position. Bottom 'digit' is now
963 * "flip" is used to run this loop twice for each byte.
969 digits
[0] += HIGH_NIBBLE (*p
);
974 /* Take low nibble and bump our pointer "p".
976 digits
[0] += LOW_NIBBLE (*p
);
981 /* Re-decimalize. We have to do this often enough
982 * that we don't overflow, but once per nibble is
983 * overkill. Easier this way, though. Note that the
984 * carry is often larger than 10 (e.g. max initial
985 * carry out of lowest nibble is 15, could bubble all
986 * the way up greater than 10). So we have to do
987 * the carrying beyond the last current digit.
990 for (j
= 0; j
< decimal_len
- 1; j
++)
994 /* "/" won't handle an unsigned char with
995 * a value that if signed would be negative.
996 * So extend to longword int via "dummy".
999 carry
= CARRY_OUT (dummy
);
1000 digits
[j
] = CARRY_LEFT (dummy
);
1002 if (j
>= decimal_digits
&& carry
== 0)
1005 * All higher digits are 0 and we
1006 * no longer have a carry.
1008 * Note: "j" is 0-based, "decimal_digits" is
1011 decimal_digits
= j
+ 1;
1017 /* Ok, now "digits" is the decimal representation, with
1018 * the "decimal_digits" actual digits. Print!
1020 for (i
= decimal_digits
- 1; i
>= 0; i
--)
1022 fprintf_filtered (stream
, "%1d", digits
[i
]);
1026 fprintf_filtered (stream
, local_decimal_format_suffix ());
1029 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1032 print_hex_chars (stream
, valaddr
, len
)
1034 unsigned char *valaddr
;
1039 /* FIXME: We should be not printing leading zeroes in most cases. */
1041 fprintf_filtered (stream
, local_hex_format_prefix ());
1042 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1048 fprintf_filtered (stream
, "%02x", *p
);
1053 for (p
= valaddr
+ len
- 1;
1057 fprintf_filtered (stream
, "%02x", *p
);
1060 fprintf_filtered (stream
, local_hex_format_suffix ());
1063 /* Called by various <lang>_val_print routines to print elements of an
1064 array in the form "<elem1>, <elem2>, <elem3>, ...".
1066 (FIXME?) Assumes array element separator is a comma, which is correct
1067 for all languages currently handled.
1068 (FIXME?) Some languages have a notation for repeated array elements,
1069 perhaps we should try to use that notation when appropriate.
1073 val_print_array_elements (type
, valaddr
, address
, stream
, format
, deref_ref
,
1082 enum val_prettyprint pretty
;
1085 unsigned int things_printed
= 0;
1087 struct type
*elttype
;
1089 /* Position of the array element we are examining to see
1090 whether it is repeated. */
1092 /* Number of repetitions we have detected so far. */
1095 elttype
= TYPE_TARGET_TYPE (type
);
1096 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1097 len
= TYPE_LENGTH (type
) / eltlen
;
1099 annotate_array_section_begin (i
, elttype
);
1101 for (; i
< len
&& things_printed
< print_max
; i
++)
1105 if (prettyprint_arrays
)
1107 fprintf_filtered (stream
, ",\n");
1108 print_spaces_filtered (2 + 2 * recurse
, stream
);
1112 fprintf_filtered (stream
, ", ");
1115 wrap_here (n_spaces (2 + 2 * recurse
));
1119 while ((rep1
< len
) &&
1120 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
1126 if (reps
> repeat_count_threshold
)
1128 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1129 deref_ref
, recurse
+ 1, pretty
);
1130 annotate_elt_rep (reps
);
1131 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1132 annotate_elt_rep_end ();
1135 things_printed
+= repeat_count_threshold
;
1139 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
1140 deref_ref
, recurse
+ 1, pretty
);
1145 annotate_array_section_end ();
1148 fprintf_filtered (stream
, "...");
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 (addr
, len
, width
, stream
)
1167 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1168 int errcode
; /* Errno returned from bad reads. */
1169 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1170 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1171 unsigned int chunksize
; /* Size of each fetch, in chars. */
1172 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
1173 char *bufptr
; /* Pointer to next available byte in buffer. */
1174 char *limit
; /* First location past end of fetch buffer. */
1175 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1176 int found_nul
; /* Non-zero if we found the nul char */
1178 /* First we need to figure out the limit on the number of characters we are
1179 going to attempt to fetch and print. This is actually pretty simple. If
1180 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1181 LEN is -1, then the limit is print_max. This is true regardless of
1182 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1183 because finding the null byte (or available memory) is what actually
1184 limits the fetch. */
1186 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
1188 /* Now decide how large of chunks to try to read in one operation. This
1189 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1190 so we might as well read them all in one operation. If LEN is -1, we
1191 are looking for a null terminator to end the fetching, so we might as
1192 well read in blocks that are large enough to be efficient, but not so
1193 large as to be slow if fetchlimit happens to be large. So we choose the
1194 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1195 200 is way too big for remote debugging over a serial line. */
1197 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1199 /* Loop until we either have all the characters to print, or we encounter
1200 some error, such as bumping into the end of the address space. */
1203 old_chain
= make_cleanup (null_cleanup
, 0);
1207 buffer
= (char *) xmalloc (len
* width
);
1209 old_chain
= make_cleanup (free
, buffer
);
1211 nfetch
= target_read_memory_partial (addr
, bufptr
, len
* width
, &errcode
)
1213 addr
+= nfetch
* width
;
1214 bufptr
+= nfetch
* width
;
1218 unsigned long bufsize
= 0;
1222 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1225 buffer
= (char *) xmalloc (nfetch
* width
);
1228 discard_cleanups (old_chain
);
1229 buffer
= (char *) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
1232 old_chain
= make_cleanup (free
, buffer
);
1233 bufptr
= buffer
+ bufsize
* width
;
1236 /* Read as much as we can. */
1237 nfetch
= target_read_memory_partial (addr
, bufptr
, nfetch
* width
, &errcode
)
1240 /* Scan this chunk for the null byte that terminates the string
1241 to print. If found, we don't need to fetch any more. Note
1242 that bufptr is explicitly left pointing at the next character
1243 after the null byte, or at the next character after the end of
1246 limit
= bufptr
+ nfetch
* width
;
1247 while (bufptr
< limit
)
1251 c
= extract_unsigned_integer (bufptr
, width
);
1256 /* We don't care about any error which happened after
1257 the NULL terminator. */
1264 while (errcode
== 0 /* no error */
1265 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
1266 && !found_nul
); /* haven't found nul yet */
1269 { /* length of string is really 0! */
1270 buffer
= bufptr
= NULL
;
1274 /* bufptr and addr now point immediately beyond the last byte which we
1275 consider part of the string (including a '\0' which ends the string). */
1277 /* We now have either successfully filled the buffer to fetchlimit, or
1278 terminated early due to an error or finding a null char when LEN is -1. */
1280 if (len
== -1 && !found_nul
)
1284 /* We didn't find a null terminator we were looking for. Attempt
1285 to peek at the next character. If not successful, or it is not
1286 a null byte, then force ellipsis to be printed. */
1288 peekbuf
= (char *) alloca (width
);
1290 if (target_read_memory (addr
, peekbuf
, width
) == 0
1291 && extract_unsigned_integer (peekbuf
, width
) != 0)
1294 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1296 /* Getting an error when we have a requested length, or fetching less
1297 than the number of characters actually requested, always make us
1304 /* If we get an error before fetching anything, don't print a string.
1305 But if we fetch something and then get an error, print the string
1306 and then the error message. */
1307 if (errcode
== 0 || bufptr
> buffer
)
1311 fputs_filtered (" ", stream
);
1313 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1320 fprintf_filtered (stream
, " <Address ");
1321 print_address_numeric (addr
, 1, stream
);
1322 fprintf_filtered (stream
, " out of bounds>");
1326 fprintf_filtered (stream
, " <Error reading address ");
1327 print_address_numeric (addr
, 1, stream
);
1328 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1332 do_cleanups (old_chain
);
1333 return ((bufptr
- buffer
) / width
);
1337 /* Validate an input or output radix setting, and make sure the user
1338 knows what they really did here. Radix setting is confusing, e.g.
1339 setting the input radix to "10" never changes it! */
1343 set_input_radix (args
, from_tty
, c
)
1346 struct cmd_list_element
*c
;
1348 set_input_radix_1 (from_tty
, *(unsigned *) c
->var
);
1353 set_input_radix_1 (from_tty
, radix
)
1357 /* We don't currently disallow any input radix except 0 or 1, which don't
1358 make any mathematical sense. In theory, we can deal with any input
1359 radix greater than 1, even if we don't have unique digits for every
1360 value from 0 to radix-1, but in practice we lose on large radix values.
1361 We should either fix the lossage or restrict the radix range more.
1366 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1369 input_radix
= radix
;
1372 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1373 radix
, radix
, radix
);
1379 set_output_radix (args
, from_tty
, c
)
1382 struct cmd_list_element
*c
;
1384 set_output_radix_1 (from_tty
, *(unsigned *) c
->var
);
1388 set_output_radix_1 (from_tty
, radix
)
1392 /* Validate the radix and disallow ones that we aren't prepared to
1393 handle correctly, leaving the radix unchanged. */
1397 output_format
= 'x'; /* hex */
1400 output_format
= 0; /* decimal */
1403 output_format
= 'o'; /* octal */
1406 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1409 output_radix
= radix
;
1412 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1413 radix
, radix
, radix
);
1417 /* Set both the input and output radix at once. Try to set the output radix
1418 first, since it has the most restrictive range. An radix that is valid as
1419 an output radix is also valid as an input radix.
1421 It may be useful to have an unusual input radix. If the user wishes to
1422 set an input radix that is not valid as an output radix, he needs to use
1423 the 'set input-radix' command. */
1426 set_radix (arg
, from_tty
)
1432 radix
= (arg
== NULL
) ? 10 : parse_and_eval_address (arg
);
1433 set_output_radix_1 (0, radix
);
1434 set_input_radix_1 (0, radix
);
1437 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1438 radix
, radix
, radix
);
1442 /* Show both the input and output radices. */
1446 show_radix (arg
, from_tty
)
1452 if (input_radix
== output_radix
)
1454 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1455 input_radix
, input_radix
, input_radix
);
1459 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1460 input_radix
, input_radix
, input_radix
);
1461 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1462 output_radix
, output_radix
, output_radix
);
1470 set_print (arg
, from_tty
)
1475 "\"set print\" must be followed by the name of a print subcommand.\n");
1476 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1481 show_print (args
, from_tty
)
1485 cmd_show_list (showprintlist
, from_tty
, "");
1489 _initialize_valprint ()
1491 struct cmd_list_element
*c
;
1493 add_prefix_cmd ("print", no_class
, set_print
,
1494 "Generic command for setting how things print.",
1495 &setprintlist
, "set print ", 0, &setlist
);
1496 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1497 /* prefer set print to set prompt */
1498 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1500 add_prefix_cmd ("print", no_class
, show_print
,
1501 "Generic command for showing print settings.",
1502 &showprintlist
, "show print ", 0, &showlist
);
1503 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1504 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1507 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *) &print_max
,
1508 "Set limit on string chars or array elements to print.\n\
1509 \"set print elements 0\" causes there to be no limit.",
1514 (add_set_cmd ("null-stop", no_class
, var_boolean
,
1515 (char *) &stop_print_at_null
,
1516 "Set printing of char arrays to stop at first null char.",
1521 (add_set_cmd ("repeats", no_class
, var_uinteger
,
1522 (char *) &repeat_count_threshold
,
1523 "Set threshold for repeated print elements.\n\
1524 \"set print repeats 0\" causes all elements to be individually printed.",
1529 (add_set_cmd ("pretty", class_support
, var_boolean
,
1530 (char *) &prettyprint_structs
,
1531 "Set prettyprinting of structures.",
1536 (add_set_cmd ("union", class_support
, var_boolean
, (char *) &unionprint
,
1537 "Set printing of unions interior to structures.",
1542 (add_set_cmd ("array", class_support
, var_boolean
,
1543 (char *) &prettyprint_arrays
,
1544 "Set prettyprinting of arrays.",
1549 (add_set_cmd ("address", class_support
, var_boolean
, (char *) &addressprint
,
1550 "Set printing of addresses.",
1554 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1555 (char *) &input_radix
,
1556 "Set default input radix for entering numbers.",
1558 add_show_from_set (c
, &showlist
);
1559 c
->function
.sfunc
= set_input_radix
;
1561 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1562 (char *) &output_radix
,
1563 "Set default output radix for printing of values.",
1565 add_show_from_set (c
, &showlist
);
1566 c
->function
.sfunc
= set_output_radix
;
1568 /* The "set radix" and "show radix" commands are special in that they are
1569 like normal set and show commands but allow two normally independent
1570 variables to be either set or shown with a single command. So the
1571 usual add_set_cmd() and add_show_from_set() commands aren't really
1573 add_cmd ("radix", class_support
, set_radix
,
1574 "Set default input and output number radices.\n\
1575 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1576 Without an argument, sets both radices back to the default value of 10.",
1578 add_cmd ("radix", class_support
, show_radix
,
1579 "Show the default input and output number radices.\n\
1580 Use 'show input-radix' or 'show output-radix' to independently show each.",
1583 /* Give people the defaults which they are used to. */
1584 prettyprint_structs
= 0;
1585 prettyprint_arrays
= 0;
1588 print_max
= PRINT_MAX_DEFAULT
;
This page took 0.089479 seconds and 4 git commands to generate.