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 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
50 struct ui_file
*stream
, int addressprint
)
52 CORE_ADDR func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
55 /* If the function pointer is represented by a description, print the
56 address of the description. */
57 if (addressprint
&& func_addr
!= address
)
59 fputs_filtered ("@", stream
);
60 fputs_filtered (paddress (gdbarch
, address
), stream
);
61 fputs_filtered (": ", stream
);
63 print_address_demangle (gdbarch
, func_addr
, stream
, demangle
);
66 /* get_long_set_bounds - assigns the bounds of the long set to low and
70 get_long_set_bounds (struct type
*type
, LONGEST
*low
, LONGEST
*high
)
74 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
76 len
= TYPE_NFIELDS (type
);
77 i
= TYPE_N_BASECLASSES (type
);
80 *low
= TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, i
)));
81 *high
= TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
,
85 error (_("expecting long_set"));
90 m2_print_long_set (struct type
*type
, const gdb_byte
*valaddr
,
91 int embedded_offset
, CORE_ADDR address
,
92 struct ui_file
*stream
)
96 LONGEST previous_low
= 0;
97 LONGEST previous_high
= 0;
98 LONGEST i
, low_bound
, high_bound
;
99 LONGEST field_low
, field_high
;
105 CHECK_TYPEDEF (type
);
107 fprintf_filtered (stream
, "{");
108 len
= TYPE_NFIELDS (type
);
109 if (get_long_set_bounds (type
, &low_bound
, &high_bound
))
111 field
= TYPE_N_BASECLASSES (type
);
112 range
= TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, field
));
116 fprintf_filtered (stream
, " %s }", _("<unknown bounds of set>"));
120 target
= TYPE_TARGET_TYPE (range
);
122 if (get_discrete_bounds (range
, &field_low
, &field_high
) >= 0)
124 for (i
= low_bound
; i
<= high_bound
; i
++)
126 bitval
= value_bit_index (TYPE_FIELD_TYPE (type
, field
),
127 (TYPE_FIELD_BITPOS (type
, field
) / 8) +
128 valaddr
+ embedded_offset
, i
);
130 error (_("bit test is out of range"));
137 fprintf_filtered (stream
, ", ");
138 print_type_scalar (target
, i
, stream
);
149 if (previous_low
+1 < previous_high
)
150 fprintf_filtered (stream
, "..");
151 if (previous_low
+1 < previous_high
)
152 print_type_scalar (target
, previous_high
, stream
);
161 range
= TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type
, field
));
162 if (get_discrete_bounds (range
, &field_low
, &field_high
) < 0)
164 target
= TYPE_TARGET_TYPE (range
);
169 if (previous_low
+1 < previous_high
)
171 fprintf_filtered (stream
, "..");
172 print_type_scalar (target
, previous_high
, stream
);
176 fprintf_filtered (stream
, "}");
181 m2_print_unbounded_array (struct type
*type
, const gdb_byte
*valaddr
,
182 int embedded_offset
, CORE_ADDR address
,
183 struct ui_file
*stream
, int recurse
,
184 const struct value_print_options
*options
)
186 struct type
*content_type
;
191 CHECK_TYPEDEF (type
);
192 content_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0));
194 addr
= unpack_pointer (TYPE_FIELD_TYPE (type
, 0),
195 (TYPE_FIELD_BITPOS (type
, 0) / 8) +
196 valaddr
+ embedded_offset
);
198 val
= value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
, 0)),
200 len
= unpack_field_as_long (type
, valaddr
+ embedded_offset
, 1);
202 fprintf_filtered (stream
, "{");
203 m2_print_array_contents (value_type (val
), value_contents(val
),
204 value_embedded_offset (val
), addr
, stream
,
205 recurse
, options
, len
);
206 fprintf_filtered (stream
, ", HIGH = %d}", (int) len
);
210 print_unpacked_pointer (struct type
*type
,
211 CORE_ADDR address
, CORE_ADDR addr
,
212 const struct value_print_options
*options
,
213 struct ui_file
*stream
)
215 struct gdbarch
*gdbarch
= get_type_arch (type
);
216 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
218 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
220 /* Try to print what function it points to. */
221 print_function_pointer_address (gdbarch
, addr
, stream
,
222 options
->addressprint
);
223 /* Return value is irrelevant except for string pointers. */
227 if (options
->addressprint
&& options
->format
!= 's')
228 fputs_filtered (paddress (gdbarch
, address
), stream
);
230 /* For a pointer to char or unsigned char, also print the string
231 pointed to, unless pointer is null. */
233 if (TYPE_LENGTH (elttype
) == 1
234 && TYPE_CODE (elttype
) == TYPE_CODE_INT
235 && (options
->format
== 0 || options
->format
== 's')
237 return val_print_string (TYPE_TARGET_TYPE (type
), addr
, -1,
244 print_variable_at_address (struct type
*type
,
245 const gdb_byte
*valaddr
,
246 struct ui_file
*stream
,
248 const struct value_print_options
*options
)
250 struct gdbarch
*gdbarch
= get_type_arch (type
);
251 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
252 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
254 fprintf_filtered (stream
, "[");
255 fputs_filtered (paddress (gdbarch
, addr
), stream
);
256 fprintf_filtered (stream
, "] : ");
258 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
260 struct value
*deref_val
=
261 value_at (TYPE_TARGET_TYPE (type
), unpack_pointer (type
, valaddr
));
262 common_val_print (deref_val
, stream
, recurse
, options
, current_language
);
265 fputs_filtered ("???", stream
);
269 /* m2_print_array_contents - prints out the contents of an
270 array up to a max_print values.
271 It prints arrays of char as a string
272 and all other data types as comma
276 m2_print_array_contents (struct type
*type
, const gdb_byte
*valaddr
,
277 int embedded_offset
, CORE_ADDR address
,
278 struct ui_file
*stream
, int recurse
,
279 const struct value_print_options
*options
,
283 CHECK_TYPEDEF (type
);
285 if (TYPE_LENGTH (type
) > 0)
287 eltlen
= TYPE_LENGTH (type
);
288 if (options
->prettyprint_arrays
)
289 print_spaces_filtered (2 + 2 * recurse
, stream
);
290 /* For an array of chars, print with string syntax. */
292 ((TYPE_CODE (type
) == TYPE_CODE_INT
)
293 || ((current_language
->la_language
== language_m2
)
294 && (TYPE_CODE (type
) == TYPE_CODE_CHAR
)))
295 && (options
->format
== 0 || options
->format
== 's'))
296 val_print_string (type
, address
, len
+1, stream
, options
);
299 fprintf_filtered (stream
, "{");
300 val_print_array_elements (type
, valaddr
+ embedded_offset
,
301 address
, stream
, recurse
, options
, 0);
302 fprintf_filtered (stream
, "}");
308 /* Print data of type TYPE located at VALADDR (within GDB), which came from
309 the inferior at address ADDRESS, onto stdio stream STREAM according to
310 OPTIONS. The data at VALADDR is in target byte order.
312 If the data are a string pointer, returns the number of string characters
316 m2_val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
317 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
318 const struct value_print_options
*options
)
320 struct gdbarch
*gdbarch
= get_type_arch (type
);
321 unsigned int i
= 0; /* Number of characters printed */
323 struct type
*elttype
;
325 int length_pos
, length_size
, string_pos
;
330 CHECK_TYPEDEF (type
);
331 switch (TYPE_CODE (type
))
333 case TYPE_CODE_ARRAY
:
334 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
336 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
337 eltlen
= TYPE_LENGTH (elttype
);
338 len
= TYPE_LENGTH (type
) / eltlen
;
339 if (options
->prettyprint_arrays
)
340 print_spaces_filtered (2 + 2 * recurse
, stream
);
341 /* For an array of chars, print with string syntax. */
343 ((TYPE_CODE (elttype
) == TYPE_CODE_INT
)
344 || ((current_language
->la_language
== language_m2
)
345 && (TYPE_CODE (elttype
) == TYPE_CODE_CHAR
)))
346 && (options
->format
== 0 || options
->format
== 's'))
348 /* If requested, look for the first null char and only print
349 elements up to it. */
350 if (options
->stop_print_at_null
)
352 unsigned int temp_len
;
354 /* Look for a NULL char. */
356 (valaddr
+ embedded_offset
)[temp_len
]
357 && temp_len
< len
&& temp_len
< options
->print_max
;
362 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
363 valaddr
+ embedded_offset
, len
, 0,
369 fprintf_filtered (stream
, "{");
370 val_print_array_elements (type
, valaddr
+ embedded_offset
,
371 address
, stream
, recurse
, options
, 0);
372 fprintf_filtered (stream
, "}");
376 /* Array of unspecified length: treat like pointer to first elt. */
377 print_unpacked_pointer (type
, address
, address
, options
, stream
);
381 if (TYPE_CONST (type
))
382 print_variable_at_address (type
, valaddr
+ embedded_offset
,
383 stream
, recurse
, options
);
384 else if (options
->format
&& options
->format
!= 's')
385 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
389 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
390 print_unpacked_pointer (type
, addr
, address
, options
, stream
);
395 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
396 if (options
->addressprint
)
399 = extract_typed_address (valaddr
+ embedded_offset
, type
);
400 fprintf_filtered (stream
, "@");
401 fputs_filtered (paddress (gdbarch
, addr
), stream
);
402 if (options
->deref_ref
)
403 fputs_filtered (": ", stream
);
405 /* De-reference the reference. */
406 if (options
->deref_ref
)
408 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
410 struct value
*deref_val
=
412 (TYPE_TARGET_TYPE (type
),
413 unpack_pointer (type
, valaddr
+ embedded_offset
));
414 common_val_print (deref_val
, stream
, recurse
, options
,
418 fputs_filtered ("???", stream
);
422 case TYPE_CODE_UNION
:
423 if (recurse
&& !options
->unionprint
)
425 fprintf_filtered (stream
, "{...}");
429 case TYPE_CODE_STRUCT
:
430 if (m2_is_long_set (type
))
431 m2_print_long_set (type
, valaddr
, embedded_offset
, address
,
433 else if (m2_is_unbounded_array (type
))
434 m2_print_unbounded_array (type
, valaddr
, embedded_offset
,
435 address
, stream
, recurse
, options
);
437 cp_print_value_fields (type
, type
, valaddr
, embedded_offset
,
438 address
, stream
, recurse
, options
, NULL
, 0);
444 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
448 len
= TYPE_NFIELDS (type
);
449 val
= unpack_long (type
, valaddr
+ embedded_offset
);
450 for (i
= 0; i
< len
; i
++)
453 if (val
== TYPE_FIELD_BITPOS (type
, i
))
460 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
464 print_longest (stream
, 'd', 0, val
);
471 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
475 /* FIXME, we should consider, at least for ANSI C language, eliminating
476 the distinction made between FUNCs and POINTERs to FUNCs. */
477 fprintf_filtered (stream
, "{");
478 type_print (type
, "", stream
, -1);
479 fprintf_filtered (stream
, "} ");
480 /* Try to print what function it points to, and its address. */
481 print_address_demangle (gdbarch
, address
, stream
, demangle
);
485 if (options
->format
|| options
->output_format
)
487 struct value_print_options opts
= *options
;
488 opts
.format
= (options
->format
? options
->format
489 : options
->output_format
);
490 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
495 val
= unpack_long (type
, valaddr
+ embedded_offset
);
497 fputs_filtered ("FALSE", stream
);
499 fputs_filtered ("TRUE", stream
);
501 fprintf_filtered (stream
, "%ld)", (long int) val
);
505 case TYPE_CODE_RANGE
:
506 if (TYPE_LENGTH (type
) == TYPE_LENGTH (TYPE_TARGET_TYPE (type
)))
508 m2_val_print (TYPE_TARGET_TYPE (type
), valaddr
, embedded_offset
,
509 address
, stream
, recurse
, options
);
512 /* FIXME: create_range_type does not set the unsigned bit in a
513 range type (I think it probably should copy it from the target
514 type), so we won't print values which are too large to
515 fit in a signed integer correctly. */
516 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
517 print with the target type, though, because the size of our type
518 and the target type might differ). */
522 if (options
->format
|| options
->output_format
)
524 struct value_print_options opts
= *options
;
525 opts
.format
= (options
->format
? options
->format
526 : options
->output_format
);
527 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
531 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
535 if (options
->format
|| options
->output_format
)
537 struct value_print_options opts
= *options
;
538 opts
.format
= (options
->format
? options
->format
539 : options
->output_format
);
540 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
545 val
= unpack_long (type
, valaddr
+ embedded_offset
);
546 if (TYPE_UNSIGNED (type
))
547 fprintf_filtered (stream
, "%u", (unsigned int) val
);
549 fprintf_filtered (stream
, "%d", (int) val
);
550 fputs_filtered (" ", stream
);
551 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
557 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
560 print_floating (valaddr
+ embedded_offset
, type
, stream
);
563 case TYPE_CODE_METHOD
:
566 case TYPE_CODE_BITSTRING
:
568 elttype
= TYPE_INDEX_TYPE (type
);
569 CHECK_TYPEDEF (elttype
);
570 if (TYPE_STUB (elttype
))
572 fprintf_filtered (stream
, _("<incomplete type>"));
578 struct type
*range
= elttype
;
579 LONGEST low_bound
, high_bound
;
581 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
585 fputs_filtered ("B'", stream
);
587 fputs_filtered ("{", stream
);
589 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
593 fputs_filtered (_("<error value>"), stream
);
597 for (i
= low_bound
; i
<= high_bound
; i
++)
599 int element
= value_bit_index (type
, valaddr
+ embedded_offset
,
604 goto maybe_bad_bstring
;
607 fprintf_filtered (stream
, "%d", element
);
611 fputs_filtered (", ", stream
);
612 print_type_scalar (range
, i
, stream
);
615 if (i
+ 1 <= high_bound
616 && value_bit_index (type
, valaddr
+ embedded_offset
,
620 fputs_filtered ("..", stream
);
621 while (i
+ 1 <= high_bound
622 && value_bit_index (type
,
623 valaddr
+ embedded_offset
,
626 print_type_scalar (range
, j
, stream
);
632 fputs_filtered ("'", stream
);
634 fputs_filtered ("}", stream
);
639 fprintf_filtered (stream
, "void");
642 case TYPE_CODE_ERROR
:
643 fprintf_filtered (stream
, _("<error type>"));
646 case TYPE_CODE_UNDEF
:
647 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
648 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
649 and no complete type for struct foo in that file. */
650 fprintf_filtered (stream
, _("<incomplete type>"));
654 error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type
));
This page took 0.043277 seconds and 4 git commands to generate.