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 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), value_contents(val),
205 value_embedded_offset (val), addr, stream,
206 recurse, options, len);
207 fprintf_filtered (stream, ", HIGH = %d}", (int) len);
211 print_unpacked_pointer (struct type *type,
212 CORE_ADDR address, CORE_ADDR addr,
213 const struct value_print_options *options,
214 struct ui_file *stream)
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 (addr, stream, options->addressprint);
222 /* Return value is irrelevant except for string pointers. */
226 if (options->addressprint && options->format != 's')
227 fputs_filtered (paddress (address), stream);
229 /* For a pointer to char or unsigned char, also print the string
230 pointed to, unless pointer is null. */
232 if (TYPE_LENGTH (elttype) == 1
233 && TYPE_CODE (elttype) == TYPE_CODE_INT
234 && (options->format == 0 || options->format == 's')
236 return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
243 print_variable_at_address (struct type *type,
244 const gdb_byte *valaddr,
245 struct ui_file *stream,
247 const struct value_print_options *options)
249 CORE_ADDR addr = unpack_pointer (type, valaddr);
250 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
252 fprintf_filtered (stream, "[");
253 fputs_filtered (paddress (addr), stream);
254 fprintf_filtered (stream, "] : ");
256 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
258 struct value *deref_val =
259 value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
260 common_val_print (deref_val, stream, recurse, options, current_language);
263 fputs_filtered ("???", stream);
267 /* m2_print_array_contents - prints out the contents of an
268 array up to a max_print values.
269 It prints arrays of char as a string
270 and all other data types as comma
274 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
275 int embedded_offset, CORE_ADDR address,
276 struct ui_file *stream, int recurse,
277 const struct value_print_options *options,
281 CHECK_TYPEDEF (type);
283 if (TYPE_LENGTH (type) > 0)
285 eltlen = TYPE_LENGTH (type);
286 if (options->prettyprint_arrays)
287 print_spaces_filtered (2 + 2 * recurse, stream);
288 /* For an array of chars, print with string syntax. */
290 ((TYPE_CODE (type) == TYPE_CODE_INT)
291 || ((current_language->la_language == language_m2)
292 && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
293 && (options->format == 0 || options->format == 's'))
294 val_print_string (type, address, len+1, stream, options);
297 fprintf_filtered (stream, "{");
298 val_print_array_elements (type, valaddr + embedded_offset,
299 address, stream, recurse, options, 0);
300 fprintf_filtered (stream, "}");
306 /* Print data of type TYPE located at VALADDR (within GDB), which came from
307 the inferior at address ADDRESS, onto stdio stream STREAM according to
308 OPTIONS. The data at VALADDR is in target byte order.
310 If the data are a string pointer, returns the number of string characters
314 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
315 CORE_ADDR address, struct ui_file *stream, int recurse,
316 const struct value_print_options *options)
318 unsigned int i = 0; /* Number of characters printed */
320 struct type *elttype;
322 int length_pos, length_size, string_pos;
327 CHECK_TYPEDEF (type);
328 switch (TYPE_CODE (type))
330 case TYPE_CODE_ARRAY:
331 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
333 elttype = check_typedef (TYPE_TARGET_TYPE (type));
334 eltlen = TYPE_LENGTH (elttype);
335 len = TYPE_LENGTH (type) / eltlen;
336 if (options->prettyprint_arrays)
337 print_spaces_filtered (2 + 2 * recurse, stream);
338 /* For an array of chars, print with string syntax. */
340 ((TYPE_CODE (elttype) == TYPE_CODE_INT)
341 || ((current_language->la_language == language_m2)
342 && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
343 && (options->format == 0 || options->format == 's'))
345 /* If requested, look for the first null char and only print
346 elements up to it. */
347 if (options->stop_print_at_null)
349 unsigned int temp_len;
351 /* Look for a NULL char. */
353 (valaddr + embedded_offset)[temp_len]
354 && temp_len < len && temp_len < options->print_max;
359 LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
360 valaddr + embedded_offset, len, 0,
366 fprintf_filtered (stream, "{");
367 val_print_array_elements (type, valaddr + embedded_offset,
368 address, stream, recurse, options, 0);
369 fprintf_filtered (stream, "}");
373 /* Array of unspecified length: treat like pointer to first elt. */
374 print_unpacked_pointer (type, address, address, options, stream);
378 if (TYPE_CONST (type))
379 print_variable_at_address (type, valaddr + embedded_offset,
380 stream, recurse, options);
381 else if (options->format && options->format != 's')
382 print_scalar_formatted (valaddr + embedded_offset, type,
386 addr = unpack_pointer (type, valaddr + embedded_offset);
387 print_unpacked_pointer (type, addr, address, options, stream);
392 elttype = check_typedef (TYPE_TARGET_TYPE (type));
393 if (options->addressprint)
396 = extract_typed_address (valaddr + embedded_offset, type);
397 fprintf_filtered (stream, "@");
398 fputs_filtered (paddress (addr), stream);
399 if (options->deref_ref)
400 fputs_filtered (": ", stream);
402 /* De-reference the reference. */
403 if (options->deref_ref)
405 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
407 struct value *deref_val =
409 (TYPE_TARGET_TYPE (type),
410 unpack_pointer (type, valaddr + embedded_offset));
411 common_val_print (deref_val, stream, recurse, options,
415 fputs_filtered ("???", stream);
419 case TYPE_CODE_UNION:
420 if (recurse && !options->unionprint)
422 fprintf_filtered (stream, "{...}");
426 case TYPE_CODE_STRUCT:
427 if (m2_is_long_set (type))
428 m2_print_long_set (type, valaddr, embedded_offset, address,
430 else if (m2_is_unbounded_array (type))
431 m2_print_unbounded_array (type, valaddr, embedded_offset,
432 address, stream, recurse, options);
434 cp_print_value_fields (type, type, valaddr, embedded_offset,
435 address, stream, recurse, options, NULL, 0);
441 print_scalar_formatted (valaddr + embedded_offset, type,
445 len = TYPE_NFIELDS (type);
446 val = unpack_long (type, valaddr + embedded_offset);
447 for (i = 0; i < len; i++)
450 if (val == TYPE_FIELD_BITPOS (type, i))
457 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
461 print_longest (stream, 'd', 0, val);
468 print_scalar_formatted (valaddr + embedded_offset, type,
472 /* FIXME, we should consider, at least for ANSI C language, eliminating
473 the distinction made between FUNCs and POINTERs to FUNCs. */
474 fprintf_filtered (stream, "{");
475 type_print (type, "", stream, -1);
476 fprintf_filtered (stream, "} ");
477 /* Try to print what function it points to, and its address. */
478 print_address_demangle (address, stream, demangle);
482 if (options->format || options->output_format)
484 struct value_print_options opts = *options;
485 opts.format = (options->format ? options->format
486 : options->output_format);
487 print_scalar_formatted (valaddr + embedded_offset, type,
492 val = unpack_long (type, valaddr + embedded_offset);
494 fputs_filtered ("FALSE", stream);
496 fputs_filtered ("TRUE", stream);
498 fprintf_filtered (stream, "%ld)", (long int) val);
502 case TYPE_CODE_RANGE:
503 if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
505 m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
506 address, stream, recurse, options);
509 /* FIXME: create_range_type does not set the unsigned bit in a
510 range type (I think it probably should copy it from the target
511 type), so we won't print values which are too large to
512 fit in a signed integer correctly. */
513 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
514 print with the target type, though, because the size of our type
515 and the target type might differ). */
519 if (options->format || options->output_format)
521 struct value_print_options opts = *options;
522 opts.format = (options->format ? options->format
523 : options->output_format);
524 print_scalar_formatted (valaddr + embedded_offset, type,
528 val_print_type_code_int (type, valaddr + embedded_offset, stream);
532 if (options->format || options->output_format)
534 struct value_print_options opts = *options;
535 opts.format = (options->format ? options->format
536 : options->output_format);
537 print_scalar_formatted (valaddr + embedded_offset, type,
542 val = unpack_long (type, valaddr + embedded_offset);
543 if (TYPE_UNSIGNED (type))
544 fprintf_filtered (stream, "%u", (unsigned int) val);
546 fprintf_filtered (stream, "%d", (int) val);
547 fputs_filtered (" ", stream);
548 LA_PRINT_CHAR ((unsigned char) val, type, stream);
554 print_scalar_formatted (valaddr + embedded_offset, type,
557 print_floating (valaddr + embedded_offset, type, stream);
560 case TYPE_CODE_METHOD:
563 case TYPE_CODE_BITSTRING:
565 elttype = TYPE_INDEX_TYPE (type);
566 CHECK_TYPEDEF (elttype);
567 if (TYPE_STUB (elttype))
569 fprintf_filtered (stream, _("<incomplete type>"));
575 struct type *range = elttype;
576 LONGEST low_bound, high_bound;
578 int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
582 fputs_filtered ("B'", stream);
584 fputs_filtered ("{", stream);
586 i = get_discrete_bounds (range, &low_bound, &high_bound);
590 fputs_filtered (_("<error value>"), stream);
594 for (i = low_bound; i <= high_bound; i++)
596 int element = value_bit_index (type, valaddr + embedded_offset,
601 goto maybe_bad_bstring;
604 fprintf_filtered (stream, "%d", element);
608 fputs_filtered (", ", stream);
609 print_type_scalar (range, i, stream);
612 if (i + 1 <= high_bound
613 && value_bit_index (type, valaddr + embedded_offset,
617 fputs_filtered ("..", stream);
618 while (i + 1 <= high_bound
619 && value_bit_index (type,
620 valaddr + embedded_offset,
623 print_type_scalar (range, j, stream);
629 fputs_filtered ("'", stream);
631 fputs_filtered ("}", stream);
636 fprintf_filtered (stream, "void");
639 case TYPE_CODE_ERROR:
640 fprintf_filtered (stream, _("<error type>"));
643 case TYPE_CODE_UNDEF:
644 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
645 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
646 and no complete type for struct foo in that file. */
647 fprintf_filtered (stream, _("<incomplete type>"));
651 error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));