1 /* Support for printing Chill values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991-1994, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
27 #include "expression.h"
31 #include "c-lang.h" /* For c_val_print */
32 #include "typeprint.h"
36 static void chill_print_value_fields (struct type
*, char *,
37 struct ui_file
*, int, int,
38 enum val_prettyprint
, struct type
**);
40 static void chill_print_type_scalar (struct type
*, LONGEST
,
43 static void chill_val_print_array_elements (struct type
*, char *,
44 CORE_ADDR
, struct ui_file
*,
46 enum val_prettyprint
);
49 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
50 Used to print data from type structures in a specified type. For example,
51 array bounds may be characters or booleans in some languages, and this
52 allows the ranges to be printed in their "natural" form rather than as
53 decimal integer values. */
56 chill_print_type_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
58 switch (TYPE_CODE (type
))
61 if (TYPE_TARGET_TYPE (type
))
63 chill_print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
70 case TYPE_CODE_STRUCT
:
78 case TYPE_CODE_STRING
:
79 case TYPE_CODE_BITSTRING
:
81 case TYPE_CODE_MEMBER
:
82 case TYPE_CODE_METHOD
:
86 case TYPE_CODE_COMPLEX
:
87 case TYPE_CODE_TYPEDEF
:
91 print_type_scalar (type
, val
, stream
);
94 /* Print the elements of an array.
95 Similar to val_print_array_elements, but prints
96 element indexes (in Chill syntax). */
99 chill_val_print_array_elements (struct type
*type
, char *valaddr
,
100 CORE_ADDR address
, struct ui_file
*stream
,
101 int format
, int deref_ref
, int recurse
,
102 enum val_prettyprint pretty
)
105 unsigned int things_printed
= 0;
107 struct type
*elttype
;
108 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
109 struct type
*index_type
= TYPE_TARGET_TYPE (range_type
);
111 /* Position of the array element we are examining to see
112 whether it is repeated. */
114 /* Number of repetitions we have detected so far. */
116 LONGEST low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
118 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
119 eltlen
= TYPE_LENGTH (elttype
);
120 len
= TYPE_LENGTH (type
) / eltlen
;
122 annotate_array_section_begin (i
, elttype
);
124 for (; i
< len
&& things_printed
< print_max
; i
++)
128 if (prettyprint_arrays
)
130 fprintf_filtered (stream
, ",\n");
131 print_spaces_filtered (2 + 2 * recurse
, stream
);
135 fprintf_filtered (stream
, ", ");
138 wrap_here (n_spaces (2 + 2 * recurse
));
142 while ((rep1
< len
) &&
143 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
149 fputs_filtered ("(", stream
);
150 chill_print_type_scalar (index_type
, low_bound
+ i
, stream
);
153 fputs_filtered (":", stream
);
154 chill_print_type_scalar (index_type
, low_bound
+ i
+ reps
- 1,
156 fputs_filtered ("): ", stream
);
157 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
158 deref_ref
, recurse
+ 1, pretty
);
165 fputs_filtered ("): ", stream
);
166 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
167 deref_ref
, recurse
+ 1, pretty
);
172 annotate_array_section_end ();
175 fprintf_filtered (stream
, "...");
179 /* Print data of type TYPE located at VALADDR (within GDB), which came from
180 the inferior at address ADDRESS, onto stdio stream STREAM according to
181 FORMAT (a letter or 0 for natural format). The data at VALADDR is in
184 If the data are a string pointer, returns the number of string characters
187 If DEREF_REF is nonzero, then dereference references, otherwise just print
190 The PRETTY parameter controls prettyprinting. */
193 chill_val_print (struct type
*type
, char *valaddr
, int embedded_offset
,
194 CORE_ADDR address
, struct ui_file
*stream
, int format
,
195 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
198 unsigned int i
= 0; /* Number of characters printed. */
199 struct type
*elttype
;
202 CHECK_TYPEDEF (type
);
204 switch (TYPE_CODE (type
))
206 case TYPE_CODE_ARRAY
:
207 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
209 if (prettyprint_arrays
)
211 print_spaces_filtered (2 + 2 * recurse
, stream
);
213 fprintf_filtered (stream
, "[");
214 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
215 format
, deref_ref
, recurse
, pretty
);
216 fprintf_filtered (stream
, "]");
220 error ("unimplemented in chill_val_print; unspecified array length");
225 format
= format
? format
: output_format
;
228 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
232 val_print_type_code_int (type
, valaddr
, stream
);
237 format
= format
? format
: output_format
;
240 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
244 LA_PRINT_CHAR ((unsigned char) unpack_long (type
, valaddr
),
252 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
256 print_floating (valaddr
, type
, stream
);
261 format
= format
? format
: output_format
;
264 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
268 /* FIXME: Why is this using builtin_type_chill_bool not type? */
269 val
= unpack_long (builtin_type_chill_bool
, valaddr
);
270 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
274 case TYPE_CODE_UNDEF
:
275 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
276 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
277 and no complete type for struct foo in that file. */
278 fprintf_filtered (stream
, "<incomplete type>");
282 if (format
&& format
!= 's')
284 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
287 addr
= unpack_pointer (type
, valaddr
);
288 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
290 /* We assume a NULL pointer is all zeros ... */
293 fputs_filtered ("NULL", stream
);
297 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
299 /* Try to print what function it points to. */
300 print_address_demangle (addr
, stream
, demangle
);
301 /* Return value is irrelevant except for string pointers. */
304 if (addressprint
&& format
!= 's')
306 print_address_numeric (addr
, 1, stream
);
309 /* For a pointer to char or unsigned char, also print the string
310 pointed to, unless pointer is null. */
311 if (TYPE_LENGTH (elttype
) == 1
312 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
313 && (format
== 0 || format
== 's')
315 && /* If print_max is UINT_MAX, the alloca below will fail.
316 In that case don't try to print the string. */
317 print_max
< UINT_MAX
)
318 i
= val_print_string (addr
, -1, TYPE_LENGTH (elttype
), stream
);
320 /* Return number of characters printed, plus one for the
321 terminating null if we have "reached the end". */
322 return (i
+ (print_max
&& i
!= print_max
));
325 case TYPE_CODE_STRING
:
326 i
= TYPE_LENGTH (type
);
327 LA_PRINT_STRING (stream
, valaddr
, i
, 1, 0);
328 /* Return number of characters printed, plus one for the terminating
329 null if we have "reached the end". */
330 return (i
+ (print_max
&& i
!= print_max
));
333 case TYPE_CODE_BITSTRING
:
335 elttype
= TYPE_INDEX_TYPE (type
);
336 CHECK_TYPEDEF (elttype
);
337 if (TYPE_FLAGS (elttype
) & TYPE_FLAG_STUB
)
339 fprintf_filtered (stream
, "<incomplete type>");
344 struct type
*range
= elttype
;
345 LONGEST low_bound
, high_bound
;
347 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
351 fputs_filtered ("B'", stream
);
353 fputs_filtered ("[", stream
);
355 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
359 fputs_filtered ("<error value>", stream
);
363 for (i
= low_bound
; i
<= high_bound
; i
++)
365 int element
= value_bit_index (type
, valaddr
, i
);
369 goto maybe_bad_bstring
;
372 fprintf_filtered (stream
, "%d", element
);
376 fputs_filtered (", ", stream
);
377 chill_print_type_scalar (range
, (LONGEST
) i
, stream
);
380 /* Look for a continuous range of true elements. */
381 if (i
+ 1 <= high_bound
&& value_bit_index (type
, valaddr
, ++i
))
383 int j
= i
; /* j is the upper bound so far of the range */
384 fputs_filtered (":", stream
);
385 while (i
+ 1 <= high_bound
386 && value_bit_index (type
, valaddr
, ++i
))
388 chill_print_type_scalar (range
, (LONGEST
) j
, stream
);
394 fputs_filtered ("'", stream
);
396 fputs_filtered ("]", stream
);
400 case TYPE_CODE_STRUCT
:
401 if (chill_varying_type (type
))
403 struct type
*inner
= check_typedef (TYPE_FIELD_TYPE (type
, 1));
404 long length
= unpack_long (TYPE_FIELD_TYPE (type
, 0), valaddr
);
405 char *data_addr
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
407 switch (TYPE_CODE (inner
))
409 case TYPE_CODE_STRING
:
410 if (length
> TYPE_LENGTH (type
) - 2)
412 fprintf_filtered (stream
,
413 "<dynamic length %ld > static length %d> *invalid*",
414 length
, TYPE_LENGTH (type
));
416 /* Don't print the string; doing so might produce a
420 LA_PRINT_STRING (stream
, data_addr
, length
, 1, 0);
426 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
433 fprintf_filtered (stream
, "LOC(");
434 print_address_numeric
435 (extract_address (valaddr
, TARGET_PTR_BIT
/ HOST_CHAR_BIT
),
438 fprintf_filtered (stream
, ")");
440 fputs_filtered (": ", stream
);
442 /* De-reference the reference. */
445 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_UNDEF
)
447 value_ptr deref_val
=
449 (TYPE_TARGET_TYPE (type
),
450 unpack_pointer (lookup_pointer_type (builtin_type_void
),
453 val_print (VALUE_TYPE (deref_val
),
454 VALUE_CONTENTS (deref_val
),
456 VALUE_ADDRESS (deref_val
), stream
, format
,
457 deref_ref
, recurse
+ 1, pretty
);
460 fputs_filtered ("???", stream
);
465 c_val_print (type
, valaddr
, 0, address
, stream
, format
,
466 deref_ref
, recurse
, pretty
);
469 case TYPE_CODE_RANGE
:
470 if (TYPE_TARGET_TYPE (type
))
471 chill_val_print (TYPE_TARGET_TYPE (type
), valaddr
, 0, address
, stream
,
472 format
, deref_ref
, recurse
, pretty
);
475 case TYPE_CODE_MEMBER
:
476 case TYPE_CODE_UNION
:
479 case TYPE_CODE_ERROR
:
481 /* Let's defer printing to the C printer, rather than
482 print an error message. FIXME! */
483 c_val_print (type
, valaddr
, 0, address
, stream
, format
,
484 deref_ref
, recurse
, pretty
);
490 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
491 print out a structure's fields: cp_print_value_fields and cplus_print_value.
493 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
494 same meanings as in cplus_print_value and c_val_print.
496 DONT_PRINT is an array of baseclass types that we
497 should not print, or zero if called from top level. */
500 chill_print_value_fields (struct type
*type
, char *valaddr
,
501 struct ui_file
*stream
, int format
, int recurse
,
502 enum val_prettyprint pretty
, struct type
**dont_print
)
507 CHECK_TYPEDEF (type
);
509 fprintf_filtered (stream
, "[");
510 len
= TYPE_NFIELDS (type
);
513 fprintf_filtered (stream
, "<No data fields>");
517 for (i
= 0; i
< len
; i
++)
521 fprintf_filtered (stream
, ", ");
526 fprintf_filtered (stream
, "\n");
527 print_spaces_filtered (2 + 2 * recurse
, stream
);
531 wrap_here (n_spaces (2 + 2 * recurse
));
533 fputs_filtered (".", stream
);
534 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
535 language_chill
, DMGL_NO_OPTS
);
536 fputs_filtered (": ", stream
);
537 if (TYPE_FIELD_PACKED (type
, i
))
541 /* Bitfields require special handling, especially due to byte
543 v
= value_from_longest (TYPE_FIELD_TYPE (type
, i
),
544 unpack_field_as_long (type
, valaddr
, i
));
546 chill_val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
), 0, 0,
547 stream
, format
, 0, recurse
+ 1, pretty
);
551 chill_val_print (TYPE_FIELD_TYPE (type
, i
),
552 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / 8, 0,
553 0, stream
, format
, 0, recurse
+ 1, pretty
);
558 fprintf_filtered (stream
, "\n");
559 print_spaces_filtered (2 * recurse
, stream
);
562 fprintf_filtered (stream
, "]");
566 chill_value_print (value_ptr val
, struct ui_file
*stream
, int format
,
567 enum val_prettyprint pretty
)
569 struct type
*type
= VALUE_TYPE (val
);
570 struct type
*real_type
= check_typedef (type
);
572 /* If it is a pointer, indicate what it points to.
574 Print type also if it is a reference. */
576 if (TYPE_CODE (real_type
) == TYPE_CODE_PTR
||
577 TYPE_CODE (real_type
) == TYPE_CODE_REF
)
579 char *valaddr
= VALUE_CONTENTS (val
);
580 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
581 if (TYPE_CODE (type
) != TYPE_CODE_PTR
|| addr
!= 0)
584 char *name
= TYPE_NAME (type
);
586 fputs_filtered (name
, stream
);
587 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
588 fputs_filtered ("PTR", stream
);
591 fprintf_filtered (stream
, "(");
592 type_print (type
, "", stream
, -1);
593 fprintf_filtered (stream
, ")");
595 fprintf_filtered (stream
, "(");
596 i
= val_print (type
, valaddr
, 0, VALUE_ADDRESS (val
),
597 stream
, format
, 1, 0, pretty
);
598 fprintf_filtered (stream
, ")");
602 return (val_print (type
, VALUE_CONTENTS (val
), 0,
603 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
));
This page took 0.042495 seconds and 4 git commands to generate.