1 /* Support for printing Modula 2 values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006,
4 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
28 #include "typeprint.h"
33 static int print_unpacked_pointer (struct type
*type
,
34 CORE_ADDR address
, CORE_ADDR addr
,
35 const struct value_print_options
*options
,
36 struct ui_file
*stream
);
38 m2_print_array_contents (struct type
*type
, const gdb_byte
*valaddr
,
39 int embedded_offset
, CORE_ADDR address
,
40 struct ui_file
*stream
, int recurse
,
41 const struct value
*val
,
42 const struct value_print_options
*options
,
46 /* Print function pointer with inferior address ADDRESS onto stdio
50 print_function_pointer_address (struct gdbarch
*gdbarch
, CORE_ADDR address
,
51 struct ui_file
*stream
, int addressprint
)
53 CORE_ADDR func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
56 /* If the function pointer is represented by a description, print the
57 address of the description. */
58 if (addressprint
&& func_addr
!= address
)
60 fputs_filtered ("@", stream
);
61 fputs_filtered (paddress (gdbarch
, address
), stream
);
62 fputs_filtered (": ", stream
);
64 print_address_demangle (gdbarch
, func_addr
, stream
, demangle
);
67 /* get_long_set_bounds - assigns the bounds of the long set to low and
71 get_long_set_bounds (struct type
*type
, LONGEST
*low
, LONGEST
*high
)
75 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
77 len
= TYPE_NFIELDS (type
);
78 i
= TYPE_N_BASECLASSES (type
);
81 *low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, i
)));
82 *high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
,
86 error (_("expecting long_set"));
91 m2_print_long_set (struct type
*type
, const gdb_byte
*valaddr
,
92 int embedded_offset
, CORE_ADDR address
,
93 struct ui_file
*stream
)
97 LONGEST previous_low
= 0;
98 LONGEST previous_high
= 0;
99 LONGEST i
, low_bound
, high_bound
;
100 LONGEST field_low
, field_high
;
106 CHECK_TYPEDEF (type
);
108 fprintf_filtered (stream
, "{");
109 len
= TYPE_NFIELDS (type
);
110 if (get_long_set_bounds (type
, &low_bound
, &high_bound
))
112 field
= TYPE_N_BASECLASSES (type
);
113 range
= TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, field
));
117 fprintf_filtered (stream
, " %s }", _("<unknown bounds of set>"));
121 target
= TYPE_TARGET_TYPE (range
);
123 if (get_discrete_bounds (range
, &field_low
, &field_high
) >= 0)
125 for (i
= low_bound
; i
<= high_bound
; i
++)
127 bitval
= value_bit_index (TYPE_FIELD_TYPE (type
, field
),
128 (TYPE_FIELD_BITPOS (type
, field
) / 8) +
129 valaddr
+ embedded_offset
, i
);
131 error (_("bit test is out of range"));
138 fprintf_filtered (stream
, ", ");
139 print_type_scalar (target
, i
, stream
);
150 if (previous_low
+1 < previous_high
)
151 fprintf_filtered (stream
, "..");
152 if (previous_low
+1 < previous_high
)
153 print_type_scalar (target
, previous_high
, stream
);
162 range
= TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, field
));
163 if (get_discrete_bounds (range
, &field_low
, &field_high
) < 0)
165 target
= TYPE_TARGET_TYPE (range
);
170 if (previous_low
+1 < previous_high
)
172 fprintf_filtered (stream
, "..");
173 print_type_scalar (target
, previous_high
, stream
);
177 fprintf_filtered (stream
, "}");
182 m2_print_unbounded_array (struct type
*type
, const gdb_byte
*valaddr
,
183 int embedded_offset
, CORE_ADDR address
,
184 struct ui_file
*stream
, int recurse
,
185 const struct value_print_options
*options
)
187 struct type
*content_type
;
192 CHECK_TYPEDEF (type
);
193 content_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0));
195 addr
= unpack_pointer (TYPE_FIELD_TYPE (type
, 0),
196 (TYPE_FIELD_BITPOS (type
, 0) / 8) +
197 valaddr
+ embedded_offset
);
199 val
= value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0)),
201 len
= unpack_field_as_long (type
, valaddr
+ embedded_offset
, 1);
203 fprintf_filtered (stream
, "{");
204 m2_print_array_contents (value_type (val
),
205 value_contents_for_printing (val
),
206 value_embedded_offset (val
), addr
, stream
,
207 recurse
, val
, options
, len
);
208 fprintf_filtered (stream
, ", HIGH = %d}", (int) len
);
212 print_unpacked_pointer (struct type
*type
,
213 CORE_ADDR address
, CORE_ADDR addr
,
214 const struct value_print_options
*options
,
215 struct ui_file
*stream
)
217 struct gdbarch
*gdbarch
= get_type_arch (type
);
218 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
220 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
222 /* Try to print what function it points to. */
223 print_function_pointer_address (gdbarch
, addr
, stream
,
224 options
->addressprint
);
225 /* Return value is irrelevant except for string pointers. */
229 if (options
->addressprint
&& options
->format
!= 's')
230 fputs_filtered (paddress (gdbarch
, address
), stream
);
232 /* For a pointer to char or unsigned char, also print the string
233 pointed to, unless pointer is null. */
235 if (TYPE_LENGTH (elttype
) == 1
236 && TYPE_CODE (elttype
) == TYPE_CODE_INT
237 && (options
->format
== 0 || options
->format
== 's')
239 return val_print_string (TYPE_TARGET_TYPE (type
), NULL
, addr
, -1,
246 print_variable_at_address (struct type
*type
,
247 const gdb_byte
*valaddr
,
248 struct ui_file
*stream
,
250 const struct value_print_options
*options
)
252 struct gdbarch
*gdbarch
= get_type_arch (type
);
253 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
254 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
256 fprintf_filtered (stream
, "[");
257 fputs_filtered (paddress (gdbarch
, addr
), stream
);
258 fprintf_filtered (stream
, "] : ");
260 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
262 struct value
*deref_val
=
263 value_at (TYPE_TARGET_TYPE (type
), unpack_pointer (type
, valaddr
));
265 common_val_print (deref_val
, stream
, recurse
, options
, current_language
);
268 fputs_filtered ("???", stream
);
272 /* m2_print_array_contents - prints out the contents of an
273 array up to a max_print values.
274 It prints arrays of char as a string
275 and all other data types as comma
279 m2_print_array_contents (struct type
*type
, const gdb_byte
*valaddr
,
280 int embedded_offset
, CORE_ADDR address
,
281 struct ui_file
*stream
, int recurse
,
282 const struct value
*val
,
283 const struct value_print_options
*options
,
287 CHECK_TYPEDEF (type
);
289 if (TYPE_LENGTH (type
) > 0)
291 eltlen
= TYPE_LENGTH (type
);
292 if (options
->prettyprint_arrays
)
293 print_spaces_filtered (2 + 2 * recurse
, stream
);
294 /* For an array of chars, print with string syntax. */
296 ((TYPE_CODE (type
) == TYPE_CODE_INT
)
297 || ((current_language
->la_language
== language_m2
)
298 && (TYPE_CODE (type
) == TYPE_CODE_CHAR
)))
299 && (options
->format
== 0 || options
->format
== 's'))
300 val_print_string (type
, NULL
, address
, len
+1, stream
, options
);
303 fprintf_filtered (stream
, "{");
304 val_print_array_elements (type
, valaddr
, embedded_offset
,
305 address
, stream
, recurse
, val
,
307 fprintf_filtered (stream
, "}");
313 /* Print data of type TYPE located at VALADDR (within GDB), which came from
314 the inferior at address ADDRESS, onto stdio stream STREAM according to
315 OPTIONS. The data at VALADDR is in target byte order.
317 If the data are a string pointer, returns the number of string characters
321 m2_val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
322 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
323 const struct value
*original_value
,
324 const struct value_print_options
*options
)
326 struct gdbarch
*gdbarch
= get_type_arch (type
);
327 unsigned int i
= 0; /* Number of characters printed. */
329 struct type
*elttype
;
334 CHECK_TYPEDEF (type
);
335 switch (TYPE_CODE (type
))
337 case TYPE_CODE_ARRAY
:
338 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
340 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
341 eltlen
= TYPE_LENGTH (elttype
);
342 len
= TYPE_LENGTH (type
) / eltlen
;
343 if (options
->prettyprint_arrays
)
344 print_spaces_filtered (2 + 2 * recurse
, stream
);
345 /* For an array of chars, print with string syntax. */
347 ((TYPE_CODE (elttype
) == TYPE_CODE_INT
)
348 || ((current_language
->la_language
== language_m2
)
349 && (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
)))
350 && (options
->format
== 0 || options
->format
== 's'))
352 /* If requested, look for the first null char and only print
353 elements up to it. */
354 if (options
->stop_print_at_null
)
356 unsigned int temp_len
;
358 /* Look for a NULL char. */
360 (valaddr
+ embedded_offset
)[temp_len
]
361 && temp_len
< len
&& temp_len
< options
->print_max
;
366 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
367 valaddr
+ embedded_offset
, len
, NULL
,
373 fprintf_filtered (stream
, "{");
374 val_print_array_elements (type
, valaddr
, embedded_offset
,
376 recurse
, original_value
,
378 fprintf_filtered (stream
, "}");
382 /* Array of unspecified length: treat like pointer to first elt. */
383 print_unpacked_pointer (type
, address
, address
, options
, stream
);
387 if (TYPE_CONST (type
))
388 print_variable_at_address (type
, valaddr
+ embedded_offset
,
389 stream
, recurse
, options
);
390 else if (options
->format
&& options
->format
!= 's')
391 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
395 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
396 print_unpacked_pointer (type
, addr
, address
, options
, stream
);
401 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
402 if (options
->addressprint
)
405 = extract_typed_address (valaddr
+ embedded_offset
, type
);
407 fprintf_filtered (stream
, "@");
408 fputs_filtered (paddress (gdbarch
, addr
), stream
);
409 if (options
->deref_ref
)
410 fputs_filtered (": ", stream
);
412 /* De-reference the reference. */
413 if (options
->deref_ref
)
415 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
417 struct value
*deref_val
=
419 (TYPE_TARGET_TYPE (type
),
420 unpack_pointer (type
, valaddr
+ embedded_offset
));
422 common_val_print (deref_val
, stream
, recurse
, options
,
426 fputs_filtered ("???", stream
);
430 case TYPE_CODE_UNION
:
431 if (recurse
&& !options
->unionprint
)
433 fprintf_filtered (stream
, "{...}");
437 case TYPE_CODE_STRUCT
:
438 if (m2_is_long_set (type
))
439 m2_print_long_set (type
, valaddr
, embedded_offset
, address
,
441 else if (m2_is_unbounded_array (type
))
442 m2_print_unbounded_array (type
, valaddr
, embedded_offset
,
443 address
, stream
, recurse
, options
);
445 cp_print_value_fields (type
, type
, valaddr
, embedded_offset
,
446 address
, stream
, recurse
, original_value
,
453 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
457 len
= TYPE_NFIELDS (type
);
458 val
= unpack_long (type
, valaddr
+ embedded_offset
);
459 for (i
= 0; i
< len
; i
++)
462 if (val
== TYPE_FIELD_BITPOS (type
, i
))
469 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
473 print_longest (stream
, 'd', 0, val
);
480 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
484 /* FIXME, we should consider, at least for ANSI C language, eliminating
485 the distinction made between FUNCs and POINTERs to FUNCs. */
486 fprintf_filtered (stream
, "{");
487 type_print (type
, "", stream
, -1);
488 fprintf_filtered (stream
, "} ");
489 /* Try to print what function it points to, and its address. */
490 print_address_demangle (gdbarch
, address
, stream
, demangle
);
494 if (options
->format
|| options
->output_format
)
496 struct value_print_options opts
= *options
;
498 opts
.format
= (options
->format
? options
->format
499 : options
->output_format
);
500 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
505 val
= unpack_long (type
, valaddr
+ embedded_offset
);
507 fputs_filtered ("FALSE", stream
);
509 fputs_filtered ("TRUE", stream
);
511 fprintf_filtered (stream
, "%ld)", (long int) val
);
515 case TYPE_CODE_RANGE
:
516 if (TYPE_LENGTH (type
) == TYPE_LENGTH (TYPE_TARGET_TYPE (type
)))
518 m2_val_print (TYPE_TARGET_TYPE (type
), valaddr
, embedded_offset
,
519 address
, stream
, recurse
, original_value
, options
);
522 /* FIXME: create_range_type does not set the unsigned bit in a
523 range type (I think it probably should copy it from the target
524 type), so we won't print values which are too large to
525 fit in a signed integer correctly. */
526 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
527 print with the target type, though, because the size of our type
528 and the target type might differ). */
532 if (options
->format
|| options
->output_format
)
534 struct value_print_options opts
= *options
;
536 opts
.format
= (options
->format
? options
->format
537 : options
->output_format
);
538 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
542 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
546 if (options
->format
|| options
->output_format
)
548 struct value_print_options opts
= *options
;
550 opts
.format
= (options
->format
? options
->format
551 : options
->output_format
);
552 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
557 val
= unpack_long (type
, valaddr
+ embedded_offset
);
558 if (TYPE_UNSIGNED (type
))
559 fprintf_filtered (stream
, "%u", (unsigned int) val
);
561 fprintf_filtered (stream
, "%d", (int) val
);
562 fputs_filtered (" ", stream
);
563 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
569 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
572 print_floating (valaddr
+ embedded_offset
, type
, stream
);
575 case TYPE_CODE_METHOD
:
578 case TYPE_CODE_BITSTRING
:
580 elttype
= TYPE_INDEX_TYPE (type
);
581 CHECK_TYPEDEF (elttype
);
582 if (TYPE_STUB (elttype
))
584 fprintf_filtered (stream
, _("<incomplete type>"));
590 struct type
*range
= elttype
;
591 LONGEST low_bound
, high_bound
;
593 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
597 fputs_filtered ("B'", stream
);
599 fputs_filtered ("{", stream
);
601 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
605 fputs_filtered (_("<error value>"), stream
);
609 for (i
= low_bound
; i
<= high_bound
; i
++)
611 int element
= value_bit_index (type
, valaddr
+ embedded_offset
,
617 goto maybe_bad_bstring
;
620 fprintf_filtered (stream
, "%d", element
);
624 fputs_filtered (", ", stream
);
625 print_type_scalar (range
, i
, stream
);
628 if (i
+ 1 <= high_bound
629 && value_bit_index (type
, valaddr
+ embedded_offset
,
634 fputs_filtered ("..", stream
);
635 while (i
+ 1 <= high_bound
636 && value_bit_index (type
,
637 valaddr
+ embedded_offset
,
640 print_type_scalar (range
, j
, stream
);
646 fputs_filtered ("'", stream
);
648 fputs_filtered ("}", stream
);
653 fprintf_filtered (stream
, "void");
656 case TYPE_CODE_ERROR
:
657 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
660 case TYPE_CODE_UNDEF
:
661 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
662 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
663 and no complete type for struct foo in that file. */
664 fprintf_filtered (stream
, _("<incomplete type>"));
668 error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type
));
This page took 0.051336 seconds and 5 git commands to generate.