GDB (xrefs)
/tmp/gdb-7.10/gdb/ada-valprint.c
Go to the documentation of this file.
1 /* Support for printing Ada 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 <ctype.h>
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "expression.h"
25 #include "value.h"
26 #include "demangle.h"
27 #include "valprint.h"
28 #include "language.h"
29 #include "annotate.h"
30 #include "ada-lang.h"
31 #include "c-lang.h"
32 #include "infcall.h"
33 #include "objfiles.h"
34 
35 static int print_field_values (struct type *, const gdb_byte *,
36  int,
37  struct ui_file *, int,
38  const struct value *,
39  const struct value_print_options *,
40  int, struct type *, int,
41  const struct language_defn *);
42 
43 
44 /* Make TYPE unsigned if its range of values includes no negatives. */
45 static void
46 adjust_type_signedness (struct type *type)
47 {
48  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
49  && TYPE_LOW_BOUND (type) >= 0)
50  TYPE_UNSIGNED (type) = 1;
51 }
52 
53 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
54  if non-standard (i.e., other than 1 for numbers, other than lower bound
55  of index type for enumerated type). Returns 1 if something printed,
56  otherwise 0. */
57 
58 static int
59 print_optional_low_bound (struct ui_file *stream, struct type *type,
60  const struct value_print_options *options)
61 {
62  struct type *index_type;
63  LONGEST low_bound;
64  LONGEST high_bound;
65 
66  if (options->print_array_indexes)
67  return 0;
68 
69  if (!get_array_bounds (type, &low_bound, &high_bound))
70  return 0;
71 
72  /* If this is an empty array, then don't print the lower bound.
73  That would be confusing, because we would print the lower bound,
74  followed by... nothing! */
75  if (low_bound > high_bound)
76  return 0;
77 
78  index_type = TYPE_INDEX_TYPE (type);
79 
80  while (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
81  {
82  /* We need to know what the base type is, in order to do the
83  appropriate check below. Otherwise, if this is a subrange
84  of an enumerated type, where the underlying value of the
85  first element is typically 0, we might test the low bound
86  against the wrong value. */
87  index_type = TYPE_TARGET_TYPE (index_type);
88  }
89 
90  switch (TYPE_CODE (index_type))
91  {
92  case TYPE_CODE_BOOL:
93  if (low_bound == 0)
94  return 0;
95  break;
96  case TYPE_CODE_ENUM:
97  if (low_bound == TYPE_FIELD_ENUMVAL (index_type, 0))
98  return 0;
99  break;
100  case TYPE_CODE_UNDEF:
101  index_type = NULL;
102  /* FALL THROUGH */
103  default:
104  if (low_bound == 1)
105  return 0;
106  break;
107  }
108 
109  ada_print_scalar (index_type, low_bound, stream);
110  fprintf_filtered (stream, " => ");
111  return 1;
112 }
113 
114 /* Version of val_print_array_elements for GNAT-style packed arrays.
115  Prints elements of packed array of type TYPE at bit offset
116  BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
117  separates with commas. RECURSE is the recursion (nesting) level.
118  TYPE must have been decoded (as by ada_coerce_to_simple_array). */
119 
120 static void
121 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
122  int offset,
123  int bitoffset, struct ui_file *stream,
124  int recurse,
125  const struct value *val,
126  const struct value_print_options *options)
127 {
128  unsigned int i;
129  unsigned int things_printed = 0;
130  unsigned len;
131  struct type *elttype, *index_type;
132  unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
133  struct value *mark = value_mark ();
134  LONGEST low = 0;
135 
136  elttype = TYPE_TARGET_TYPE (type);
137  index_type = TYPE_INDEX_TYPE (type);
138 
139  {
140  LONGEST high;
141 
142  if (get_discrete_bounds (index_type, &low, &high) < 0)
143  len = 1;
144  else
145  len = high - low + 1;
146  }
147 
148  i = 0;
149  annotate_array_section_begin (i, elttype);
150 
151  while (i < len && things_printed < options->print_max)
152  {
153  struct value *v0, *v1;
154  int i0;
155 
156  if (i != 0)
157  {
158  if (options->prettyformat_arrays)
159  {
160  fprintf_filtered (stream, ",\n");
161  print_spaces_filtered (2 + 2 * recurse, stream);
162  }
163  else
164  {
165  fprintf_filtered (stream, ", ");
166  }
167  }
168  wrap_here (n_spaces (2 + 2 * recurse));
169  maybe_print_array_index (index_type, i + low, stream, options);
170 
171  i0 = i;
172  v0 = ada_value_primitive_packed_val (NULL, valaddr + offset,
173  (i0 * bitsize) / HOST_CHAR_BIT,
174  (i0 * bitsize) % HOST_CHAR_BIT,
175  bitsize, elttype);
176  while (1)
177  {
178  i += 1;
179  if (i >= len)
180  break;
181  v1 = ada_value_primitive_packed_val (NULL, valaddr + offset,
182  (i * bitsize) / HOST_CHAR_BIT,
183  (i * bitsize) % HOST_CHAR_BIT,
184  bitsize, elttype);
187  break;
189  v1, value_embedded_offset (v1),
191  break;
192  }
193 
194  if (i - i0 > options->repeat_count_threshold)
195  {
196  struct value_print_options opts = *options;
197 
198  opts.deref_ref = 0;
199  val_print (elttype, value_contents_for_printing (v0),
200  value_embedded_offset (v0), 0, stream,
201  recurse + 1, v0, &opts, current_language);
202  annotate_elt_rep (i - i0);
203  fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
205 
206  }
207  else
208  {
209  int j;
210  struct value_print_options opts = *options;
211 
212  opts.deref_ref = 0;
213  for (j = i0; j < i; j += 1)
214  {
215  if (j > i0)
216  {
217  if (options->prettyformat_arrays)
218  {
219  fprintf_filtered (stream, ",\n");
220  print_spaces_filtered (2 + 2 * recurse, stream);
221  }
222  else
223  {
224  fprintf_filtered (stream, ", ");
225  }
226  wrap_here (n_spaces (2 + 2 * recurse));
227  maybe_print_array_index (index_type, j + low,
228  stream, options);
229  }
230  val_print (elttype, value_contents_for_printing (v0),
231  value_embedded_offset (v0), 0, stream,
232  recurse + 1, v0, &opts, current_language);
233  annotate_elt ();
234  }
235  }
236  things_printed += i - i0;
237  }
239  if (i < len)
240  {
241  fprintf_filtered (stream, "...");
242  }
243 
244  value_free_to_mark (mark);
245 }
246 
247 static struct type *
248 printable_val_type (struct type *type, const gdb_byte *valaddr)
249 {
250  return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
251 }
252 
253 /* Print the character C on STREAM as part of the contents of a literal
254  string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
255  of the character. */
256 
257 void
258 ada_emit_char (int c, struct type *type, struct ui_file *stream,
259  int quoter, int type_len)
260 {
261  /* If this character fits in the normal ASCII range, and is
262  a printable character, then print the character as if it was
263  an ASCII character, even if this is a wide character.
264  The UCHAR_MAX check is necessary because the isascii function
265  requires that its argument have a value of an unsigned char,
266  or EOF (EOF is obviously not printable). */
267  if (c <= UCHAR_MAX && isascii (c) && isprint (c))
268  {
269  if (c == quoter && c == '"')
270  fprintf_filtered (stream, "\"\"");
271  else
272  fprintf_filtered (stream, "%c", c);
273  }
274  else
275  fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
276 }
277 
278 /* Character #I of STRING, given that TYPE_LEN is the size in bytes
279  of a character. */
280 
281 static int
282 char_at (const gdb_byte *string, int i, int type_len,
283  enum bfd_endian byte_order)
284 {
285  if (type_len == 1)
286  return string[i];
287  else
288  return (int) extract_unsigned_integer (string + type_len * i,
289  type_len, byte_order);
290 }
291 
292 /* Print a floating-point value of type TYPE, pointed to in GDB by
293  VALADDR, on STREAM. Use Ada formatting conventions: there must be
294  a decimal point, and at least one digit before and after the
295  point. We use the GNAT format for NaNs and infinities. */
296 
297 static void
298 ada_print_floating (const gdb_byte *valaddr, struct type *type,
299  struct ui_file *stream)
300 {
301  char *s, *result;
302  struct ui_file *tmp_stream = mem_fileopen ();
303  struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
304 
305  print_floating (valaddr, type, tmp_stream);
306  result = ui_file_xstrdup (tmp_stream, NULL);
307  make_cleanup (xfree, result);
308 
309  /* Modify for Ada rules. */
310 
311  s = strstr (result, "inf");
312  if (s == NULL)
313  s = strstr (result, "Inf");
314  if (s == NULL)
315  s = strstr (result, "INF");
316  if (s != NULL)
317  strcpy (s, "Inf");
318 
319  if (s == NULL)
320  {
321  s = strstr (result, "nan");
322  if (s == NULL)
323  s = strstr (result, "NaN");
324  if (s == NULL)
325  s = strstr (result, "Nan");
326  if (s != NULL)
327  {
328  s[0] = s[2] = 'N';
329  if (result[0] == '-')
330  result += 1;
331  }
332  }
333 
334  if (s == NULL && strchr (result, '.') == NULL)
335  {
336  s = strchr (result, 'e');
337  if (s == NULL)
338  fprintf_filtered (stream, "%s.0", result);
339  else
340  fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
341  }
342  else
343  fprintf_filtered (stream, "%s", result);
344 
345  do_cleanups (cleanups);
346 }
347 
348 void
349 ada_printchar (int c, struct type *type, struct ui_file *stream)
350 {
351  fputs_filtered ("'", stream);
352  ada_emit_char (c, type, stream, '\'', TYPE_LENGTH (type));
353  fputs_filtered ("'", stream);
354 }
355 
356 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
357  form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
358  like a default signed integer. */
359 
360 void
361 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
362 {
363  unsigned int i;
364  unsigned len;
365 
366  if (!type)
367  {
368  print_longest (stream, 'd', 0, val);
369  return;
370  }
371 
372  type = ada_check_typedef (type);
373 
374  switch (TYPE_CODE (type))
375  {
376 
377  case TYPE_CODE_ENUM:
378  len = TYPE_NFIELDS (type);
379  for (i = 0; i < len; i++)
380  {
381  if (TYPE_FIELD_ENUMVAL (type, i) == val)
382  {
383  break;
384  }
385  }
386  if (i < len)
387  {
388  fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
389  }
390  else
391  {
392  print_longest (stream, 'd', 0, val);
393  }
394  break;
395 
396  case TYPE_CODE_INT:
397  print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
398  break;
399 
400  case TYPE_CODE_CHAR:
401  LA_PRINT_CHAR (val, type, stream);
402  break;
403 
404  case TYPE_CODE_BOOL:
405  fprintf_filtered (stream, val ? "true" : "false");
406  break;
407 
408  case TYPE_CODE_RANGE:
409  ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
410  return;
411 
412  case TYPE_CODE_UNDEF:
413  case TYPE_CODE_PTR:
414  case TYPE_CODE_ARRAY:
415  case TYPE_CODE_STRUCT:
416  case TYPE_CODE_UNION:
417  case TYPE_CODE_FUNC:
418  case TYPE_CODE_FLT:
419  case TYPE_CODE_VOID:
420  case TYPE_CODE_SET:
421  case TYPE_CODE_STRING:
422  case TYPE_CODE_ERROR:
423  case TYPE_CODE_MEMBERPTR:
424  case TYPE_CODE_METHODPTR:
425  case TYPE_CODE_METHOD:
426  case TYPE_CODE_REF:
427  warning (_("internal error: unhandled type in ada_print_scalar"));
428  break;
429 
430  default:
431  error (_("Invalid type code in symbol table."));
432  }
433  gdb_flush (stream);
434 }
435 
436 /* Print the character string STRING, printing at most LENGTH characters.
437  Printing stops early if the number hits print_max; repeat counts
438  are printed as appropriate. Print ellipses at the end if we
439  had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
440  TYPE_LEN is the length (1 or 2) of the character type. */
441 
442 static void
443 printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string,
444  unsigned int length, int force_ellipses, int type_len,
445  const struct value_print_options *options)
446 {
447  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype));
448  unsigned int i;
449  unsigned int things_printed = 0;
450  int in_quotes = 0;
451  int need_comma = 0;
452 
453  if (length == 0)
454  {
455  fputs_filtered ("\"\"", stream);
456  return;
457  }
458 
459  for (i = 0; i < length && things_printed < options->print_max; i += 1)
460  {
461  /* Position of the character we are examining
462  to see whether it is repeated. */
463  unsigned int rep1;
464  /* Number of repetitions we have detected so far. */
465  unsigned int reps;
466 
467  QUIT;
468 
469  if (need_comma)
470  {
471  fputs_filtered (", ", stream);
472  need_comma = 0;
473  }
474 
475  rep1 = i + 1;
476  reps = 1;
477  while (rep1 < length
478  && char_at (string, rep1, type_len, byte_order)
479  == char_at (string, i, type_len, byte_order))
480  {
481  rep1 += 1;
482  reps += 1;
483  }
484 
485  if (reps > options->repeat_count_threshold)
486  {
487  if (in_quotes)
488  {
489  fputs_filtered ("\", ", stream);
490  in_quotes = 0;
491  }
492  fputs_filtered ("'", stream);
493  ada_emit_char (char_at (string, i, type_len, byte_order),
494  elttype, stream, '\'', type_len);
495  fputs_filtered ("'", stream);
496  fprintf_filtered (stream, _(" <repeats %u times>"), reps);
497  i = rep1 - 1;
498  things_printed += options->repeat_count_threshold;
499  need_comma = 1;
500  }
501  else
502  {
503  if (!in_quotes)
504  {
505  fputs_filtered ("\"", stream);
506  in_quotes = 1;
507  }
508  ada_emit_char (char_at (string, i, type_len, byte_order),
509  elttype, stream, '"', type_len);
510  things_printed += 1;
511  }
512  }
513 
514  /* Terminate the quotes if necessary. */
515  if (in_quotes)
516  fputs_filtered ("\"", stream);
517 
518  if (force_ellipses || i < length)
519  fputs_filtered ("...", stream);
520 }
521 
522 void
523 ada_printstr (struct ui_file *stream, struct type *type,
524  const gdb_byte *string, unsigned int length,
525  const char *encoding, int force_ellipses,
526  const struct value_print_options *options)
527 {
528  printstr (stream, type, string, length, force_ellipses, TYPE_LENGTH (type),
529  options);
530 }
531 
532 static int
533 print_variant_part (struct type *type, int field_num,
534  const gdb_byte *valaddr, int offset,
535  struct ui_file *stream, int recurse,
536  const struct value *val,
537  const struct value_print_options *options,
538  int comma_needed,
539  struct type *outer_type, int outer_offset,
540  const struct language_defn *language)
541 {
542  struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
543  int which = ada_which_variant_applies (var_type, outer_type,
544  valaddr + outer_offset);
545 
546  if (which < 0)
547  return 0;
548  else
549  return print_field_values
550  (TYPE_FIELD_TYPE (var_type, which),
551  valaddr,
552  offset + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
553  + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
554  stream, recurse, val, options,
555  comma_needed, outer_type, outer_offset, language);
556 }
557 
558 /* Print out fields of value at VALADDR + OFFSET having structure type TYPE.
559 
560  TYPE, VALADDR, OFFSET, STREAM, RECURSE, and OPTIONS have the same
561  meanings as in ada_print_value and ada_val_print.
562 
563  OUTER_TYPE and OUTER_OFFSET give type and address of enclosing
564  record (used to get discriminant values when printing variant
565  parts).
566 
567  COMMA_NEEDED is 1 if fields have been printed at the current recursion
568  level, so that a comma is needed before any field printed by this
569  call.
570 
571  Returns 1 if COMMA_NEEDED or any fields were printed. */
572 
573 static int
574 print_field_values (struct type *type, const gdb_byte *valaddr,
575  int offset, struct ui_file *stream, int recurse,
576  const struct value *val,
577  const struct value_print_options *options,
578  int comma_needed,
579  struct type *outer_type, int outer_offset,
580  const struct language_defn *language)
581 {
582  int i, len;
583 
584  len = TYPE_NFIELDS (type);
585 
586  for (i = 0; i < len; i += 1)
587  {
588  if (ada_is_ignored_field (type, i))
589  continue;
590 
591  if (ada_is_wrapper_field (type, i))
592  {
593  comma_needed =
595  valaddr,
596  (offset
597  + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
598  stream, recurse, val, options,
599  comma_needed, type, offset, language);
600  continue;
601  }
602  else if (ada_is_variant_part (type, i))
603  {
604  comma_needed =
605  print_variant_part (type, i, valaddr,
606  offset, stream, recurse, val,
607  options, comma_needed,
608  outer_type, outer_offset, language);
609  continue;
610  }
611 
612  if (comma_needed)
613  fprintf_filtered (stream, ", ");
614  comma_needed = 1;
615 
616  if (options->prettyformat)
617  {
618  fprintf_filtered (stream, "\n");
619  print_spaces_filtered (2 + 2 * recurse, stream);
620  }
621  else
622  {
623  wrap_here (n_spaces (2 + 2 * recurse));
624  }
625 
627  fprintf_filtered (stream, "%.*s",
629  TYPE_FIELD_NAME (type, i));
631  fputs_filtered (" => ", stream);
633 
634  if (TYPE_FIELD_PACKED (type, i))
635  {
636  struct value *v;
637 
638  /* Bitfields require special handling, especially due to byte
639  order problems. */
640  if (HAVE_CPLUS_STRUCT (type) && TYPE_FIELD_IGNORE (type, i))
641  {
642  fputs_filtered (_("<optimized out or zero length>"), stream);
643  }
644  else
645  {
646  int bit_pos = TYPE_FIELD_BITPOS (type, i);
647  int bit_size = TYPE_FIELD_BITSIZE (type, i);
648  struct value_print_options opts;
649 
652  (NULL, valaddr,
653  offset + bit_pos / HOST_CHAR_BIT,
654  bit_pos % HOST_CHAR_BIT,
655  bit_size, TYPE_FIELD_TYPE (type, i));
656  opts = *options;
657  opts.deref_ref = 0;
658  val_print (TYPE_FIELD_TYPE (type, i),
660  value_embedded_offset (v), 0,
661  stream, recurse + 1, v,
662  &opts, language);
663  }
664  }
665  else
666  {
667  struct value_print_options opts = *options;
668 
669  opts.deref_ref = 0;
670  val_print (TYPE_FIELD_TYPE (type, i), valaddr,
671  (offset + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT),
672  0, stream, recurse + 1, val, &opts, language);
673  }
675  }
676 
677  return comma_needed;
678 }
679 
680 /* Implement Ada val_print'ing for the case where TYPE is
681  a TYPE_CODE_ARRAY of characters. */
682 
683 static void
684 ada_val_print_string (struct type *type, const gdb_byte *valaddr,
685  int offset, int offset_aligned, CORE_ADDR address,
686  struct ui_file *stream, int recurse,
687  const struct value *original_value,
688  const struct value_print_options *options)
689 {
690  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
691  struct type *elttype = TYPE_TARGET_TYPE (type);
692  unsigned int eltlen;
693  unsigned int len;
694 
695  /* We know that ELTTYPE cannot possibly be null, because we assume
696  that we're called only when TYPE is a string-like type.
697  Similarly, the size of ELTTYPE should also be non-null, since
698  it's a character-like type. */
699  gdb_assert (elttype != NULL);
700  gdb_assert (TYPE_LENGTH (elttype) != 0);
701 
702  eltlen = TYPE_LENGTH (elttype);
703  len = TYPE_LENGTH (type) / eltlen;
704 
705  if (options->prettyformat_arrays)
706  print_spaces_filtered (2 + 2 * recurse, stream);
707 
708  /* If requested, look for the first null char and only print
709  elements up to it. */
710  if (options->stop_print_at_null)
711  {
712  int temp_len;
713 
714  /* Look for a NULL char. */
715  for (temp_len = 0;
716  (temp_len < len
717  && temp_len < options->print_max
718  && char_at (valaddr + offset_aligned,
719  temp_len, eltlen, byte_order) != 0);
720  temp_len += 1);
721  len = temp_len;
722  }
723 
724  printstr (stream, elttype, valaddr + offset_aligned, len, 0,
725  eltlen, options);
726 }
727 
728 /* Implement Ada val_print-ing for GNAT arrays (Eg. fat pointers,
729  thin pointers, etc). */
730 
731 static void
732 ada_val_print_gnat_array (struct type *type, const gdb_byte *valaddr,
733  int offset, CORE_ADDR address,
734  struct ui_file *stream, int recurse,
735  const struct value *original_value,
736  const struct value_print_options *options,
737  const struct language_defn *language)
738 {
739  struct value *mark = value_mark ();
740  struct value *val;
741 
742  val = value_from_contents_and_address (type, valaddr + offset, address);
743  /* If this is a reference, coerce it now. This helps taking care
744  of the case where ADDRESS is meaningless because original_value
745  was not an lval. */
746  val = coerce_ref (val);
747  if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF) /* array access type. */
748  val = ada_coerce_to_simple_array_ptr (val);
749  else
750  val = ada_coerce_to_simple_array (val);
751  if (val == NULL)
752  {
754  fprintf_filtered (stream, "0x0");
755  }
756  else
759  stream, recurse, val, options, language);
760  value_free_to_mark (mark);
761 }
762 
763 /* Implement Ada val_print'ing for the case where TYPE is
764  a TYPE_CODE_PTR. */
765 
766 static void
767 ada_val_print_ptr (struct type *type, const gdb_byte *valaddr,
768  int offset, int offset_aligned, CORE_ADDR address,
769  struct ui_file *stream, int recurse,
770  const struct value *original_value,
771  const struct value_print_options *options,
772  const struct language_defn *language)
773 {
774  val_print (type, valaddr, offset, address, stream, recurse,
775  original_value, options, language_def (language_c));
776 
777  if (ada_is_tag_type (type))
778  {
779  struct value *val =
781  valaddr + offset_aligned,
782  address + offset_aligned);
783  const char *name = ada_tag_name (val);
784 
785  if (name != NULL)
786  fprintf_filtered (stream, " (%s)", name);
787  }
788 }
789 
790 /* Implement Ada val_print'ing for the case where TYPE is
791  a TYPE_CODE_INT or TYPE_CODE_RANGE. */
792 
793 static void
794 ada_val_print_num (struct type *type, const gdb_byte *valaddr,
795  int offset, int offset_aligned, CORE_ADDR address,
796  struct ui_file *stream, int recurse,
797  const struct value *original_value,
798  const struct value_print_options *options,
799  const struct language_defn *language)
800 {
801  if (ada_is_fixed_point_type (type))
802  {
803  LONGEST v = unpack_long (type, valaddr + offset_aligned);
804 
805  fprintf_filtered (stream, TYPE_LENGTH (type) < 4 ? "%.11g" : "%.17g",
806  (double) ada_fixed_to_float (type, v));
807  return;
808  }
809  else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
810  {
811  struct type *target_type = TYPE_TARGET_TYPE (type);
812 
813  if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
814  {
815  /* Obscure case of range type that has different length from
816  its base type. Perform a conversion, or we will get a
817  nonsense value. Actually, we could use the same
818  code regardless of lengths; I'm just avoiding a cast. */
819  struct value *v1
820  = value_from_contents_and_address (type, valaddr + offset, 0);
821  struct value *v = value_cast (target_type, v1);
822 
823  val_print (target_type, value_contents_for_printing (v),
824  value_embedded_offset (v), 0, stream,
825  recurse + 1, v, options, language);
826  }
827  else
828  val_print (TYPE_TARGET_TYPE (type), valaddr, offset,
829  address, stream, recurse, original_value,
830  options, language);
831  return;
832  }
833  else
834  {
835  int format = (options->format ? options->format
836  : options->output_format);
837 
838  if (format)
839  {
840  struct value_print_options opts = *options;
841 
842  opts.format = format;
843  val_print_scalar_formatted (type, valaddr, offset_aligned,
844  original_value, &opts, 0, stream);
845  }
846  else if (ada_is_system_address_type (type))
847  {
848  /* FIXME: We want to print System.Address variables using
849  the same format as for any access type. But for some
850  reason GNAT encodes the System.Address type as an int,
851  so we have to work-around this deficiency by handling
852  System.Address values as a special case. */
853 
854  struct gdbarch *gdbarch = get_type_arch (type);
855  struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
856  CORE_ADDR addr = extract_typed_address (valaddr + offset_aligned,
857  ptr_type);
858 
859  fprintf_filtered (stream, "(");
860  type_print (type, "", stream, -1);
861  fprintf_filtered (stream, ") ");
862  fputs_filtered (paddress (gdbarch, addr), stream);
863  }
864  else
865  {
866  val_print_type_code_int (type, valaddr + offset_aligned, stream);
867  if (ada_is_character_type (type))
868  {
869  LONGEST c;
870 
871  fputs_filtered (" ", stream);
872  c = unpack_long (type, valaddr + offset_aligned);
873  ada_printchar (c, type, stream);
874  }
875  }
876  return;
877  }
878 }
879 
880 /* Implement Ada val_print'ing for the case where TYPE is
881  a TYPE_CODE_ENUM. */
882 
883 static void
884 ada_val_print_enum (struct type *type, const gdb_byte *valaddr,
885  int offset, int offset_aligned, CORE_ADDR address,
886  struct ui_file *stream, int recurse,
887  const struct value *original_value,
888  const struct value_print_options *options,
889  const struct language_defn *language)
890 {
891  int i;
892  unsigned int len;
893  LONGEST val;
894 
895  if (options->format)
896  {
897  val_print_scalar_formatted (type, valaddr, offset_aligned,
898  original_value, options, 0, stream);
899  return;
900  }
901 
902  len = TYPE_NFIELDS (type);
903  val = unpack_long (type, valaddr + offset_aligned);
904  for (i = 0; i < len; i++)
905  {
906  QUIT;
907  if (val == TYPE_FIELD_ENUMVAL (type, i))
908  break;
909  }
910 
911  if (i < len)
912  {
913  const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
914 
915  if (name[0] == '\'')
916  fprintf_filtered (stream, "%ld %s", (long) val, name);
917  else
918  fputs_filtered (name, stream);
919  }
920  else
921  print_longest (stream, 'd', 0, val);
922 }
923 
924 /* Implement Ada val_print'ing for the case where TYPE is
925  a TYPE_CODE_FLT. */
926 
927 static void
928 ada_val_print_flt (struct type *type, const gdb_byte *valaddr,
929  int offset, int offset_aligned, CORE_ADDR address,
930  struct ui_file *stream, int recurse,
931  const struct value *original_value,
932  const struct value_print_options *options,
933  const struct language_defn *language)
934 {
935  if (options->format)
936  {
937  val_print (type, valaddr, offset, address, stream, recurse,
938  original_value, options, language_def (language_c));
939  return;
940  }
941 
942  ada_print_floating (valaddr + offset, type, stream);
943 }
944 
945 /* Implement Ada val_print'ing for the case where TYPE is
946  a TYPE_CODE_STRUCT or TYPE_CODE_UNION. */
947 
948 static void
950  (struct type *type, const gdb_byte *valaddr, int offset,
951  int offset_aligned, CORE_ADDR address, struct ui_file *stream,
952  int recurse, const struct value *original_value,
953  const struct value_print_options *options,
954  const struct language_defn *language)
955 {
957  {
958  fprintf_filtered (stream, "(...?)");
959  return;
960  }
961 
962  fprintf_filtered (stream, "(");
963 
964  if (print_field_values (type, valaddr, offset_aligned,
965  stream, recurse, original_value, options,
966  0, type, offset_aligned, language) != 0
967  && options->prettyformat)
968  {
969  fprintf_filtered (stream, "\n");
970  print_spaces_filtered (2 * recurse, stream);
971  }
972 
973  fprintf_filtered (stream, ")");
974 }
975 
976 /* Implement Ada val_print'ing for the case where TYPE is
977  a TYPE_CODE_ARRAY. */
978 
979 static void
980 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
981  int offset, int offset_aligned, CORE_ADDR address,
982  struct ui_file *stream, int recurse,
983  const struct value *original_value,
984  const struct value_print_options *options)
985 {
986  /* For an array of characters, print with string syntax. */
987  if (ada_is_string_type (type)
988  && (options->format == 0 || options->format == 's'))
989  {
990  ada_val_print_string (type, valaddr, offset, offset_aligned,
991  address, stream, recurse, original_value,
992  options);
993  return;
994  }
995 
996  fprintf_filtered (stream, "(");
997  print_optional_low_bound (stream, type, options);
998  if (TYPE_FIELD_BITSIZE (type, 0) > 0)
999  val_print_packed_array_elements (type, valaddr, offset_aligned,
1000  0, stream, recurse,
1001  original_value, options);
1002  else
1003  val_print_array_elements (type, valaddr, offset_aligned, address,
1004  stream, recurse, original_value,
1005  options, 0);
1006  fprintf_filtered (stream, ")");
1007 }
1008 
1009 /* Implement Ada val_print'ing for the case where TYPE is
1010  a TYPE_CODE_REF. */
1011 
1012 static void
1013 ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
1014  int offset, int offset_aligned, CORE_ADDR address,
1015  struct ui_file *stream, int recurse,
1016  const struct value *original_value,
1017  const struct value_print_options *options,
1018  const struct language_defn *language)
1019 {
1020  /* For references, the debugger is expected to print the value as
1021  an address if DEREF_REF is null. But printing an address in place
1022  of the object value would be confusing to an Ada programmer.
1023  So, for Ada values, we print the actual dereferenced value
1024  regardless. */
1025  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
1026  struct value *deref_val;
1027  CORE_ADDR deref_val_int;
1028 
1029  if (TYPE_CODE (elttype) == TYPE_CODE_UNDEF)
1030  {
1031  fputs_filtered ("<ref to undefined type>", stream);
1032  return;
1033  }
1034 
1035  deref_val = coerce_ref_if_computed (original_value);
1036  if (deref_val)
1037  {
1038  if (ada_is_tagged_type (value_type (deref_val), 1))
1039  deref_val = ada_tag_value_at_base_address (deref_val);
1040 
1041  common_val_print (deref_val, stream, recurse + 1, options,
1042  language);
1043  return;
1044  }
1045 
1046  deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
1047  if (deref_val_int == 0)
1048  {
1049  fputs_filtered ("(null)", stream);
1050  return;
1051  }
1052 
1053  deref_val
1055  deref_val_int));
1056  if (ada_is_tagged_type (value_type (deref_val), 1))
1057  deref_val = ada_tag_value_at_base_address (deref_val);
1058 
1059  /* Make sure that the object does not have an unreasonable size
1060  before trying to print it. This can happen for instance with
1061  references to dynamic objects whose contents is uninitialized
1062  (Eg: an array whose bounds are not set yet). */
1063  ada_ensure_varsize_limit (value_type (deref_val));
1064 
1065  val_print (value_type (deref_val),
1066  value_contents_for_printing (deref_val),
1067  value_embedded_offset (deref_val),
1068  value_address (deref_val), stream, recurse + 1,
1069  deref_val, options, language);
1070 }
1071 
1072 /* See the comment on ada_val_print. This function differs in that it
1073  does not catch evaluation errors (leaving that to ada_val_print). */
1074 
1075 static void
1076 ada_val_print_1 (struct type *type, const gdb_byte *valaddr,
1077  int offset, CORE_ADDR address,
1078  struct ui_file *stream, int recurse,
1079  const struct value *original_value,
1080  const struct value_print_options *options,
1081  const struct language_defn *language)
1082 {
1083  int offset_aligned;
1084 
1085  type = ada_check_typedef (type);
1086 
1087  if (ada_is_array_descriptor_type (type)
1089  && TYPE_CODE (type) != TYPE_CODE_PTR))
1090  {
1091  ada_val_print_gnat_array (type, valaddr, offset, address,
1092  stream, recurse, original_value,
1093  options, language);
1094  return;
1095  }
1096 
1097  offset_aligned = offset + ada_aligned_value_addr (type, valaddr) - valaddr;
1098  type = printable_val_type (type, valaddr + offset_aligned);
1099  type = resolve_dynamic_type (type, valaddr + offset_aligned,
1100  address + offset_aligned);
1101 
1102  switch (TYPE_CODE (type))
1103  {
1104  default:
1105  val_print (type, valaddr, offset, address, stream, recurse,
1106  original_value, options, language_def (language_c));
1107  break;
1108 
1109  case TYPE_CODE_PTR:
1110  ada_val_print_ptr (type, valaddr, offset, offset_aligned,
1111  address, stream, recurse, original_value,
1112  options, language);
1113  break;
1114 
1115  case TYPE_CODE_INT:
1116  case TYPE_CODE_RANGE:
1117  ada_val_print_num (type, valaddr, offset, offset_aligned,
1118  address, stream, recurse, original_value,
1119  options, language);
1120  break;
1121 
1122  case TYPE_CODE_ENUM:
1123  ada_val_print_enum (type, valaddr, offset, offset_aligned,
1124  address, stream, recurse, original_value,
1125  options, language);
1126  break;
1127 
1128  case TYPE_CODE_FLT:
1129  ada_val_print_flt (type, valaddr, offset, offset_aligned,
1130  address, stream, recurse, original_value,
1131  options, language);
1132  break;
1133 
1134  case TYPE_CODE_UNION:
1135  case TYPE_CODE_STRUCT:
1136  ada_val_print_struct_union (type, valaddr, offset, offset_aligned,
1137  address, stream, recurse,
1138  original_value, options, language);
1139  break;
1140 
1141  case TYPE_CODE_ARRAY:
1142  ada_val_print_array (type, valaddr, offset, offset_aligned,
1143  address, stream, recurse, original_value,
1144  options);
1145  return;
1146 
1147  case TYPE_CODE_REF:
1148  ada_val_print_ref (type, valaddr, offset, offset_aligned,
1149  address, stream, recurse, original_value,
1150  options, language);
1151  break;
1152  }
1153 }
1154 
1155 /* See val_print for a description of the various parameters of this
1156  function; they are identical. */
1157 
1158 void
1159 ada_val_print (struct type *type, const gdb_byte *valaddr,
1160  int embedded_offset, CORE_ADDR address,
1161  struct ui_file *stream, int recurse,
1162  const struct value *val,
1163  const struct value_print_options *options)
1164 {
1165 
1166  /* XXX: this catches QUIT/ctrl-c as well. Isn't that busted? */
1167  TRY
1168  {
1169  ada_val_print_1 (type, valaddr, embedded_offset, address,
1170  stream, recurse, val, options,
1172  }
1173  CATCH (except, RETURN_MASK_ALL)
1174  {
1175  }
1176  END_CATCH
1177 }
1178 
1179 void
1180 ada_value_print (struct value *val0, struct ui_file *stream,
1181  const struct value_print_options *options)
1182 {
1183  struct value *val = ada_to_fixed_value (val0);
1184  CORE_ADDR address = value_address (val);
1185  struct type *type = ada_check_typedef (value_enclosing_type (val));
1186  struct value_print_options opts;
1187 
1188  /* If it is a pointer, indicate what it points to. */
1189  if (TYPE_CODE (type) == TYPE_CODE_PTR)
1190  {
1191  /* Hack: don't print (char *) for char strings. Their
1192  type is indicated by the quoted string anyway. */
1193  if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
1194  || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
1195  || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
1196  {
1197  fprintf_filtered (stream, "(");
1198  type_print (type, "", stream, -1);
1199  fprintf_filtered (stream, ") ");
1200  }
1201  }
1202  else if (ada_is_array_descriptor_type (type))
1203  {
1204  /* We do not print the type description unless TYPE is an array
1205  access type (this is encoded by the compiler as a typedef to
1206  a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
1207  if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1208  {
1209  fprintf_filtered (stream, "(");
1210  type_print (type, "", stream, -1);
1211  fprintf_filtered (stream, ") ");
1212  }
1213  }
1214  else if (ada_is_bogus_array_descriptor (type))
1215  {
1216  fprintf_filtered (stream, "(");
1217  type_print (type, "", stream, -1);
1218  fprintf_filtered (stream, ") (...?)");
1219  return;
1220  }
1221 
1222  opts = *options;
1223  opts.deref_ref = 1;
1225  value_embedded_offset (val), address,
1226  stream, 0, val, &opts, current_language);
1227 }
static int char_at(const gdb_byte *string, int i, int type_len, enum bfd_endian byte_order)
Definition: ada-valprint.c:282
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 struct type * printable_val_type(struct type *type, const gdb_byte *valaddr)
Definition: ada-valprint.c:248
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
int ada_is_character_type(struct type *type)
Definition: ada-lang.c:9088
void annotate_field_value(void)
Definition: annotate.c:274
struct value * value_mark(void)
Definition: value.c:1499
unsigned int repeat_count_threshold
Definition: valprint.h:57
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
int ada_is_bogus_array_descriptor(struct type *type)
Definition: ada-lang.c:1925
void value_free_to_mark(struct value *mark)
Definition: value.c:1551
const char * ada_tag_name(struct value *tag)
Definition: ada-lang.c:6712
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3529
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
void xfree(void *)
Definition: common-utils.c:97
struct value * ada_value_primitive_packed_val(struct value *obj, const gdb_byte *valaddr, long offset, int bit_offset, int bit_size, struct type *type)
Definition: ada-lang.c:2390
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1246
void ada_value_print(struct value *val0, struct ui_file *stream, const struct value_print_options *options)
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2914
void warning(const char *fmt,...)
Definition: errors.c:26
struct type * ada_to_fixed_type(struct type *type, const gdb_byte *valaddr, CORE_ADDR address, struct value *dval, int check_tag)
Definition: ada-lang.c:8826
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
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
const struct language_defn * language_def(enum language lang)
Definition: language.c:471
void val_print_type_code_int(struct type *type, const gdb_byte *valaddr, struct ui_file *stream)
Definition: valprint.c:898
void print_floating(const gdb_byte *valaddr, struct type *type, struct ui_file *stream)
Definition: valprint.c:1074
static int print_field_values(struct type *, const gdb_byte *, int, struct ui_file *, int, const struct value *, const struct value_print_options *, int, struct type *, int, const struct language_defn *)
Definition: ada-valprint.c:574
struct value * coerce_ref(struct value *arg)
Definition: value.c:3688
static void val_print_packed_array_elements(struct type *type, const gdb_byte *valaddr, int offset, int bitoffset, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options)
Definition: ada-valprint.c:121
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
void annotate_field_name_end(void)
Definition: annotate.c:267
#define _(String)
Definition: gdb_locale.h:40
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1173
struct type * ada_check_typedef(struct type *type)
Definition: ada-lang.c:8932
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1372
#define END_CATCH
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
static void ada_val_print_struct_union(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:950
enum val_prettyformat prettyformat
Definition: valprint.h:28
const gdb_byte * ada_aligned_value_addr(struct type *type, const gdb_byte *valaddr)
Definition: ada-lang.c:9222
int ada_is_string_type(struct type *type)
Definition: ada-lang.c:9112
void ada_print_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition: ada-valprint.c:361
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
#define TRY
struct value * ada_coerce_to_simple_array_ptr(struct value *arr)
Definition: ada-lang.c:2023
const char *const name
Definition: aarch64-tdep.c:68
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define CATCH(EXCEPTION, MASK)
void ada_val_print(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)
static void ada_val_print_ptr(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:767
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
int ada_is_tagged_type(struct type *type, int refok)
Definition: ada-lang.c:6467
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
int ada_name_prefix_len(const char *name)
Definition: ada-lang.c:634
void annotate_elt_rep(unsigned int repcount)
Definition: annotate.c:556
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
int ada_is_system_address_type(struct type *type)
Definition: ada-lang.c:11249
struct type * value_enclosing_type(struct value *value)
Definition: value.c:1098
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define TYPE_FIELD_IGNORE(thistype, n)
Definition: gdbtypes.h:1402
void annotate_array_section_begin(int idx, struct type *elttype)
Definition: annotate.c:545
struct value * coerce_ref_if_computed(const struct value *arg)
Definition: value.c:3652
int ada_is_wrapper_field(struct type *type, int field_num)
Definition: ada-lang.c:6793
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
char * n_spaces(int n)
Definition: utils.c:2442
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
int ada_is_array_descriptor_type(struct type *type)
Definition: ada-lang.c:1907
void wrap_here(char *indent)
Definition: utils.c:1930
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1378
static char encoding[]
Definition: remote-mips.c:2988
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
void annotate_elt_rep_end(void)
Definition: annotate.c:563
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2797
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1371
int ada_is_constrained_packed_array_type(struct type *type)
Definition: ada-lang.c:2095
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
struct value * ada_tag_value_at_base_address(struct value *obj)
Definition: ada-lang.c:6557
void annotate_array_section_end(void)
Definition: annotate.c:577
int ada_is_tag_type(struct type *type)
Definition: ada-lang.c:6475
Definition: value.c:172
int ada_is_fixed_point_type(struct type *type)
Definition: ada-lang.c:11241
int ada_which_variant_applies(struct type *var_type, struct type *outer_type, const gdb_byte *outer_valaddr)
Definition: ada-lang.c:7496
int ada_is_ignored_field(struct type *type, int field_num)
Definition: ada-lang.c:6426
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2464
bfd_byte gdb_byte
Definition: common-types.h:38
static void ada_val_print_gnat_array(struct type *type, const gdb_byte *valaddr, int offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:732
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
int value_contents_eq(const struct value *val1, int offset1, const struct value *val2, int offset2, int length)
Definition: value.c:865
const struct language_defn * current_language
Definition: language.c:85
static void ada_print_floating(const gdb_byte *valaddr, struct type *type, struct ui_file *stream)
Definition: ada-valprint.c:298
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1016
struct type * ada_aligned_type(struct type *type)
Definition: ada-lang.c:9209
void ada_emit_char(int c, struct type *type, struct ui_file *stream, int quoter, int type_len)
Definition: ada-valprint.c:258
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
void ada_printstr(struct ui_file *stream, struct type *type, const gdb_byte *string, unsigned int length, const char *encoding, int force_ellipses, const struct value_print_options *options)
Definition: ada-valprint.c:523
struct type * resolve_dynamic_type(struct type *type, const gdb_byte *valaddr, CORE_ADDR addr)
Definition: gdbtypes.c:2143
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
struct value * ada_coerce_to_simple_array(struct value *arr)
Definition: ada-lang.c:2044
#define HAVE_CPLUS_STRUCT(type)
Definition: gdbtypes.h:1202
int ada_is_variant_part(struct type *type, int field_num)
Definition: ada-lang.c:6809
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
struct value * ada_value_ind(struct value *val0)
Definition: ada-lang.c:7570
static void ada_val_print_enum(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:884
static void ada_val_print_array(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options)
Definition: ada-valprint.c:980
void annotate_elt(void)
Definition: annotate.c:570
static void ada_val_print_string(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options)
Definition: ada-valprint.c:684
static int print_variant_part(struct type *type, int field_num, const gdb_byte *valaddr, int offset, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options, int comma_needed, struct type *outer_type, int outer_offset, const struct language_defn *language)
Definition: ada-valprint.c:533
void annotate_field_end(void)
Definition: annotate.c:281
const char * ada_enum_name(const char *name)
Definition: ada-lang.c:9238
static void adjust_type_signedness(struct type *type)
Definition: ada-valprint.c:46
int value_embedded_offset(struct value *value)
Definition: value.c:1388
struct type * value_type(const struct value *value)
Definition: value.c:1021
void ada_printchar(int c, struct type *type, struct ui_file *stream)
Definition: ada-valprint.c:349
static void ada_val_print_flt(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:928
unsigned int print_max
Definition: valprint.h:53
void ada_ensure_varsize_limit(const struct type *type)
Definition: ada-lang.c:742
DOUBLEST ada_fixed_to_float(struct type *type, LONGEST x)
Definition: ada-lang.c:11306
struct value * ada_to_fixed_value(struct value *val)
Definition: ada-lang.c:8993
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define HOST_CHAR_BIT
Definition: host-defs.h:40
#define LA_PRINT_CHAR(ch, type, stream)
Definition: language.h:494
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
#define QUIT
Definition: defs.h:160
static void ada_val_print_num(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
Definition: ada-valprint.c:794
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
static void printstr(struct ui_file *stream, struct type *elttype, const gdb_byte *string, unsigned int length, int force_ellipses, int type_len, const struct value_print_options *options)
Definition: ada-valprint.c:443
static int print_optional_low_bound(struct ui_file *stream, struct type *type, const struct value_print_options *options)
Definition: ada-valprint.c:59
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:978
int get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition: gdbtypes.c:899
void val_print(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, const struct language_defn *language)
Definition: valprint.c:737
void error(const char *fmt,...)
Definition: errors.c:38
void maybe_print_array_index(struct type *index_type, LONGEST index, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1596
static void ada_val_print_ref(struct type *type, const gdb_byte *valaddr, int offset, int offset_aligned, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
static void ada_val_print_1(struct type *type, const gdb_byte *valaddr, int offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *original_value, const struct value_print_options *options, const struct language_defn *language)
int embedded_offset
Definition: value.c:312
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
long long LONGEST
Definition: common-types.h:52
void annotate_field_begin(struct type *type)
Definition: annotate.c:256
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
const ULONGEST const LONGEST len
Definition: target.h:309