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 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_print_options
*options
,
45 /* Print function pointer with inferior address ADDRESS onto stdio
49 print_function_pointer_address (CORE_ADDR address
, struct ui_file
*stream
,
52 CORE_ADDR func_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
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 (address
), stream
);
62 fputs_filtered (": ", stream
);
64 print_address_demangle (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 target
= builtin_type_int32
;
125 if (get_discrete_bounds (range
, &field_low
, &field_high
) >= 0)
127 for (i
= low_bound
; i
<= high_bound
; i
++)
129 bitval
= value_bit_index (TYPE_FIELD_TYPE (type
, field
),
130 (TYPE_FIELD_BITPOS (type
, field
) / 8) +
131 valaddr
+ embedded_offset
, i
);
133 error (_("bit test is out of range"));
140 fprintf_filtered (stream
, ", ");
141 print_type_scalar (target
, i
, stream
);
152 if (previous_low
+1 < previous_high
)
153 fprintf_filtered (stream
, "..");
154 if (previous_low
+1 < previous_high
)
155 print_type_scalar (target
, previous_high
, stream
);
164 range
= TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, field
));
165 if (get_discrete_bounds (range
, &field_low
, &field_high
) < 0)
167 target
= TYPE_TARGET_TYPE (range
);
169 target
= builtin_type_int32
;
174 if (previous_low
+1 < previous_high
)
176 fprintf_filtered (stream
, "..");
177 print_type_scalar (target
, previous_high
, stream
);
181 fprintf_filtered (stream
, "}");
186 m2_print_unbounded_array (struct type
*type
, const gdb_byte
*valaddr
,
187 int embedded_offset
, CORE_ADDR address
,
188 struct ui_file
*stream
, int recurse
,
189 const struct value_print_options
*options
)
191 struct type
*content_type
;
196 CHECK_TYPEDEF (type
);
197 content_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0));
199 addr
= unpack_pointer (TYPE_FIELD_TYPE (type
, 0),
200 (TYPE_FIELD_BITPOS (type
, 0) / 8) +
201 valaddr
+ embedded_offset
);
203 val
= value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0)),
205 len
= unpack_field_as_long (type
, valaddr
+ embedded_offset
, 1);
207 fprintf_filtered (stream
, "{");
208 m2_print_array_contents (value_type (val
), value_contents(val
),
209 value_embedded_offset (val
), addr
, stream
,
210 recurse
, options
, len
);
211 fprintf_filtered (stream
, ", HIGH = %d}", (int) len
);
215 print_unpacked_pointer (struct type
*type
,
216 CORE_ADDR address
, CORE_ADDR addr
,
217 const struct value_print_options
*options
,
218 struct ui_file
*stream
)
220 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
222 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
224 /* Try to print what function it points to. */
225 print_function_pointer_address (addr
, stream
, options
->addressprint
);
226 /* Return value is irrelevant except for string pointers. */
230 if (options
->addressprint
&& options
->format
!= 's')
231 fputs_filtered (paddress (address
), stream
);
233 /* For a pointer to char or unsigned char, also print the string
234 pointed to, unless pointer is null. */
236 if (TYPE_LENGTH (elttype
) == 1
237 && TYPE_CODE (elttype
) == TYPE_CODE_INT
238 && (options
->format
== 0 || options
->format
== 's')
240 return val_print_string (TYPE_TARGET_TYPE (type
), addr
, -1,
247 print_variable_at_address (struct type
*type
,
248 const gdb_byte
*valaddr
,
249 struct ui_file
*stream
,
251 const struct value_print_options
*options
)
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 (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
));
264 common_val_print (deref_val
, stream
, recurse
, options
, current_language
);
267 fputs_filtered ("???", stream
);
271 /* m2_print_array_contents - prints out the contents of an
272 array up to a max_print values.
273 It prints arrays of char as a string
274 and all other data types as comma
278 m2_print_array_contents (struct type
*type
, const gdb_byte
*valaddr
,
279 int embedded_offset
, CORE_ADDR address
,
280 struct ui_file
*stream
, int recurse
,
281 const struct value_print_options
*options
,
285 CHECK_TYPEDEF (type
);
287 if (TYPE_LENGTH (type
) > 0)
289 eltlen
= TYPE_LENGTH (type
);
290 if (options
->prettyprint_arrays
)
291 print_spaces_filtered (2 + 2 * recurse
, stream
);
292 /* For an array of chars, print with string syntax. */
294 ((TYPE_CODE (type
) == TYPE_CODE_INT
)
295 || ((current_language
->la_language
== language_m2
)
296 && (TYPE_CODE (type
) == TYPE_CODE_CHAR
)))
297 && (options
->format
== 0 || options
->format
== 's'))
298 val_print_string (type
, address
, len
+1, stream
, options
);
301 fprintf_filtered (stream
, "{");
302 val_print_array_elements (type
, valaddr
+ embedded_offset
,
303 address
, stream
, recurse
, options
, 0);
304 fprintf_filtered (stream
, "}");
310 /* Print data of type TYPE located at VALADDR (within GDB), which came from
311 the inferior at address ADDRESS, onto stdio stream STREAM according to
312 OPTIONS. The data at VALADDR is in target byte order.
314 If the data are a string pointer, returns the number of string characters
318 m2_val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
319 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
320 const struct value_print_options
*options
)
322 unsigned int i
= 0; /* Number of characters printed */
324 struct type
*elttype
;
326 int length_pos
, length_size
, string_pos
;
331 CHECK_TYPEDEF (type
);
332 switch (TYPE_CODE (type
))
334 case TYPE_CODE_ARRAY
:
335 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
337 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
338 eltlen
= TYPE_LENGTH (elttype
);
339 len
= TYPE_LENGTH (type
) / eltlen
;
340 if (options
->prettyprint_arrays
)
341 print_spaces_filtered (2 + 2 * recurse
, stream
);
342 /* For an array of chars, print with string syntax. */
344 ((TYPE_CODE (elttype
) == TYPE_CODE_INT
)
345 || ((current_language
->la_language
== language_m2
)
346 && (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
)))
347 && (options
->format
== 0 || options
->format
== 's'))
349 /* If requested, look for the first null char and only print
350 elements up to it. */
351 if (options
->stop_print_at_null
)
353 unsigned int temp_len
;
355 /* Look for a NULL char. */
357 (valaddr
+ embedded_offset
)[temp_len
]
358 && temp_len
< len
&& temp_len
< options
->print_max
;
363 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
364 valaddr
+ embedded_offset
, len
, 0,
370 fprintf_filtered (stream
, "{");
371 val_print_array_elements (type
, valaddr
+ embedded_offset
,
372 address
, stream
, recurse
, options
, 0);
373 fprintf_filtered (stream
, "}");
377 /* Array of unspecified length: treat like pointer to first elt. */
378 print_unpacked_pointer (type
, address
, address
, options
, stream
);
382 if (TYPE_CONST (type
))
383 print_variable_at_address (type
, valaddr
+ embedded_offset
,
384 stream
, recurse
, options
);
385 else if (options
->format
&& options
->format
!= 's')
386 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
390 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
391 print_unpacked_pointer (type
, addr
, address
, options
, stream
);
396 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
397 if (options
->addressprint
)
400 = extract_typed_address (valaddr
+ embedded_offset
, type
);
401 fprintf_filtered (stream
, "@");
402 fputs_filtered (paddress (addr
), stream
);
403 if (options
->deref_ref
)
404 fputs_filtered (": ", stream
);
406 /* De-reference the reference. */
407 if (options
->deref_ref
)
409 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
411 struct value
*deref_val
=
413 (TYPE_TARGET_TYPE (type
),
414 unpack_pointer (type
, valaddr
+ embedded_offset
));
415 common_val_print (deref_val
, stream
, recurse
, options
,
419 fputs_filtered ("???", stream
);
423 case TYPE_CODE_UNION
:
424 if (recurse
&& !options
->unionprint
)
426 fprintf_filtered (stream
, "{...}");
430 case TYPE_CODE_STRUCT
:
431 if (m2_is_long_set (type
))
432 m2_print_long_set (type
, valaddr
, embedded_offset
, address
,
434 else if (m2_is_unbounded_array (type
))
435 m2_print_unbounded_array (type
, valaddr
, embedded_offset
,
436 address
, stream
, recurse
, options
);
438 cp_print_value_fields (type
, type
, valaddr
, embedded_offset
,
439 address
, stream
, recurse
, options
, NULL
, 0);
445 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
449 len
= TYPE_NFIELDS (type
);
450 val
= unpack_long (type
, valaddr
+ embedded_offset
);
451 for (i
= 0; i
< len
; i
++)
454 if (val
== TYPE_FIELD_BITPOS (type
, i
))
461 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
465 print_longest (stream
, 'd', 0, val
);
472 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
476 /* FIXME, we should consider, at least for ANSI C language, eliminating
477 the distinction made between FUNCs and POINTERs to FUNCs. */
478 fprintf_filtered (stream
, "{");
479 type_print (type
, "", stream
, -1);
480 fprintf_filtered (stream
, "} ");
481 /* Try to print what function it points to, and its address. */
482 print_address_demangle (address
, stream
, demangle
);
486 if (options
->format
|| options
->output_format
)
488 struct value_print_options opts
= *options
;
489 opts
.format
= (options
->format
? options
->format
490 : options
->output_format
);
491 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
496 val
= unpack_long (type
, valaddr
+ embedded_offset
);
498 fputs_filtered ("FALSE", stream
);
500 fputs_filtered ("TRUE", stream
);
502 fprintf_filtered (stream
, "%ld)", (long int) val
);
506 case TYPE_CODE_RANGE
:
507 if (TYPE_LENGTH (type
) == TYPE_LENGTH (TYPE_TARGET_TYPE (type
)))
509 m2_val_print (TYPE_TARGET_TYPE (type
), valaddr
, embedded_offset
,
510 address
, stream
, recurse
, options
);
513 /* FIXME: create_range_type does not set the unsigned bit in a
514 range type (I think it probably should copy it from the target
515 type), so we won't print values which are too large to
516 fit in a signed integer correctly. */
517 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
518 print with the target type, though, because the size of our type
519 and the target type might differ). */
523 if (options
->format
|| options
->output_format
)
525 struct value_print_options opts
= *options
;
526 opts
.format
= (options
->format
? options
->format
527 : options
->output_format
);
528 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
532 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
536 if (options
->format
|| options
->output_format
)
538 struct value_print_options opts
= *options
;
539 opts
.format
= (options
->format
? options
->format
540 : options
->output_format
);
541 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
546 val
= unpack_long (type
, valaddr
+ embedded_offset
);
547 if (TYPE_UNSIGNED (type
))
548 fprintf_filtered (stream
, "%u", (unsigned int) val
);
550 fprintf_filtered (stream
, "%d", (int) val
);
551 fputs_filtered (" ", stream
);
552 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
558 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
561 print_floating (valaddr
+ embedded_offset
, type
, stream
);
564 case TYPE_CODE_METHOD
:
567 case TYPE_CODE_BITSTRING
:
569 elttype
= TYPE_INDEX_TYPE (type
);
570 CHECK_TYPEDEF (elttype
);
571 if (TYPE_STUB (elttype
))
573 fprintf_filtered (stream
, _("<incomplete type>"));
579 struct type
*range
= elttype
;
580 LONGEST low_bound
, high_bound
;
582 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
586 fputs_filtered ("B'", stream
);
588 fputs_filtered ("{", stream
);
590 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
594 fputs_filtered (_("<error value>"), stream
);
598 for (i
= low_bound
; i
<= high_bound
; i
++)
600 int element
= value_bit_index (type
, valaddr
+ embedded_offset
,
605 goto maybe_bad_bstring
;
608 fprintf_filtered (stream
, "%d", element
);
612 fputs_filtered (", ", stream
);
613 print_type_scalar (range
, i
, stream
);
616 if (i
+ 1 <= high_bound
617 && value_bit_index (type
, valaddr
+ embedded_offset
,
621 fputs_filtered ("..", stream
);
622 while (i
+ 1 <= high_bound
623 && value_bit_index (type
,
624 valaddr
+ embedded_offset
,
627 print_type_scalar (range
, j
, stream
);
633 fputs_filtered ("'", stream
);
635 fputs_filtered ("}", stream
);
640 fprintf_filtered (stream
, "void");
643 case TYPE_CODE_ERROR
:
644 fprintf_filtered (stream
, _("<error type>"));
647 case TYPE_CODE_UNDEF
:
648 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
649 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
650 and no complete type for struct foo in that file. */
651 fprintf_filtered (stream
, _("<incomplete type>"));
655 error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type
));
This page took 0.042619 seconds and 4 git commands to generate.