1 /* Support for printing Chill values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "expression.h"
30 #include "c-lang.h" /* For c_val_print */
31 #include "typeprint.h"
36 chill_print_value_fields
PARAMS ((struct type
*, char *, GDB_FILE
*, int, int,
37 enum val_prettyprint
, struct type
**));
40 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
41 Used to print data from type structures in a specified type. For example,
42 array bounds may be characters or booleans in some languages, and this
43 allows the ranges to be printed in their "natural" form rather than as
44 decimal integer values. */
47 chill_print_type_scalar (type
, val
, stream
)
52 switch (TYPE_CODE (type
))
55 if (TYPE_TARGET_TYPE (type
))
57 chill_print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
61 print_type_scalar (type
, val
, stream
);
64 /* Print the elements of an array.
65 Similar to val_print_array_elements, but prints
66 element indexes (in Chill syntax). */
69 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
70 format
, deref_ref
, recurse
, pretty
)
78 enum val_prettyprint pretty
;
81 unsigned int things_printed
= 0;
84 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
85 struct type
*index_type
= TYPE_TARGET_TYPE (range_type
);
87 /* Position of the array element we are examining to see
88 whether it is repeated. */
90 /* Number of repetitions we have detected so far. */
92 LONGEST low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
93 LONGEST high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
95 elttype
= TYPE_TARGET_TYPE (type
);
96 eltlen
= TYPE_LENGTH (elttype
);
97 len
= TYPE_LENGTH (type
) / eltlen
;
99 annotate_array_section_begin (i
, elttype
);
101 for (; i
< len
&& things_printed
< print_max
; i
++)
105 if (prettyprint_arrays
)
107 fprintf_filtered (stream
, ",\n");
108 print_spaces_filtered (2 + 2 * recurse
, stream
);
112 fprintf_filtered (stream
, ", ");
115 wrap_here (n_spaces (2 + 2 * recurse
));
119 while ((rep1
< len
) &&
120 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
126 fputs_filtered ("(", stream
);
127 chill_print_type_scalar (index_type
, low_bound
+ i
, stream
);
130 fputs_filtered (":", stream
);
131 chill_print_type_scalar (index_type
, low_bound
+ i
+ reps
- 1,
133 fputs_filtered ("): ", stream
);
134 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
135 deref_ref
, recurse
+ 1, pretty
);
142 fputs_filtered ("): ", stream
);
143 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
144 deref_ref
, recurse
+ 1, pretty
);
149 annotate_array_section_end ();
152 fprintf_filtered (stream
, "...");
156 /* Print data of type TYPE located at VALADDR (within GDB), which came from
157 the inferior at address ADDRESS, onto stdio stream STREAM according to
158 FORMAT (a letter or 0 for natural format). The data at VALADDR is in
161 If the data are a string pointer, returns the number of string characters
164 If DEREF_REF is nonzero, then dereference references, otherwise just print
167 The PRETTY parameter controls prettyprinting. */
170 chill_val_print (type
, valaddr
, address
, stream
, format
, deref_ref
, recurse
,
179 enum val_prettyprint pretty
;
182 unsigned int i
= 0; /* Number of characters printed. */
183 struct type
*elttype
;
186 switch (TYPE_CODE (type
))
188 case TYPE_CODE_ARRAY
:
189 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
191 if (prettyprint_arrays
)
193 print_spaces_filtered (2 + 2 * recurse
, stream
);
195 fprintf_filtered (stream
, "[");
196 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
197 format
, deref_ref
, recurse
, pretty
);
198 fprintf_filtered (stream
, "]");
202 error ("unimplemented in chill_val_print; unspecified array length");
207 format
= format
? format
: output_format
;
210 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
214 val_print_type_code_int (type
, valaddr
, stream
);
219 format
= format
? format
: output_format
;
222 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
226 LA_PRINT_CHAR ((unsigned char) unpack_long (type
, valaddr
),
234 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
238 print_floating (valaddr
, type
, stream
);
243 format
= format
? format
: output_format
;
246 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
250 /* FIXME: Why is this using builtin_type_chill_bool not type? */
251 val
= unpack_long (builtin_type_chill_bool
, valaddr
);
252 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
256 case TYPE_CODE_UNDEF
:
257 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
258 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
259 and no complete type for struct foo in that file. */
260 fprintf_filtered (stream
, "<incomplete type>");
264 if (format
&& format
!= 's')
266 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
269 addr
= unpack_pointer (type
, valaddr
);
270 elttype
= TYPE_TARGET_TYPE (type
);
272 /* We assume a NULL pointer is all zeros ... */
275 fputs_filtered ("NULL", stream
);
279 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
281 /* Try to print what function it points to. */
282 print_address_demangle (addr
, stream
, demangle
);
283 /* Return value is irrelevant except for string pointers. */
286 if (addressprint
&& format
!= 's')
288 print_address_numeric (addr
, 1, stream
);
291 /* For a pointer to char or unsigned char, also print the string
292 pointed to, unless pointer is null. */
293 if (TYPE_LENGTH (elttype
) == 1
294 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
295 && (format
== 0 || format
== 's')
297 && /* If print_max is UINT_MAX, the alloca below will fail.
298 In that case don't try to print the string. */
299 print_max
< UINT_MAX
)
301 i
= val_print_string (addr
, 0, stream
);
303 /* Return number of characters printed, plus one for the
304 terminating null if we have "reached the end". */
305 return (i
+ (print_max
&& i
!= print_max
));
308 case TYPE_CODE_STRING
:
309 i
= TYPE_LENGTH (type
);
310 LA_PRINT_STRING (stream
, valaddr
, i
, 0);
311 /* Return number of characters printed, plus one for the terminating
312 null if we have "reached the end". */
313 return (i
+ (print_max
&& i
!= print_max
));
316 case TYPE_CODE_BITSTRING
:
318 elttype
= TYPE_INDEX_TYPE (type
);
319 check_stub_type (elttype
);
320 if (TYPE_FLAGS (elttype
) & TYPE_FLAG_STUB
)
322 fprintf_filtered (stream
, "<incomplete type>");
327 struct type
*range
= elttype
;
328 int low_bound
= TYPE_LOW_BOUND (range
);
329 int high_bound
= TYPE_HIGH_BOUND (range
);
331 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
335 fputs_filtered ("B'", stream
);
337 fputs_filtered ("[", stream
);
338 for (i
= low_bound
; i
<= high_bound
; i
++)
340 int element
= value_bit_index (type
, valaddr
, i
);
342 fprintf_filtered (stream
, "%d", element
);
346 fputs_filtered (", ", stream
);
347 chill_print_type_scalar (range
, i
, stream
);
350 /* Look for a continuous range of true elements. */
351 if (i
+1 <= high_bound
&& value_bit_index (type
, valaddr
, ++i
))
353 int j
= i
; /* j is the upper bound so far of the range */
354 fputs_filtered (":", stream
);
355 while (i
+1 <= high_bound
356 && value_bit_index (type
, valaddr
, ++i
))
358 chill_print_type_scalar (range
, j
, stream
);
363 fputs_filtered ("'", stream
);
365 fputs_filtered ("]", stream
);
369 case TYPE_CODE_STRUCT
:
370 if (chill_varying_type (type
))
372 struct type
*inner
= TYPE_FIELD_TYPE (type
, 1);
373 long length
= unpack_long (TYPE_FIELD_TYPE (type
, 0), valaddr
);
374 char *data_addr
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
376 switch (TYPE_CODE (inner
))
378 case TYPE_CODE_STRING
:
379 if (length
> TYPE_LENGTH (type
))
381 fprintf_filtered (stream
,
382 "<dynamic length %d > static length %d>",
383 length
, TYPE_LENGTH (type
));
385 LA_PRINT_STRING (stream
, data_addr
, length
, 0);
391 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
398 fprintf_filtered (stream
, "LOC(");
399 print_address_numeric
400 (extract_address (valaddr
, TARGET_PTR_BIT
/ HOST_CHAR_BIT
),
403 fprintf_filtered (stream
, ")");
405 fputs_filtered (": ", stream
);
407 /* De-reference the reference. */
410 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_UNDEF
)
412 value_ptr deref_val
=
414 (TYPE_TARGET_TYPE (type
),
415 unpack_pointer (lookup_pointer_type (builtin_type_void
),
417 val_print (VALUE_TYPE (deref_val
),
418 VALUE_CONTENTS (deref_val
),
419 VALUE_ADDRESS (deref_val
), stream
, format
,
420 deref_ref
, recurse
+ 1, pretty
);
423 fputs_filtered ("???", stream
);
428 c_val_print (type
, valaddr
, address
, stream
, format
,
429 deref_ref
, recurse
, pretty
);
432 case TYPE_CODE_RANGE
:
433 if (TYPE_TARGET_TYPE (type
))
434 chill_val_print (TYPE_TARGET_TYPE (type
), valaddr
, address
, stream
,
435 format
, deref_ref
, recurse
, pretty
);
438 case TYPE_CODE_MEMBER
:
439 case TYPE_CODE_UNION
:
442 case TYPE_CODE_ERROR
:
444 /* Let's defer printing to the C printer, rather than
445 print an error message. FIXME! */
446 c_val_print (type
, valaddr
, address
, stream
, format
,
447 deref_ref
, recurse
, pretty
);
453 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
454 print out a structure's fields: cp_print_value_fields and cplus_print_value.
456 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
457 same meanings as in cplus_print_value and c_val_print.
459 DONT_PRINT is an array of baseclass types that we
460 should not print, or zero if called from top level. */
463 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
470 enum val_prettyprint pretty
;
471 struct type
**dont_print
;
476 check_stub_type (type
);
478 fprintf_filtered (stream
, "[");
479 len
= TYPE_NFIELDS (type
);
482 fprintf_filtered (stream
, "<No data fields>");
486 for (i
= 0; i
< len
; i
++)
490 fprintf_filtered (stream
, ", ");
495 fprintf_filtered (stream
, "\n");
496 print_spaces_filtered (2 + 2 * recurse
, stream
);
500 wrap_here (n_spaces (2 + 2 * recurse
));
502 fputs_filtered (".", stream
);
503 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
504 language_chill
, DMGL_NO_OPTS
);
505 fputs_filtered (": ", stream
);
506 if (TYPE_FIELD_PACKED (type
, i
))
510 /* Bitfields require special handling, especially due to byte
512 v
= value_from_longest (TYPE_FIELD_TYPE (type
, i
),
513 unpack_field_as_long (type
, valaddr
, i
));
515 chill_val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
), 0,
516 stream
, format
, 0, recurse
+ 1, pretty
);
520 chill_val_print (TYPE_FIELD_TYPE (type
, i
),
521 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
522 0, stream
, format
, 0, recurse
+ 1, pretty
);
527 fprintf_filtered (stream
, "\n");
528 print_spaces_filtered (2 * recurse
, stream
);
531 fprintf_filtered (stream
, "]");
535 chill_value_print (val
, stream
, format
, pretty
)
539 enum val_prettyprint pretty
;
541 /* A "repeated" value really contains several values in a row.
542 They are made by the @ operator.
543 Print such values as if they were arrays. */
545 if (VALUE_REPEATED (val
))
547 register unsigned int n
= VALUE_REPETITIONS (val
);
548 register unsigned int typelen
= TYPE_LENGTH (VALUE_TYPE (val
));
549 fprintf_filtered (stream
, "[");
550 /* Print arrays of characters using string syntax. */
551 if (typelen
== 1 && TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
553 LA_PRINT_STRING (stream
, VALUE_CONTENTS (val
), n
, 0);
556 value_print_array_elements (val
, stream
, format
, pretty
);
558 fprintf_filtered (stream
, "]");
559 return (n
* typelen
);
563 struct type
*type
= VALUE_TYPE (val
);
565 /* If it is a pointer, indicate what it points to.
567 Print type also if it is a reference.
569 C++: if it is a member pointer, we will take care
570 of that when we print it. */
571 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
572 TYPE_CODE (type
) == TYPE_CODE_REF
)
574 char *valaddr
= VALUE_CONTENTS (val
);
575 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
576 if (TYPE_CODE (type
) != TYPE_CODE_PTR
|| addr
!= 0)
579 char *name
= TYPE_NAME (type
);
581 fputs_filtered (name
, stream
);
582 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
583 fputs_filtered ("PTR", stream
);
586 fprintf_filtered (stream
, "(");
587 type_print (type
, "", stream
, -1);
588 fprintf_filtered (stream
, ")");
590 fprintf_filtered (stream
, "(");
591 i
= val_print (type
, valaddr
, VALUE_ADDRESS (val
),
592 stream
, format
, 1, 0, pretty
);
593 fprintf_filtered (stream
, ")");
597 return (val_print (type
, VALUE_CONTENTS (val
),
598 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
));
This page took 0.041266 seconds and 4 git commands to generate.