GDB (xrefs)
/tmp/gdb-7.10/gdb/m2-valprint.c
Go to the documentation of this file.
1 /* Support for printing Modula 2 values for GDB, the GNU debugger.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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 3 of the License, or
10  (at your option) any later version.
11 
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.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "expression.h"
24 #include "value.h"
25 #include "valprint.h"
26 #include "language.h"
27 #include "typeprint.h"
28 #include "c-lang.h"
29 #include "m2-lang.h"
30 #include "target.h"
31 
32 static int print_unpacked_pointer (struct type *type,
33  CORE_ADDR address, CORE_ADDR addr,
34  const struct value_print_options *options,
35  struct ui_file *stream);
36 static void
37 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
38  int embedded_offset, CORE_ADDR address,
39  struct ui_file *stream, int recurse,
40  const struct value *val,
41  const struct value_print_options *options,
42  int len);
43 
44 
45 /* get_long_set_bounds - assigns the bounds of the long set to low and
46  high. */
47 
48 int
50 {
51  int len, i;
52 
53  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
54  {
55  len = TYPE_NFIELDS (type);
56  i = TYPE_N_BASECLASSES (type);
57  if (len == 0)
58  return 0;
59  *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
61  len-1)));
62  return 1;
63  }
64  error (_("expecting long_set"));
65  return 0;
66 }
67 
68 static void
69 m2_print_long_set (struct type *type, const gdb_byte *valaddr,
70  int embedded_offset, CORE_ADDR address,
71  struct ui_file *stream)
72 {
73  int empty_set = 1;
74  int element_seen = 0;
75  LONGEST previous_low = 0;
76  LONGEST previous_high= 0;
77  LONGEST i, low_bound, high_bound;
78  LONGEST field_low, field_high;
79  struct type *range;
80  int len, field;
81  struct type *target;
82  int bitval;
83 
84  CHECK_TYPEDEF (type);
85 
86  fprintf_filtered (stream, "{");
87  len = TYPE_NFIELDS (type);
88  if (get_long_set_bounds (type, &low_bound, &high_bound))
89  {
90  field = TYPE_N_BASECLASSES (type);
91  range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
92  }
93  else
94  {
95  fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
96  return;
97  }
98 
99  target = TYPE_TARGET_TYPE (range);
100 
101  if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
102  {
103  for (i = low_bound; i <= high_bound; i++)
104  {
105  bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
106  (TYPE_FIELD_BITPOS (type, field) / 8) +
107  valaddr + embedded_offset, i);
108  if (bitval < 0)
109  error (_("bit test is out of range"));
110  else if (bitval > 0)
111  {
112  previous_high = i;
113  if (! element_seen)
114  {
115  if (! empty_set)
116  fprintf_filtered (stream, ", ");
117  print_type_scalar (target, i, stream);
118  empty_set = 0;
119  element_seen = 1;
120  previous_low = i;
121  }
122  }
123  else
124  {
125  /* bit is not set */
126  if (element_seen)
127  {
128  if (previous_low+1 < previous_high)
129  fprintf_filtered (stream, "..");
130  if (previous_low+1 < previous_high)
131  print_type_scalar (target, previous_high, stream);
132  element_seen = 0;
133  }
134  }
135  if (i == field_high)
136  {
137  field++;
138  if (field == len)
139  break;
140  range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
141  if (get_discrete_bounds (range, &field_low, &field_high) < 0)
142  break;
143  target = TYPE_TARGET_TYPE (range);
144  }
145  }
146  if (element_seen)
147  {
148  if (previous_low+1 < previous_high)
149  {
150  fprintf_filtered (stream, "..");
151  print_type_scalar (target, previous_high, stream);
152  }
153  element_seen = 0;
154  }
155  fprintf_filtered (stream, "}");
156  }
157 }
158 
159 static void
160 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
161  int embedded_offset, CORE_ADDR address,
162  struct ui_file *stream, int recurse,
163  const struct value_print_options *options)
164 {
165  struct type *content_type;
166  CORE_ADDR addr;
167  LONGEST len;
168  struct value *val;
169 
170  CHECK_TYPEDEF (type);
171  content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
172 
173  addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
174  (TYPE_FIELD_BITPOS (type, 0) / 8) +
175  valaddr + embedded_offset);
176 
178  addr);
179  len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
180 
181  fprintf_filtered (stream, "{");
184  value_embedded_offset (val), addr, stream,
185  recurse, val, options, len);
186  fprintf_filtered (stream, ", HIGH = %d}", (int) len);
187 }
188 
189 static int
192  const struct value_print_options *options,
193  struct ui_file *stream)
194 {
195  struct gdbarch *gdbarch = get_type_arch (type);
196  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
197  int want_space = 0;
198 
199  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
200  {
201  /* Try to print what function it points to. */
202  print_function_pointer_address (options, gdbarch, addr, stream);
203  /* Return value is irrelevant except for string pointers. */
204  return 0;
205  }
206 
207  if (options->addressprint && options->format != 's')
208  {
209  fputs_filtered (paddress (gdbarch, address), stream);
210  want_space = 1;
211  }
212 
213  /* For a pointer to char or unsigned char, also print the string
214  pointed to, unless pointer is null. */
215 
216  if (TYPE_LENGTH (elttype) == 1
217  && TYPE_CODE (elttype) == TYPE_CODE_INT
218  && (options->format == 0 || options->format == 's')
219  && addr != 0)
220  {
221  if (want_space)
222  fputs_filtered (" ", stream);
223  return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
224  stream, options);
225  }
226 
227  return 0;
228 }
229 
230 static void
232  const gdb_byte *valaddr,
233  struct ui_file *stream,
234  int recurse,
235  const struct value_print_options *options)
236 {
237  struct gdbarch *gdbarch = get_type_arch (type);
238  CORE_ADDR addr = unpack_pointer (type, valaddr);
239  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
240 
241  fprintf_filtered (stream, "[");
242  fputs_filtered (paddress (gdbarch, addr), stream);
243  fprintf_filtered (stream, "] : ");
244 
245  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
246  {
247  struct value *deref_val =
248  value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
249 
250  common_val_print (deref_val, stream, recurse, options, current_language);
251  }
252  else
253  fputs_filtered ("???", stream);
254 }
255 
256 
257 /* m2_print_array_contents - prints out the contents of an
258  array up to a max_print values.
259  It prints arrays of char as a string
260  and all other data types as comma
261  separated values. */
262 
263 static void
264 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
266  struct ui_file *stream, int recurse,
267  const struct value *val,
268  const struct value_print_options *options,
269  int len)
270 {
271  CHECK_TYPEDEF (type);
272 
273  if (TYPE_LENGTH (type) > 0)
274  {
275  if (options->prettyformat_arrays)
276  print_spaces_filtered (2 + 2 * recurse, stream);
277  /* For an array of chars, print with string syntax. */
278  if (TYPE_LENGTH (type) == 1 &&
279  ((TYPE_CODE (type) == TYPE_CODE_INT)
281  && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
282  && (options->format == 0 || options->format == 's'))
283  val_print_string (type, NULL, address, len+1, stream, options);
284  else
285  {
286  fprintf_filtered (stream, "{");
287  val_print_array_elements (type, valaddr, embedded_offset,
288  address, stream, recurse, val,
289  options, 0);
290  fprintf_filtered (stream, "}");
291  }
292  }
293 }
294 
295 /* Decorations for Modula 2. */
296 
297 static const struct generic_val_print_decorations m2_decorations =
298 {
299  "",
300  " + ",
301  " * I",
302  "TRUE",
303  "FALSE",
304  "void"
305 };
306 
307 /* See val_print for a description of the various parameters of this
308  function; they are identical. */
309 
310 void
311 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
312  CORE_ADDR address, struct ui_file *stream, int recurse,
313  const struct value *original_value,
314  const struct value_print_options *options)
315 {
316  struct gdbarch *gdbarch = get_type_arch (type);
317  unsigned int i = 0; /* Number of characters printed. */
318  unsigned len;
319  struct type *elttype;
320  CORE_ADDR addr;
321 
322  CHECK_TYPEDEF (type);
323  switch (TYPE_CODE (type))
324  {
325  case TYPE_CODE_ARRAY:
326  if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
327  {
328  elttype = check_typedef (TYPE_TARGET_TYPE (type));
329  len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
330  if (options->prettyformat_arrays)
331  print_spaces_filtered (2 + 2 * recurse, stream);
332  /* For an array of chars, print with string syntax. */
333  if (TYPE_LENGTH (elttype) == 1 &&
334  ((TYPE_CODE (elttype) == TYPE_CODE_INT)
336  && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
337  && (options->format == 0 || options->format == 's'))
338  {
339  /* If requested, look for the first null char and only print
340  elements up to it. */
341  if (options->stop_print_at_null)
342  {
343  unsigned int temp_len;
344 
345  /* Look for a NULL char. */
346  for (temp_len = 0;
347  (valaddr + embedded_offset)[temp_len]
348  && temp_len < len && temp_len < options->print_max;
349  temp_len++);
350  len = temp_len;
351  }
352 
353  LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
354  valaddr + embedded_offset, len, NULL,
355  0, options);
356  i = len;
357  }
358  else
359  {
360  fprintf_filtered (stream, "{");
361  val_print_array_elements (type, valaddr, embedded_offset,
362  address, stream,
363  recurse, original_value,
364  options, 0);
365  fprintf_filtered (stream, "}");
366  }
367  break;
368  }
369  /* Array of unspecified length: treat like pointer to first elt. */
370  print_unpacked_pointer (type, address, address, options, stream);
371  break;
372 
373  case TYPE_CODE_PTR:
374  if (TYPE_CONST (type))
375  print_variable_at_address (type, valaddr + embedded_offset,
376  stream, recurse, options);
377  else if (options->format && options->format != 's')
378  val_print_scalar_formatted (type, valaddr, embedded_offset,
379  original_value, options, 0, stream);
380  else
381  {
382  addr = unpack_pointer (type, valaddr + embedded_offset);
383  print_unpacked_pointer (type, addr, address, options, stream);
384  }
385  break;
386 
387  case TYPE_CODE_UNION:
388  if (recurse && !options->unionprint)
389  {
390  fprintf_filtered (stream, "{...}");
391  break;
392  }
393  /* Fall through. */
394  case TYPE_CODE_STRUCT:
395  if (m2_is_long_set (type))
396  m2_print_long_set (type, valaddr, embedded_offset, address,
397  stream);
398  else if (m2_is_unbounded_array (type))
399  m2_print_unbounded_array (type, valaddr, embedded_offset,
400  address, stream, recurse, options);
401  else
402  cp_print_value_fields (type, type, valaddr, embedded_offset,
403  address, stream, recurse, original_value,
404  options, NULL, 0);
405  break;
406 
407  case TYPE_CODE_SET:
408  elttype = TYPE_INDEX_TYPE (type);
409  CHECK_TYPEDEF (elttype);
410  if (TYPE_STUB (elttype))
411  {
412  fprintf_filtered (stream, _("<incomplete type>"));
413  gdb_flush (stream);
414  break;
415  }
416  else
417  {
418  struct type *range = elttype;
419  LONGEST low_bound, high_bound;
420  int i;
421  int need_comma = 0;
422 
423  fputs_filtered ("{", stream);
424 
425  i = get_discrete_bounds (range, &low_bound, &high_bound);
426  maybe_bad_bstring:
427  if (i < 0)
428  {
429  fputs_filtered (_("<error value>"), stream);
430  goto done;
431  }
432 
433  for (i = low_bound; i <= high_bound; i++)
434  {
435  int element = value_bit_index (type, valaddr + embedded_offset,
436  i);
437 
438  if (element < 0)
439  {
440  i = element;
441  goto maybe_bad_bstring;
442  }
443  if (element)
444  {
445  if (need_comma)
446  fputs_filtered (", ", stream);
447  print_type_scalar (range, i, stream);
448  need_comma = 1;
449 
450  if (i + 1 <= high_bound
451  && value_bit_index (type, valaddr + embedded_offset,
452  ++i))
453  {
454  int j = i;
455 
456  fputs_filtered ("..", stream);
457  while (i + 1 <= high_bound
458  && value_bit_index (type,
459  valaddr + embedded_offset,
460  ++i))
461  j = i;
462  print_type_scalar (range, j, stream);
463  }
464  }
465  }
466  done:
467  fputs_filtered ("}", stream);
468  }
469  break;
470 
471  case TYPE_CODE_RANGE:
472  if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
473  {
474  m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
475  address, stream, recurse, original_value, options);
476  break;
477  }
478  /* FIXME: create_static_range_type does not set the unsigned bit in a
479  range type (I think it probably should copy it from the target
480  type), so we won't print values which are too large to
481  fit in a signed integer correctly. */
482  /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
483  print with the target type, though, because the size of our type
484  and the target type might differ). */
485  /* FALLTHROUGH */
486 
487  case TYPE_CODE_REF:
488  case TYPE_CODE_ENUM:
489  case TYPE_CODE_FUNC:
490  case TYPE_CODE_INT:
491  case TYPE_CODE_FLT:
492  case TYPE_CODE_METHOD:
493  case TYPE_CODE_VOID:
494  case TYPE_CODE_ERROR:
495  case TYPE_CODE_UNDEF:
496  case TYPE_CODE_BOOL:
497  case TYPE_CODE_CHAR:
498  default:
499  generic_val_print (type, valaddr, embedded_offset, address,
500  stream, recurse, original_value, options,
501  &m2_decorations);
502  break;
503  }
504  gdb_flush (stream);
505 }
void generic_val_print(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:374
void val_print_scalar_formatted(struct type *type, const gdb_byte *valaddr, int embedded_offset, const struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition: valprint.c:960
static const char * range
Definition: language.c:104
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1246
static void print_variable_at_address(struct type *type, const gdb_byte *valaddr, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition: m2-valprint.c:231
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2914
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:940
#define TYPE_HIGH_BOUND(range_type)
Definition: gdbtypes.h:1248
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:846
int get_long_set_bounds(struct type *type, LONGEST *low, LONGEST *high)
Definition: m2-valprint.c:49
static int print_unpacked_pointer(struct type *type, CORE_ADDR address, CORE_ADDR addr, const struct value_print_options *options, struct ui_file *stream)
Definition: m2-valprint.c:190
enum language la_language
Definition: language.h:152
#define _(String)
Definition: gdb_locale.h:40
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1173
int m2_is_long_set(struct type *type)
Definition: m2-typeprint.c:335
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static void m2_print_unbounded_array(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value_print_options *options)
Definition: m2-valprint.c:160
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
LONGEST unpack_field_as_long(struct type *type, const gdb_byte *valaddr, int fieldno)
Definition: value.c:3267
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void val_print_array_elements(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options, unsigned int i)
Definition: valprint.c:1619
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
static void m2_print_array_contents(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options, int len)
Definition: m2-valprint.c:264
Definition: gdbtypes.h:749
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:951
void print_type_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition: typeprint.c:522
Definition: value.c:65
int m2_is_unbounded_array(struct type *type)
Definition: m2-typeprint.c:489
static void m2_print_long_set(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream)
Definition: m2-valprint.c:69
int value_bit_index(struct type *type, const gdb_byte *valaddr, int index)
Definition: valarith.c:1861
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1371
Definition: value.c:172
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2464
bfd_byte gdb_byte
Definition: common-types.h:38
const struct language_defn * current_language
Definition: language.c:85
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
void m2_val_print(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options)
Definition: m2-valprint.c:311
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
#define TYPE_STUB(t)
Definition: gdbtypes.h:245
int value_embedded_offset(struct value *value)
Definition: value.c:1388
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:496
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2496
CORE_ADDR address
Definition: value.c:216
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition: valprint.c:1571
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
int get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition: gdbtypes.c:899
void error(const char *fmt,...)
Definition: errors.c:38
int embedded_offset
Definition: value.c:312
void cp_print_value_fields(struct type *, struct type *, const gdb_byte *, int, CORE_ADDR, struct ui_file *, int, const struct value *, const struct value_print_options *, struct type **, int)
Definition: cp-valprint.c:156
long long LONGEST
Definition: common-types.h:52
const ULONGEST const LONGEST len
Definition: target.h:309