1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
33 extern char *sys_errlist
[];
35 extern void print_scalar_formatted(); /* printcmd.c */
36 extern void print_address_demangle(); /* printcmd.c */
37 extern int demangle
; /* whether to print C++ syms raw or source-form */
39 /* Maximum number of chars to print for a string pointer value
40 or vector contents, or UINT_MAX for no limit. */
42 static unsigned int print_max
;
44 static void type_print_varspec_suffix ();
45 static void type_print_varspec_prefix ();
46 static void type_print_base ();
47 static void type_print_method_args ();
49 /* Default input and output radixes, and output format letter. */
51 unsigned input_radix
= 10;
52 unsigned output_radix
= 10;
53 int output_format
= 0;
56 char **unsigned_type_table
;
57 char **signed_type_table
;
58 char **float_type_table
;
61 /* Print repeat counts if there are more than this
62 many repetitions of an element in an array. */
63 #define REPEAT_COUNT_THRESHOLD 10
65 /* Define a mess of print controls. */
67 int prettyprint
; /* Controls pretty printing of structures */
68 int vtblprint
; /* Controls printing of vtbl's */
69 int unionprint
; /* Controls printing of nested unions. */
70 int arrayprint
; /* Controls pretty printing of arrays. */
71 int addressprint
; /* Controls pretty printing of addresses. */
72 int objectprint
; /* Controls looking up an object's derived type
73 using what we find in its vtables. */
75 struct obstack dont_print_obstack
;
77 static void cplus_val_print ();
79 /* Print the character string STRING, printing at most LENGTH characters.
80 Printing stops early if the number hits print_max; repeat counts
81 are printed as appropriate. Print ellipses at the end if we
82 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. */
85 print_string (stream
, string
, length
, force_ellipses
)
91 register unsigned int i
;
92 unsigned int things_printed
= 0;
95 extern int inspect_it
;
99 fputs_filtered ("\"\"", stdout
);
103 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
105 /* Position of the character we are examining
106 to see whether it is repeated. */
108 /* Number of repetitions we have detected so far. */
115 fputs_filtered (", ", stream
);
121 while (rep1
< length
&& string
[rep1
] == string
[i
])
127 if (reps
> REPEAT_COUNT_THRESHOLD
)
132 fputs_filtered ("\\\", ", stream
);
134 fputs_filtered ("\", ", stream
);
137 fputs_filtered ("'", stream
);
138 printchar (string
[i
], stream
, '\'');
139 fprintf_filtered (stream
, "' <repeats %u times>", reps
);
141 things_printed
+= REPEAT_COUNT_THRESHOLD
;
149 fputs_filtered ("\\\"", stream
);
151 fputs_filtered ("\"", stream
);
154 printchar (string
[i
], stream
, '"');
159 /* Terminate the quotes if necessary. */
163 fputs_filtered ("\\\"", stream
);
165 fputs_filtered ("\"", stream
);
168 if (force_ellipses
|| i
< length
)
169 fputs_filtered ("...", stream
);
172 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
176 print_floating (valaddr
, type
, stream
)
183 unsigned len
= TYPE_LENGTH (type
);
185 #if defined (IEEE_FLOAT)
187 /* Check for NaN's. Note that this code does not depend on us being
188 on an IEEE conforming system. It only depends on the target
189 machine using IEEE representation. This means (a)
190 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
191 be defined for systems like the 68881, which uses IEEE
192 representation, but is not IEEE conforming. */
196 /* Is the sign bit 0? */
198 /* Is it is a NaN (i.e. the exponent is all ones and
199 the fraction is nonzero)? */
202 if (len
== sizeof (float))
204 /* It's single precision. */
205 bcopy (valaddr
, &low
, sizeof (low
));
206 /* target -> host. */
207 SWAP_TARGET_AND_HOST (&low
, sizeof (float));
208 nonnegative
= low
>= 0;
209 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
210 && 0 != (low
& 0x7FFFFF));
216 /* It's double precision. Get the high and low words. */
218 #if TARGET_BYTE_ORDER == BIG_ENDIAN
219 bcopy (valaddr
+4, &low
, sizeof (low
));
220 bcopy (valaddr
+0, &high
, sizeof (high
));
222 bcopy (valaddr
+0, &low
, sizeof (low
));
223 bcopy (valaddr
+4, &high
, sizeof (high
));
225 SWAP_TARGET_AND_HOST (&low
, sizeof (low
));
226 SWAP_TARGET_AND_HOST (&high
, sizeof (high
));
227 nonnegative
= high
>= 0;
228 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
229 && ! ((((high
& 0xfffff) == 0)) && (low
== 0)));
235 /* The meaning of the sign and fraction is not defined by IEEE.
236 But the user might know what they mean. For example, they
237 (in an implementation-defined manner) distinguish between
238 signaling and quiet NaN's. */
240 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + nonnegative
,
243 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
247 #endif /* IEEE_FLOAT. */
249 doub
= unpack_double (type
, valaddr
, &inv
);
251 fprintf_filtered (stream
, "<invalid float value>");
253 fprintf_filtered (stream
, len
<= sizeof(float) ? "%.9g" : "%.17g", doub
);
256 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
258 print_hex_chars (stream
, valaddr
, len
)
260 unsigned char *valaddr
;
265 fprintf_filtered (stream
, "0x");
266 #if TARGET_BYTE_ORDER == BIG_ENDIAN
270 #else /* Little endian. */
271 for (p
= valaddr
+ len
- 1;
276 fprintf_filtered (stream
, "%02x", *p
);
280 /* Print the value VAL in C-ish syntax on stream STREAM.
281 FORMAT is a format-letter, or 0 for print in natural format of data type.
282 If the object printed is a string pointer, returns
283 the number of string bytes printed. */
286 value_print (val
, stream
, format
, pretty
)
290 enum val_prettyprint pretty
;
292 register unsigned int i
, n
, typelen
;
296 printf_filtered ("<address of value unknown>");
299 if (VALUE_OPTIMIZED_OUT (val
))
301 printf_filtered ("<value optimized out>");
305 /* A "repeated" value really contains several values in a row.
306 They are made by the @ operator.
307 Print such values as if they were arrays. */
309 else if (VALUE_REPEATED (val
))
311 n
= VALUE_REPETITIONS (val
);
312 typelen
= TYPE_LENGTH (VALUE_TYPE (val
));
313 fprintf_filtered (stream
, "{");
314 /* Print arrays of characters using string syntax. */
315 if (typelen
== 1 && TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
317 print_string (stream
, VALUE_CONTENTS (val
), n
, 0);
320 unsigned int things_printed
= 0;
322 for (i
= 0; i
< n
&& things_printed
< print_max
; i
++)
324 /* Position of the array element we are examining to see
325 whether it is repeated. */
327 /* Number of repetitions we have detected so far. */
331 fprintf_filtered (stream
, ", ");
337 && !bcmp (VALUE_CONTENTS (val
) + typelen
* i
,
338 VALUE_CONTENTS (val
) + typelen
* rep1
, typelen
))
344 if (reps
> REPEAT_COUNT_THRESHOLD
)
346 val_print (VALUE_TYPE (val
),
347 VALUE_CONTENTS (val
) + typelen
* i
,
348 VALUE_ADDRESS (val
) + typelen
* i
,
349 stream
, format
, 1, 0, pretty
);
350 fprintf (stream
, " <repeats %u times>", reps
);
352 things_printed
+= REPEAT_COUNT_THRESHOLD
;
356 val_print (VALUE_TYPE (val
),
357 VALUE_CONTENTS (val
) + typelen
* i
,
358 VALUE_ADDRESS (val
) + typelen
* i
,
359 stream
, format
, 1, 0, pretty
);
364 fprintf_filtered (stream
, "...");
366 fprintf_filtered (stream
, "}");
371 struct type
*type
= VALUE_TYPE (val
);
373 /* If it is a pointer, indicate what it points to.
375 Print type also if it is a reference.
377 C++: if it is a member pointer, we will take care
378 of that when we print it. */
379 if (TYPE_CODE (type
) == TYPE_CODE_PTR
380 || TYPE_CODE (type
) == TYPE_CODE_REF
)
382 /* Hack: remove (char *) for char strings. Their
383 type is indicated by the quoted string anyway. */
384 if (TYPE_CODE (type
) == TYPE_CODE_PTR
385 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) == sizeof(char)
386 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_INT
387 && !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
393 fprintf_filtered (stream
, "(");
394 type_print (type
, "", stream
, -1);
395 fprintf_filtered (stream
, ") ");
398 return val_print (type
, VALUE_CONTENTS (val
),
399 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
);
403 /* Return truth value for assertion that TYPE is of the type
404 "pointer to virtual function". */
406 is_vtbl_ptr_type(type
)
409 char *typename
= type_name_no_tag (type
);
410 static const char vtbl_ptr_name
[] =
411 { CPLUS_MARKER
,'v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
413 return (typename
!= NULL
&& !strcmp(typename
, vtbl_ptr_name
));
416 /* Return truth value for the assertion that TYPE is of the type
417 "pointer to virtual function table". */
422 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
423 type
= TYPE_TARGET_TYPE (type
);
427 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
428 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
)
429 /* Virtual functions tables are full of pointers to virtual functions. */
430 return is_vtbl_ptr_type (TYPE_TARGET_TYPE (type
));
434 /* Mutually recursive subroutines of cplus_val_print and val_print to print out
435 a structure's fields: val_print_fields and cplus_val_print.
437 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
438 same meanings as in cplus_val_print and val_print.
440 DONT_PRINT is an array of baseclass types that we
441 should not print, or zero if called from top level. */
443 val_print_fields (type
, valaddr
, stream
, format
, recurse
, pretty
, dont_print
)
449 enum val_prettyprint pretty
;
450 struct type
**dont_print
;
452 int i
, len
, n_baseclasses
;
454 check_stub_type (type
);
456 fprintf_filtered (stream
, "{");
457 len
= TYPE_NFIELDS (type
);
458 n_baseclasses
= TYPE_N_BASECLASSES (type
);
460 /* Print out baseclasses such that we don't print
461 duplicates of virtual baseclasses. */
462 if (n_baseclasses
> 0)
463 cplus_val_print (type
, valaddr
, stream
, format
, recurse
+1, pretty
, dont_print
);
465 if (!len
&& n_baseclasses
== 1)
466 fprintf_filtered (stream
, "<No data fields>");
469 extern int inspect_it
;
472 for (i
= n_baseclasses
; i
< len
; i
++)
474 /* Check if static field */
475 if (TYPE_FIELD_STATIC (type
, i
))
478 fprintf_filtered (stream
, ", ");
479 else if (n_baseclasses
> 0)
481 fprintf_filtered (stream
, "\n");
482 print_spaces_filtered (2 + 2 * recurse
, stream
);
483 fputs_filtered ("members of ", stream
);
484 fputs_filtered (type_name_no_tag (type
), stream
);
485 fputs_filtered (": ", stream
);
491 fprintf_filtered (stream
, "\n");
492 print_spaces_filtered (2 + 2 * recurse
, stream
);
496 wrap_here (n_spaces (2 + 2 * recurse
));
500 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
501 fputs_filtered ("\"( ptr \"", stream
);
503 fputs_filtered ("\"( nodef \"", stream
);
504 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
505 fputs_filtered ("\" \"", stream
);
506 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
507 fputs_filtered ("\") \"", stream
);
511 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
512 fputs_filtered (" = ", stream
);
514 if (TYPE_FIELD_PACKED (type
, i
))
518 /* Bitfields require special handling, especially due to byte
520 v
= value_from_longest (TYPE_FIELD_TYPE (type
, i
),
521 unpack_field_as_long (type
, valaddr
, i
));
523 val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
), 0,
524 stream
, format
, 0, recurse
+ 1, pretty
);
528 val_print (TYPE_FIELD_TYPE (type
, i
),
529 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
530 0, stream
, format
, 0, recurse
+ 1, pretty
);
535 fprintf_filtered (stream
, "\n");
536 print_spaces_filtered (2 * recurse
, stream
);
539 fprintf_filtered (stream
, "}");
542 /* Special val_print routine to avoid printing multiple copies of virtual
546 cplus_val_print (type
, valaddr
, stream
, format
, recurse
, pretty
, dont_print
)
552 enum val_prettyprint pretty
;
553 struct type
**dont_print
;
555 struct obstack tmp_obstack
;
556 struct type
**last_dont_print
557 = (struct type
**)obstack_next_free (&dont_print_obstack
);
558 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
562 /* If we're at top level, carve out a completely fresh
563 chunk of the obstack and use that until this particular
564 invocation returns. */
565 tmp_obstack
= dont_print_obstack
;
566 /* Bump up the high-water mark. Now alpha is omega. */
567 obstack_finish (&dont_print_obstack
);
570 for (i
= 0; i
< n_baseclasses
; i
++)
575 if (BASETYPE_VIA_VIRTUAL (type
, i
))
577 struct type
**first_dont_print
578 = (struct type
**)obstack_base (&dont_print_obstack
);
580 int j
= (struct type
**)obstack_next_free (&dont_print_obstack
)
584 if (TYPE_BASECLASS (type
, i
) == first_dont_print
[j
])
587 obstack_ptr_grow (&dont_print_obstack
, TYPE_BASECLASS (type
, i
));
590 baddr
= baseclass_addr (type
, i
, valaddr
, 0, &err
);
591 if (err
== 0 && baddr
== 0)
592 error ("could not find virtual baseclass `%s'\n",
593 type_name_no_tag (TYPE_BASECLASS (type
, i
)));
595 fprintf_filtered (stream
, "\n");
597 print_spaces_filtered (2 + 2 * recurse
, stream
);
598 fputs_filtered ("<", stream
);
599 fputs_filtered (type_name_no_tag (TYPE_BASECLASS (type
, i
)), stream
);
600 fputs_filtered ("> = ", stream
);
602 fprintf_filtered (stream
, "<invalid address 0x%x>", baddr
);
604 val_print_fields (TYPE_BASECLASS (type
, i
), baddr
, stream
, format
,
606 (struct type
**)obstack_base (&dont_print_obstack
));
613 /* Free the space used to deal with the printing
614 of this type from top level. */
615 obstack_free (&dont_print_obstack
, last_dont_print
);
616 /* Reset watermark so that we can continue protecting
617 ourselves from whatever we were protecting ourselves. */
618 dont_print_obstack
= tmp_obstack
;
622 /* Print data of type TYPE located at VALADDR (within GDB),
623 which came from the inferior at address ADDRESS,
624 onto stdio stream STREAM according to FORMAT
625 (a letter or 0 for natural format). The data at VALADDR
626 is in target byte order.
628 If the data are a string pointer, returns the number of
629 sting characters printed.
631 if DEREF_REF is nonzero, then dereference references,
632 otherwise just print them like pointers.
634 The PRETTY parameter controls prettyprinting. */
637 val_print (type
, valaddr
, address
, stream
, format
,
638 deref_ref
, recurse
, pretty
)
646 enum val_prettyprint pretty
;
648 register unsigned int i
;
650 struct type
*elttype
;
655 if (pretty
== Val_pretty_default
)
657 pretty
= prettyprint
? Val_prettyprint
: Val_no_prettyprint
;
662 check_stub_type (type
);
664 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
666 fprintf_filtered (stream
, "<unknown struct>");
671 switch (TYPE_CODE (type
))
673 case TYPE_CODE_ARRAY
:
674 if (TYPE_LENGTH (type
) > 0
675 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
677 elttype
= TYPE_TARGET_TYPE (type
);
678 eltlen
= TYPE_LENGTH (elttype
);
679 len
= TYPE_LENGTH (type
) / eltlen
;
681 print_spaces_filtered (2 + 2 * recurse
, stream
);
682 fprintf_filtered (stream
, "{");
683 /* For an array of chars, print with string syntax. */
684 if (eltlen
== 1 && TYPE_CODE (elttype
) == TYPE_CODE_INT
685 && (format
== 0 || format
== 's') )
686 print_string (stream
, valaddr
, len
, 0);
689 unsigned int things_printed
= 0;
691 /* If this is a virtual function table, print the 0th
692 entry specially, and the rest of the members normally. */
693 if (is_vtbl_ptr_type (elttype
))
695 fprintf_filtered (stream
, "%d vtable entries", len
-1);
701 for (; i
< len
&& things_printed
< print_max
; i
++)
703 /* Position of the array element we are examining to see
704 whether it is repeated. */
706 /* Number of repetitions we have detected so far. */
712 fprintf_filtered (stream
, ",\n");
713 print_spaces_filtered (2 + 2 * recurse
, stream
);
716 fprintf_filtered (stream
, ", ");
717 wrap_here (n_spaces (2 + 2 * recurse
));
722 && !bcmp (valaddr
+ i
* eltlen
,
723 valaddr
+ rep1
* eltlen
, eltlen
))
729 if (reps
> REPEAT_COUNT_THRESHOLD
)
731 val_print (elttype
, valaddr
+ i
* eltlen
,
732 0, stream
, format
, deref_ref
,
733 recurse
+ 1, pretty
);
734 fprintf_filtered (stream
, " <repeats %u times>", reps
);
736 things_printed
+= REPEAT_COUNT_THRESHOLD
;
740 val_print (elttype
, valaddr
+ i
* eltlen
,
741 0, stream
, format
, deref_ref
,
742 recurse
+ 1, pretty
);
747 fprintf_filtered (stream
, "...");
749 fprintf_filtered (stream
, "}");
752 /* Array of unspecified length: treat like pointer to first elt. */
753 valaddr
= (char *) &address
;
756 if (format
&& format
!= 's')
758 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
761 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_METHOD
)
763 struct type
*domain
= TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type
));
769 addr
= unpack_pointer (lookup_pointer_type (builtin_type_void
),
771 if (addr
< 128) /* FIXME! What is this 128? */
773 len
= TYPE_NFN_FIELDS (domain
);
774 for (i
= 0; i
< len
; i
++)
776 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
777 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
779 for (j
= 0; j
< len2
; j
++)
782 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == addr
)
792 struct symbol
*sym
= find_pc_function (addr
);
794 error ("invalid pointer to member function");
795 len
= TYPE_NFN_FIELDS (domain
);
796 for (i
= 0; i
< len
; i
++)
798 f
= TYPE_FN_FIELDLIST1 (domain
, i
);
799 len2
= TYPE_FN_FIELDLIST_LENGTH (domain
, i
);
801 for (j
= 0; j
< len2
; j
++)
804 if (!strcmp (SYMBOL_NAME (sym
), TYPE_FN_FIELD_PHYSNAME (f
, j
)))
812 fprintf_filtered (stream
, "&");
813 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f
, j
), stream
, 0, 0);
814 fprintf (stream
, kind
);
815 if (TYPE_FN_FIELD_PHYSNAME (f
, j
)[0] == '_'
816 && TYPE_FN_FIELD_PHYSNAME (f
, j
)[1] == CPLUS_MARKER
)
817 type_print_method_args
818 (TYPE_FN_FIELD_ARGS (f
, j
) + 1, "~",
819 TYPE_FN_FIELDLIST_NAME (domain
, i
), 0, stream
);
821 type_print_method_args
822 (TYPE_FN_FIELD_ARGS (f
, j
), "",
823 TYPE_FN_FIELDLIST_NAME (domain
, i
), 0, stream
);
826 fprintf_filtered (stream
, "(");
827 type_print (type
, "", stream
, -1);
828 fprintf_filtered (stream
, ") %d", (int) addr
>> 3);
830 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_MEMBER
)
832 struct type
*domain
= TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type
));
834 /* VAL is a byte offset into the structure type DOMAIN.
835 Find the name of the field for that offset and
839 len
= TYPE_NFIELDS (domain
);
840 /* @@ Make VAL into bit offset */
841 val
= unpack_long (builtin_type_int
, valaddr
) << 3;
842 for (i
= TYPE_N_BASECLASSES (domain
); i
< len
; i
++)
844 int bitpos
= TYPE_FIELD_BITPOS (domain
, i
);
848 if (val
< bitpos
&& i
!= 0)
850 /* Somehow pointing into a field. */
852 extra
= (val
- TYPE_FIELD_BITPOS (domain
, i
));
862 fprintf_filtered (stream
, "&");
863 type_print_base (domain
, stream
, 0, 0);
864 fprintf_filtered (stream
, "::");
865 fputs_filtered (TYPE_FIELD_NAME (domain
, i
), stream
);
867 fprintf_filtered (stream
, " + %d bytes", extra
);
869 fprintf_filtered (stream
, " (offset in bits)");
872 fprintf_filtered (stream
, "%d", val
>> 3);
876 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
877 elttype
= TYPE_TARGET_TYPE (type
);
879 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
881 /* Try to print what function it points to. */
882 print_address_demangle (addr
, stream
, demangle
);
883 /* Return value is irrelevant except for string pointers. */
887 if (addressprint
&& format
!= 's')
888 fprintf_filtered (stream
, "0x%x", addr
);
890 /* For a pointer to char or unsigned char,
891 also print the string pointed to, unless pointer is null. */
892 i
= 0; /* Number of characters printed. */
893 if (TYPE_LENGTH (elttype
) == 1
894 && TYPE_CODE (elttype
) == TYPE_CODE_INT
895 && (format
== 0 || format
== 's')
897 /* If print_max is UINT_MAX, the alloca below will fail.
898 In that case don't try to print the string. */
899 && print_max
< UINT_MAX
)
901 int first_addr_err
= 0;
904 /* Get first character. */
905 errcode
= target_read_memory (addr
, (char *)&c
, 1);
908 /* First address out of bounds. */
914 char *string
= (char *) alloca (print_max
);
916 /* If the loop ends by us hitting print_max characters,
917 we need to have elipses at the end. */
918 int force_ellipses
= 1;
920 /* This loop always fetches print_max characters, even
921 though print_string might want to print more or fewer
922 (with repeated characters). This is so that
923 we don't spend forever fetching if we print
924 a long string consisting of the same character
925 repeated. Also so we can do it all in one memory
926 operation, which is faster. However, this will be
927 slower if print_max is set high, e.g. if you set
928 print_max to 1000, not only will it take a long
929 time to fetch short strings, but if you are near
930 the end of the address space, it might not work.
933 errcode
= target_read_memory (addr
, string
, print_max
);
937 for (i
= 0; i
< print_max
; i
++)
938 if (string
[i
] == '\0')
946 fputs_filtered (" ", stream
);
947 print_string (stream
, string
, i
, force_ellipses
);
954 fprintf_filtered (stream
,
955 (" <Address 0x%x out of bounds>"
961 if (errcode
>= sys_nerr
|| errcode
< 0)
962 error ("Error reading memory address 0x%x: unknown error (%d).",
965 error ("Error reading memory address 0x%x: %s.",
966 addr
+ i
, sys_errlist
[errcode
]);
972 else /* print vtbl's nicely */
973 if (is_vtbl_member(type
))
975 CORE_ADDR vt_address
= unpack_pointer (type
, valaddr
);
977 int vt_index
= find_pc_misc_function (vt_address
);
979 && vt_address
== misc_function_vector
[vt_index
].address
)
981 fputs_filtered (" <", stream
);
982 fputs_demangled (misc_function_vector
[vt_index
].name
,
984 fputs_filtered (">", stream
);
990 vt_val
= value_at (TYPE_TARGET_TYPE (type
), vt_address
);
991 val_print (VALUE_TYPE (vt_val
), VALUE_CONTENTS (vt_val
),
992 VALUE_ADDRESS (vt_val
), stream
, format
,
993 deref_ref
, recurse
+ 1, pretty
);
996 fprintf_filtered (stream
, "\n");
997 print_spaces_filtered (2 + 2 * recurse
, stream
);
1002 /* Return number of characters printed, plus one for the
1003 terminating null if we have "reached the end". */
1004 return i
+ (print_max
&& i
!= print_max
);
1008 case TYPE_CODE_MEMBER
:
1009 error ("not implemented: member type in val_print");
1015 fprintf_filtered (stream
, "@0x%lx",
1016 unpack_long (builtin_type_int
, valaddr
));
1018 fputs_filtered (": ", stream
);
1020 /* De-reference the reference. */
1023 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_UNDEF
)
1027 (TYPE_TARGET_TYPE (type
),
1028 unpack_pointer (lookup_pointer_type (builtin_type_void
),
1030 val_print (VALUE_TYPE (deref_val
), VALUE_CONTENTS (deref_val
),
1031 VALUE_ADDRESS (deref_val
), stream
, format
,
1032 deref_ref
, recurse
+ 1, pretty
);
1035 fputs_filtered ("???", stream
);
1039 case TYPE_CODE_UNION
:
1040 if (recurse
&& !unionprint
)
1042 fprintf_filtered (stream
, "{...}");
1046 case TYPE_CODE_STRUCT
:
1047 if (vtblprint
&& is_vtbl_ptr_type(type
))
1049 /* Print the unmangled name if desired. */
1050 print_address_demangle(*((int *) (valaddr
+ /* FIXME bytesex */
1051 TYPE_FIELD_BITPOS (type
, VTBL_FNADDR_OFFSET
) / 8)),
1055 val_print_fields (type
, valaddr
, stream
, format
, recurse
, pretty
, 0);
1058 case TYPE_CODE_ENUM
:
1061 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
1064 len
= TYPE_NFIELDS (type
);
1065 val
= unpack_long (builtin_type_int
, valaddr
);
1066 for (i
= 0; i
< len
; i
++)
1069 if (val
== TYPE_FIELD_BITPOS (type
, i
))
1073 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1076 fprintf_filtered (stream
, "%lld", val
);
1078 fprintf_filtered (stream
, "%ld", val
);
1082 case TYPE_CODE_FUNC
:
1085 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
1088 /* FIXME, we should consider, at least for ANSI C language, eliminating
1089 the distinction made between FUNCs and POINTERs to FUNCs. */
1090 fprintf_filtered (stream
, "{");
1091 type_print (type
, "", stream
, -1);
1092 fprintf_filtered (stream
, "} ");
1093 /* Try to print what function it points to, and its address. */
1094 print_address_demangle (address
, stream
, demangle
);
1098 if (format
|| output_format
)
1100 print_scalar_formatted (valaddr
, type
,
1101 format
? format
: output_format
,
1105 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
1107 if (TYPE_UNSIGNED (type
))
1109 /* First figure out whether the number in fact has zeros
1110 in all its bytes more significant than least significant
1111 sizeof (LONGEST) ones. */
1113 /* Pointer to first (i.e. lowest address) nonzero character. */
1115 len
= TYPE_LENGTH (type
);
1117 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1119 len
> sizeof (LONGEST
)
1120 && p
< valaddr
+ TYPE_LENGTH (type
);
1122 #else /* Little endian. */
1123 first_addr
= valaddr
;
1124 for (p
= valaddr
+ TYPE_LENGTH (type
);
1125 len
> sizeof (LONGEST
) && p
>= valaddr
;
1127 #endif /* Little endian. */
1134 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1138 if (len
<= sizeof (LONGEST
))
1140 /* We can print it in decimal. */
1143 #if defined (LONG_LONG)
1148 unpack_long (BUILTIN_TYPE_LONGEST
, first_addr
));
1152 /* It is big, so print it in hex. */
1153 print_hex_chars (stream
, (unsigned char *)first_addr
, len
);
1158 /* Signed. One could assume two's complement (a reasonable
1159 assumption, I think) and do better than this. */
1160 print_hex_chars (stream
, (unsigned char *)valaddr
,
1161 TYPE_LENGTH (type
));
1165 #ifdef PRINT_TYPELESS_INTEGER
1166 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
1169 fprintf_filtered (stream
,
1170 TYPE_UNSIGNED (type
) ? "%u" : "%d",
1171 unpack_long (type
, valaddr
));
1173 fprintf_filtered (stream
,
1174 TYPE_UNSIGNED (type
) ? "%llu" : "%lld",
1175 unpack_long (type
, valaddr
));
1179 if (TYPE_LENGTH (type
) == 1)
1181 fprintf_filtered (stream
, " '");
1182 printchar ((unsigned char) unpack_long (type
, valaddr
),
1184 fprintf_filtered (stream
, "'");
1190 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
1192 print_floating (valaddr
, type
, stream
);
1195 case TYPE_CODE_VOID
:
1196 fprintf_filtered (stream
, "void");
1199 case TYPE_CODE_UNDEF
:
1200 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
1201 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1202 and no complete type for struct foo in that file. */
1203 fprintf_filtered (stream
, "<unknown struct>");
1206 case TYPE_CODE_ERROR
:
1207 fprintf_filtered (stream
, "?");
1210 case TYPE_CODE_RANGE
:
1211 /* FIXME, we should not ever have to print one of these yet. */
1212 fprintf_filtered (stream
, "<range type>");
1216 error ("Invalid type code in symbol table.");
1222 /* Print a description of a type in the format of a
1223 typedef for the current language.
1224 NEW is the new name for a type TYPE. */
1226 typedef_print (type
, new, stream
)
1231 switch (current_language
->la_language
)
1235 case language_cplus
:
1236 fprintf_filtered(stream
, "typedef ");
1237 type_print(type
,"",stream
,0);
1238 if(TYPE_NAME ((SYMBOL_TYPE (new))) == 0
1239 || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (new))),
1241 fprintf_filtered(stream
, " %s", SYMBOL_NAME(new));
1246 fprintf_filtered(stream
, "TYPE ");
1247 if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
1248 strcmp (TYPE_NAME(SYMBOL_TYPE(new)),
1250 fprintf_filtered(stream
, "%s = ", SYMBOL_NAME(new));
1252 fprintf_filtered(stream
, "<builtin> = ");
1253 type_print(type
,"",stream
,0);
1257 error("Language not supported.");
1259 fprintf_filtered(stream
, ";\n");
1263 /* Print a description of a type TYPE
1264 in the form of a declaration of a variable named VARSTRING.
1265 (VARSTRING is demangled if necessary.)
1266 Output goes to STREAM (via stdio).
1267 If SHOW is positive, we show the contents of the outermost level
1268 of structure even if there is a type name that could be used instead.
1269 If SHOW is negative, we never show the details of elements' types. */
1272 type_print (type
, varstring
, stream
, show
)
1278 type_print_1 (type
, varstring
, stream
, show
, 0);
1281 /* LEVEL is the depth to indent lines by. */
1284 type_print_1 (type
, varstring
, stream
, show
, level
)
1291 register enum type_code code
;
1292 type_print_base (type
, stream
, show
, level
);
1293 code
= TYPE_CODE (type
);
1294 if ((varstring
&& *varstring
)
1296 /* Need a space if going to print stars or brackets;
1297 but not if we will print just a type name. */
1298 ((show
> 0 || TYPE_NAME (type
) == 0)
1300 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
1301 || code
== TYPE_CODE_METHOD
1302 || code
== TYPE_CODE_ARRAY
1303 || code
== TYPE_CODE_MEMBER
1304 || code
== TYPE_CODE_REF
)))
1305 fprintf_filtered (stream
, " ");
1306 type_print_varspec_prefix (type
, stream
, show
, 0);
1307 fputs_demangled (varstring
, stream
, -1); /* Print demangled name
1308 without arguments */
1309 type_print_varspec_suffix (type
, stream
, show
, 0);
1312 /* Print the method arguments ARGS to the file STREAM. */
1314 type_print_method_args (args
, prefix
, varstring
, staticp
, stream
)
1316 char *prefix
, *varstring
;
1322 fputs_filtered (" ", stream
);
1323 fputs_demangled (prefix
, stream
, 1);
1324 fputs_demangled (varstring
, stream
, 1);
1325 fputs_filtered (" (", stream
);
1326 if (args
&& args
[!staticp
] && args
[!staticp
]->code
!= TYPE_CODE_VOID
)
1328 i
= !staticp
; /* skip the class variable */
1331 type_print (args
[i
++], "", stream
, 0);
1334 fprintf_filtered (stream
, " ...");
1337 else if (args
[i
]->code
!= TYPE_CODE_VOID
)
1339 fprintf_filtered (stream
, ", ");
1344 fprintf_filtered (stream
, ")");
1347 /* If TYPE is a derived type, then print out derivation
1348 information. Print out all layers of the type heirarchy
1349 until we encounter one with multiple inheritance.
1350 At that point, print out that ply, and return. */
1352 type_print_derivation_info (stream
, type
)
1357 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
1358 struct type
*basetype
= 0;
1360 while (type
&& n_baseclasses
> 0)
1362 /* Not actually sure about this one -- Bryan. */
1363 check_stub_type (type
);
1365 fprintf_filtered (stream
, ": ");
1368 basetype
= TYPE_BASECLASS (type
, i
);
1369 if (name
= type_name_no_tag (basetype
))
1371 fprintf_filtered (stream
, "%s%s ",
1372 BASETYPE_VIA_PUBLIC(type
, i
) ? "public" : "private",
1373 BASETYPE_VIA_VIRTUAL(type
, i
) ? " virtual" : "");
1374 fputs_filtered (name
, stream
);
1377 if (i
>= n_baseclasses
)
1379 fprintf_filtered (stream
, ", ");
1382 fprintf_filtered (stream
, " ");
1383 if (n_baseclasses
!= 1)
1385 n_baseclasses
= TYPE_N_BASECLASSES (basetype
);
1390 /* Print any asterisks or open-parentheses needed before the
1391 variable name (to describe its type).
1393 On outermost call, pass 0 for PASSED_A_PTR.
1394 On outermost call, SHOW > 0 means should ignore
1395 any typename for TYPE and show its details.
1396 SHOW is always zero on recursive calls. */
1399 type_print_varspec_prefix (type
, stream
, show
, passed_a_ptr
)
1408 if (TYPE_NAME (type
) && show
<= 0)
1413 switch (TYPE_CODE (type
))
1416 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
1417 fprintf_filtered (stream
, "*");
1420 case TYPE_CODE_MEMBER
:
1422 fprintf_filtered (stream
, "(");
1423 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0,
1425 fprintf_filtered (stream
, " ");
1426 type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0,
1428 fprintf_filtered (stream
, "::");
1431 case TYPE_CODE_METHOD
:
1433 fprintf (stream
, "(");
1434 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0,
1438 fprintf_filtered (stream
, " ");
1439 type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0,
1441 fprintf_filtered (stream
, "::");
1446 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
1447 fprintf_filtered (stream
, "&");
1450 case TYPE_CODE_FUNC
:
1451 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0,
1454 fprintf_filtered (stream
, "(");
1457 case TYPE_CODE_ARRAY
:
1458 type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0,
1461 fprintf_filtered (stream
, "(");
1464 case TYPE_CODE_UNDEF
:
1465 case TYPE_CODE_STRUCT
:
1466 case TYPE_CODE_UNION
:
1467 case TYPE_CODE_ENUM
:
1470 case TYPE_CODE_VOID
:
1471 case TYPE_CODE_ERROR
:
1472 case TYPE_CODE_CHAR
:
1473 case TYPE_CODE_BOOL
:
1474 /* These types need no prefix. They are listed here so that
1475 gcc -Wall will reveal any types that haven't been handled. */
1480 /* Print any array sizes, function arguments or close parentheses
1481 needed after the variable name (to describe its type).
1482 Args work like type_print_varspec_prefix. */
1485 type_print_varspec_suffix (type
, stream
, show
, passed_a_ptr
)
1494 if (TYPE_NAME (type
) && show
<= 0)
1499 switch (TYPE_CODE (type
))
1501 case TYPE_CODE_ARRAY
:
1503 fprintf_filtered (stream
, ")");
1505 fprintf_filtered (stream
, "[");
1506 if (TYPE_LENGTH (type
) > 0
1507 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
1508 fprintf_filtered (stream
, "%d",
1510 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
1511 fprintf_filtered (stream
, "]");
1513 type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
1517 case TYPE_CODE_MEMBER
:
1519 fprintf_filtered (stream
, ")");
1520 type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
1523 case TYPE_CODE_METHOD
:
1525 fprintf_filtered (stream
, ")");
1526 type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
1530 struct type
**args
= TYPE_ARG_TYPES (type
);
1532 fprintf_filtered (stream
, "(");
1534 fprintf_filtered (stream
, "...");
1535 else for (i
= 1; args
[i
] != 0 && args
[i
]->code
!= TYPE_CODE_VOID
; i
++)
1537 type_print_1 (args
[i
], "", stream
, -1, 0);
1539 fprintf_filtered (stream
, "...");
1540 else if (args
[i
+1]->code
!= TYPE_CODE_VOID
) {
1541 fprintf_filtered (stream
, ",");
1545 fprintf_filtered (stream
, ")");
1551 type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
1554 case TYPE_CODE_FUNC
:
1555 type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
1558 fprintf_filtered (stream
, ")");
1559 fprintf_filtered (stream
, "()");
1562 case TYPE_CODE_UNDEF
:
1563 case TYPE_CODE_STRUCT
:
1564 case TYPE_CODE_UNION
:
1565 case TYPE_CODE_ENUM
:
1568 case TYPE_CODE_VOID
:
1569 case TYPE_CODE_ERROR
:
1570 case TYPE_CODE_CHAR
:
1571 case TYPE_CODE_BOOL
:
1572 /* These types do not need a suffix. They are listed so that
1573 gcc -Wall will report types that may not have been considered. */
1578 /* Print the name of the type (or the ultimate pointer target,
1579 function value or array element), or the description of a
1582 SHOW nonzero means don't print this type as just its name;
1583 show its real definition even if it has a name.
1584 SHOW zero means print just typename or struct tag if there is one
1585 SHOW negative means abbreviate structure elements.
1586 SHOW is decremented for printing of structure elements.
1588 LEVEL is the depth to indent by.
1589 We increase it for some recursive calls. */
1592 type_print_base (type
, stream
, show
, level
)
1601 register int lastval
;
1608 fprintf_filtered (stream
, "<type unknown>");
1612 if (TYPE_NAME (type
) && show
<= 0)
1614 fputs_filtered (TYPE_NAME (type
), stream
);
1618 switch (TYPE_CODE (type
))
1620 case TYPE_CODE_ARRAY
:
1622 case TYPE_CODE_MEMBER
:
1624 case TYPE_CODE_FUNC
:
1625 case TYPE_CODE_METHOD
:
1626 type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
1629 case TYPE_CODE_STRUCT
:
1630 fprintf_filtered (stream
, "struct ");
1633 case TYPE_CODE_UNION
:
1634 fprintf_filtered (stream
, "union ");
1636 if (name
= type_name_no_tag (type
))
1638 fputs_filtered (name
, stream
);
1639 fputs_filtered (" ", stream
);
1643 fprintf_filtered (stream
, "{...}");
1646 check_stub_type (type
);
1648 type_print_derivation_info (stream
, type
);
1650 fprintf_filtered (stream
, "{");
1651 len
= TYPE_NFIELDS (type
);
1653 fprintf_filtered (stream
, "\n");
1656 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
1657 fprintf_filtered (stream
, "<incomplete type>\n");
1659 fprintf_filtered (stream
, "<no data fields>\n");
1662 /* If there is a base class for this type,
1663 do not print the field that it occupies. */
1664 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1667 /* Don't print out virtual function table. */
1668 if ((TYPE_FIELD_NAME (type
, i
))[5] == CPLUS_MARKER
&&
1669 !strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5))
1672 print_spaces_filtered (level
+ 4, stream
);
1673 if (TYPE_FIELD_STATIC (type
, i
))
1675 fprintf_filtered (stream
, "static ");
1677 type_print_1 (TYPE_FIELD_TYPE (type
, i
),
1678 TYPE_FIELD_NAME (type
, i
),
1679 stream
, show
- 1, level
+ 4);
1680 if (!TYPE_FIELD_STATIC (type
, i
)
1681 && TYPE_FIELD_PACKED (type
, i
))
1683 /* It is a bitfield. This code does not attempt
1684 to look at the bitpos and reconstruct filler,
1685 unnamed fields. This would lead to misleading
1686 results if the compiler does not put out fields
1687 for such things (I don't know what it does). */
1688 fprintf_filtered (stream
, " : %d",
1689 TYPE_FIELD_BITSIZE (type
, i
));
1691 fprintf_filtered (stream
, ";\n");
1694 /* C++: print out the methods */
1695 len
= TYPE_NFN_FIELDS (type
);
1696 if (len
) fprintf_filtered (stream
, "\n");
1697 for (i
= 0; i
< len
; i
++)
1699 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1700 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1702 for (j
= 0; j
< len2
; j
++)
1705 print_spaces_filtered (level
+ 4, stream
);
1706 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1707 fprintf_filtered (stream
, "virtual ");
1708 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1709 fprintf_filtered (stream
, "static ");
1710 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1712 /* Keep GDB from crashing here. */
1713 fprintf (stream
, "<undefined type> %s;\n",
1714 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1718 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)), "", stream
, 0);
1719 if (TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f
, j
)) & TYPE_FLAG_STUB
)
1721 /* Build something we can demangle. */
1722 char *strchr (), *gdb_mangle_name (), *cplus_demangle ();
1723 char *mangled_name
= gdb_mangle_name (type
, i
, j
);
1724 char *demangled_name
= cplus_demangle (mangled_name
, 1);
1725 if (demangled_name
== 0)
1726 fprintf_filtered (stream
, " <badly mangled name %s>",
1730 fprintf_filtered (stream
, " %s",
1731 strchr (demangled_name
, ':') + 2);
1732 free (demangled_name
);
1734 free (mangled_name
);
1736 else if (TYPE_FN_FIELD_PHYSNAME (f
, j
)[0] == '_'
1737 && TYPE_FN_FIELD_PHYSNAME (f
, j
)[1] == CPLUS_MARKER
)
1738 type_print_method_args
1739 (TYPE_FN_FIELD_ARGS (f
, j
) + 1, "~",
1740 TYPE_FN_FIELDLIST_NAME (type
, i
), 0, stream
);
1742 type_print_method_args
1743 (TYPE_FN_FIELD_ARGS (f
, j
), "",
1744 TYPE_FN_FIELDLIST_NAME (type
, i
),
1745 TYPE_FN_FIELD_STATIC_P (f
, j
), stream
);
1747 fprintf_filtered (stream
, ";\n");
1751 print_spaces_filtered (level
, stream
);
1752 fprintf_filtered (stream
, "}");
1756 case TYPE_CODE_ENUM
:
1757 fprintf_filtered (stream
, "enum ");
1758 if (name
= type_name_no_tag (type
))
1760 fputs_filtered (name
, stream
);
1761 fputs_filtered (" ", stream
);
1765 fprintf_filtered (stream
, "{...}");
1768 fprintf_filtered (stream
, "{");
1769 len
= TYPE_NFIELDS (type
);
1771 for (i
= 0; i
< len
; i
++)
1774 if (i
) fprintf_filtered (stream
, ", ");
1776 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1777 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1779 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1780 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1784 fprintf_filtered (stream
, "}");
1790 if (TYPE_LENGTH (type
) <= sizeof (LONGEST
))
1792 if (TYPE_UNSIGNED (type
))
1793 name
= unsigned_type_table
[TYPE_LENGTH (type
)];
1795 name
= signed_type_table
[TYPE_LENGTH (type
)];
1798 fputs_filtered (name
, stream
);
1800 fprintf_filtered (stream
, "<%d bit integer>",
1801 TYPE_LENGTH (type
) * TARGET_CHAR_BIT
);
1805 name
= float_type_table
[TYPE_LENGTH (type
)];
1806 fputs_filtered (name
, stream
);
1809 case TYPE_CODE_VOID
:
1810 fprintf_filtered (stream
, "void");
1813 case TYPE_CODE_UNDEF
:
1814 fprintf_filtered (stream
, "struct <unknown>");
1817 case TYPE_CODE_ERROR
:
1818 fprintf_filtered (stream
, "<unknown type>");
1821 case TYPE_CODE_RANGE
:
1822 /* This should not occur */
1823 fprintf_filtered (stream
, "<range type>");
1827 error ("Invalid type code in symbol table.");
1832 /* Validate an input or output radix setting, and make sure the user
1833 knows what they really did here. Radix setting is confusing, e.g.
1834 setting the input radix to "10" never changes it! */
1838 set_input_radix (args
, from_tty
, c
)
1841 struct cmd_list_element
*c
;
1843 unsigned radix
= *(unsigned *)c
->var
;
1846 printf_filtered ("Input radix set to decimal %d, hex %x, octal %o\n",
1847 radix
, radix
, radix
);
1853 set_output_radix (args
, from_tty
, c
)
1856 struct cmd_list_element
*c
;
1858 unsigned radix
= *(unsigned *)c
->var
;
1861 printf_filtered ("Output radix set to decimal %d, hex %x, octal %o\n",
1862 radix
, radix
, radix
);
1864 /* FIXME, we really should be able to validate the setting BEFORE
1869 output_format
= 'x';
1875 output_format
= 'o'; /* octal */
1879 error ("Unsupported radix ``decimal %d''; using decimal output",
1886 set_radix (arg
, from_tty
, c
)
1889 struct cmd_list_element
*c
;
1891 unsigned radix
= *(unsigned *)c
->var
;
1894 printf_filtered ("Radix set to decimal %d, hex %x, octal %o\n",
1895 radix
, radix
, radix
);
1897 input_radix
= radix
;
1898 output_radix
= radix
;
1900 set_output_radix (arg
, 0, c
);
1903 struct cmd_list_element
*setprintlist
= NULL
;
1904 struct cmd_list_element
*showprintlist
= NULL
;
1908 set_print (arg
, from_tty
)
1913 "\"set print\" must be followed by the name of a print subcommand.\n");
1914 help_list (setprintlist
, "set print ", -1, stdout
);
1919 show_print (args
, from_tty
)
1923 cmd_show_list (showprintlist
, from_tty
, "");
1927 _initialize_valprint ()
1929 struct cmd_list_element
*c
;
1931 add_prefix_cmd ("print", no_class
, set_print
,
1932 "Generic command for setting how things print.",
1933 &setprintlist
, "set print ", 0, &setlist
);
1934 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1935 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
); /* prefer set print
1937 add_prefix_cmd ("print", no_class
, show_print
,
1938 "Generic command for showing print settings.",
1939 &showprintlist
, "show print ", 0, &showlist
);
1940 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1941 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1944 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *)&print_max
,
1945 "Set limit on string chars or array elements to print.\n\
1946 \"set print elements 0\" causes there to be no limit.",
1951 (add_set_cmd ("pretty", class_support
, var_boolean
, (char *)&prettyprint
,
1952 "Set prettyprinting of structures.",
1957 (add_set_cmd ("union", class_support
, var_boolean
, (char *)&unionprint
,
1958 "Set printing of unions interior to structures.",
1963 (add_set_cmd ("vtbl", class_support
, var_boolean
, (char *)&vtblprint
,
1964 "Set printing of C++ virtual function tables.",
1969 (add_set_cmd ("array", class_support
, var_boolean
, (char *)&arrayprint
,
1970 "Set prettyprinting of arrays.",
1975 (add_set_cmd ("object", class_support
, var_boolean
, (char *)&objectprint
,
1976 "Set printing of object's derived type based on vtable info.",
1981 (add_set_cmd ("address", class_support
, var_boolean
, (char *)&addressprint
,
1982 "Set printing of addresses.",
1987 /* The "show radix" cmd isn't good enough to show two separate values.
1988 The rest of the code works, but the show part is confusing, so don't
1989 let them be set separately 'til we work out "show". */
1990 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1991 (char *)&input_radix
,
1992 "Set default input radix for entering numbers.",
1994 add_show_from_set (c
, &showlist
);
1995 c
->function
= set_input_radix
;
1997 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1998 (char *)&output_radix
,
1999 "Set default output radix for printing of values.",
2001 add_show_from_set (c
, &showlist
);
2002 c
->function
= set_output_radix
;
2005 c
= add_set_cmd ("radix", class_support
, var_uinteger
,
2006 (char *)&output_radix
,
2007 "Set default input and output number radix.",
2009 add_show_from_set (c
, &showlist
);
2010 c
->function
= set_radix
;
2012 /* Give people the defaults which they are used to. */
2022 /* Initialize the names of the various types based on their lengths on
2023 the target, in bits. Note that ordering is important, so that for example,
2024 if ints and longs are the same size, that size will default to "int". */
2026 unsigned_type_table
= (char **)
2027 xmalloc ((1 + (TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
)) * sizeof (char *));
2028 bzero (unsigned_type_table
, (1 + (TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
)));
2029 unsigned_type_table
[TARGET_CHAR_BIT
/TARGET_CHAR_BIT
] = "unsigned char";
2030 unsigned_type_table
[TARGET_SHORT_BIT
/TARGET_CHAR_BIT
] = "unsigned short";
2031 unsigned_type_table
[TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
] = "unsigned long long";
2032 unsigned_type_table
[TARGET_LONG_BIT
/TARGET_CHAR_BIT
] = "unsigned long";
2033 unsigned_type_table
[TARGET_INT_BIT
/TARGET_CHAR_BIT
] = "unsigned int";
2035 signed_type_table
= (char **)
2036 xmalloc ((1 + (TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
)) * sizeof (char *));
2037 bzero (signed_type_table
, (1 + (TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
)));
2038 signed_type_table
[TARGET_CHAR_BIT
/TARGET_CHAR_BIT
] = "char";
2039 signed_type_table
[TARGET_SHORT_BIT
/TARGET_CHAR_BIT
] = "short";
2040 signed_type_table
[TARGET_LONG_LONG_BIT
/TARGET_CHAR_BIT
] = "long long";
2041 signed_type_table
[TARGET_LONG_BIT
/TARGET_CHAR_BIT
] = "long";
2042 signed_type_table
[TARGET_INT_BIT
/TARGET_CHAR_BIT
] = "int";
2044 float_type_table
= (char **)
2045 xmalloc ((1 + (TARGET_LONG_DOUBLE_BIT
/TARGET_CHAR_BIT
)) * sizeof (char *));
2046 bzero (float_type_table
, (1 + (TARGET_LONG_DOUBLE_BIT
/TARGET_CHAR_BIT
)));
2047 float_type_table
[TARGET_FLOAT_BIT
/TARGET_CHAR_BIT
] = "float";
2048 float_type_table
[TARGET_DOUBLE_COMPLEX_BIT
/TARGET_CHAR_BIT
] = "double complex";
2049 float_type_table
[TARGET_COMPLEX_BIT
/TARGET_CHAR_BIT
] = "complex";
2050 float_type_table
[TARGET_LONG_DOUBLE_BIT
/TARGET_CHAR_BIT
] = "long double";
2051 float_type_table
[TARGET_DOUBLE_BIT
/TARGET_CHAR_BIT
] = "double";
2053 obstack_begin (&dont_print_obstack
, 32 * sizeof (struct type
*));