OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [ada-valprint.c] - Blame information for rev 857

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Support for printing Ada values for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002,
4
   2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
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.
12
 
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.
17
 
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/>.  */
20
 
21
#include <ctype.h>
22
#include "defs.h"
23
#include "gdb_string.h"
24
#include "symtab.h"
25
#include "gdbtypes.h"
26
#include "expression.h"
27
#include "value.h"
28
#include "demangle.h"
29
#include "valprint.h"
30
#include "language.h"
31
#include "annotate.h"
32
#include "ada-lang.h"
33
#include "c-lang.h"
34
#include "infcall.h"
35
#include "exceptions.h"
36
 
37
/* Encapsulates arguments to ada_val_print.  */
38
struct ada_val_print_args
39
{
40
  struct type *type;
41
  const gdb_byte *valaddr0;
42
  int embedded_offset;
43
  CORE_ADDR address;
44
  struct ui_file *stream;
45
  int format;
46
  int deref_ref;
47
  int recurse;
48
  enum val_prettyprint pretty;
49
};
50
 
51
static void print_record (struct type *, const gdb_byte *, struct ui_file *,
52
                          int, int, enum val_prettyprint);
53
 
54
static int print_field_values (struct type *, const gdb_byte *,
55
                               struct ui_file *, int, int,
56
                               enum val_prettyprint, int, struct type *,
57
                               const gdb_byte *);
58
 
59
static void adjust_type_signedness (struct type *);
60
 
61
static int ada_val_print_stub (void *args0);
62
 
63
static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
64
                            struct ui_file *, int, int, int,
65
                            enum val_prettyprint);
66
 
67
 
68
/* Make TYPE unsigned if its range of values includes no negatives.  */
69
static void
70
adjust_type_signedness (struct type *type)
71
{
72
  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
73
      && TYPE_LOW_BOUND (type) >= 0)
74
    TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
75
}
76
 
77
/* Assuming TYPE is a simple, non-empty array type, prints its lower bound
78
   on STREAM, if non-standard (i.e., other than 1 for numbers, other
79
   than lower bound of index type for enumerated type).  Returns 1
80
   if something printed, otherwise 0.  */
81
 
82
static int
83
print_optional_low_bound (struct ui_file *stream, struct type *type)
84
{
85
  struct type *index_type;
86
  long low_bound;
87
 
88
  if (print_array_indexes_p ())
89
    return 0;
90
 
91
  if (!get_array_low_bound (type, &low_bound))
92
    return 0;
93
 
94
  index_type = TYPE_INDEX_TYPE (type);
95
 
96
  if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
97
    {
98
      /* We need to know what the base type is, in order to do the
99
         appropriate check below.  Otherwise, if this is a subrange
100
         of an enumerated type, where the underlying value of the
101
         first element is typically 0, we might test the low bound
102
         against the wrong value.  */
103
      index_type = TYPE_TARGET_TYPE (index_type);
104
    }
105
 
106
  switch (TYPE_CODE (index_type))
107
    {
108
    case TYPE_CODE_ENUM:
109
      if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
110
        return 0;
111
      break;
112
    case TYPE_CODE_UNDEF:
113
      index_type = builtin_type_long;
114
      /* FALL THROUGH */
115
    default:
116
      if (low_bound == 1)
117
        return 0;
118
      break;
119
    }
120
 
121
  ada_print_scalar (index_type, (LONGEST) low_bound, stream);
122
  fprintf_filtered (stream, " => ");
123
  return 1;
124
}
125
 
126
/*  Version of val_print_array_elements for GNAT-style packed arrays.
127
    Prints elements of packed array of type TYPE at bit offset
128
    BITOFFSET from VALADDR on STREAM.  Formats according to FORMAT and
129
    separates with commas.  RECURSE is the recursion (nesting) level.
130
    If PRETTY, uses "prettier" format.  TYPE must have been decoded (as
131
    by ada_coerce_to_simple_array).  */
132
 
133
static void
134
val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
135
                                 int bitoffset, struct ui_file *stream,
136
                                 int format, int recurse,
137
                                 enum val_prettyprint pretty)
138
{
139
  unsigned int i;
140
  unsigned int things_printed = 0;
141
  unsigned len;
142
  struct type *elttype, *index_type;
143
  unsigned eltlen;
144
  unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
145
  struct value *mark = value_mark ();
146
  LONGEST low = 0;
147
 
148
  elttype = TYPE_TARGET_TYPE (type);
149
  eltlen = TYPE_LENGTH (check_typedef (elttype));
150
  index_type = TYPE_INDEX_TYPE (type);
151
 
152
  {
153
    LONGEST high;
154
    if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
155
      len = 1;
156
    else
157
      len = high - low + 1;
158
  }
159
 
160
  i = 0;
161
  annotate_array_section_begin (i, elttype);
162
 
163
  while (i < len && things_printed < print_max)
164
    {
165
      struct value *v0, *v1;
166
      int i0;
167
 
168
      if (i != 0)
169
        {
170
          if (prettyprint_arrays)
171
            {
172
              fprintf_filtered (stream, ",\n");
173
              print_spaces_filtered (2 + 2 * recurse, stream);
174
            }
175
          else
176
            {
177
              fprintf_filtered (stream, ", ");
178
            }
179
        }
180
      wrap_here (n_spaces (2 + 2 * recurse));
181
      maybe_print_array_index (index_type, i + low, stream, format, pretty);
182
 
183
      i0 = i;
184
      v0 = ada_value_primitive_packed_val (NULL, valaddr,
185
                                           (i0 * bitsize) / HOST_CHAR_BIT,
186
                                           (i0 * bitsize) % HOST_CHAR_BIT,
187
                                           bitsize, elttype);
188
      while (1)
189
        {
190
          i += 1;
191
          if (i >= len)
192
            break;
193
          v1 = ada_value_primitive_packed_val (NULL, valaddr,
194
                                               (i * bitsize) / HOST_CHAR_BIT,
195
                                               (i * bitsize) % HOST_CHAR_BIT,
196
                                               bitsize, elttype);
197
          if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
198
            break;
199
        }
200
 
201
      if (i - i0 > repeat_count_threshold)
202
        {
203
          val_print (elttype, value_contents (v0), 0, 0, stream, format,
204
                     0, recurse + 1, pretty);
205
          annotate_elt_rep (i - i0);
206
          fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
207
          annotate_elt_rep_end ();
208
 
209
        }
210
      else
211
        {
212
          int j;
213
          for (j = i0; j < i; j += 1)
214
            {
215
              if (j > i0)
216
                {
217
                  if (prettyprint_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, format, pretty);
229
                }
230
              val_print (elttype, value_contents (v0), 0, 0, stream, format,
231
                         0, recurse + 1, pretty);
232
              annotate_elt ();
233
            }
234
        }
235
      things_printed += i - i0;
236
    }
237
  annotate_array_section_end ();
238
  if (i < len)
239
    {
240
      fprintf_filtered (stream, "...");
241
    }
242
 
243
  value_free_to_mark (mark);
244
}
245
 
246
static struct type *
247
printable_val_type (struct type *type, const gdb_byte *valaddr)
248
{
249
  return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
250
}
251
 
252
/* Print the character C on STREAM as part of the contents of a literal
253
   string whose delimiter is QUOTER.  TYPE_LEN is the length in bytes
254
   (1 or 2) of the character.  */
255
 
256
void
257
ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
258
{
259
  if (type_len != 2)
260
    type_len = 1;
261
 
262
  c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
263
 
264
  if (isascii (c) && isprint (c))
265
    {
266
      if (c == quoter && c == '"')
267
        fprintf_filtered (stream, "\"\"");
268
      else
269
        fprintf_filtered (stream, "%c", c);
270
    }
271
  else
272
    fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
273
}
274
 
275
/* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
276
   or 2) of a character.  */
277
 
278
static int
279
char_at (const gdb_byte *string, int i, int type_len)
280
{
281
  if (type_len == 1)
282
    return string[i];
283
  else
284
    return (int) extract_unsigned_integer (string + 2 * i, 2);
285
}
286
 
287
/* Wrapper around memcpy to make it legal argument to ui_file_put */
288
static void
289
ui_memcpy (void *dest, const char *buffer, long len)
290
{
291
  memcpy (dest, buffer, (size_t) len);
292
  ((char *) dest)[len] = '\0';
293
}
294
 
295
/* Print a floating-point value of type TYPE, pointed to in GDB by
296
   VALADDR, on STREAM.  Use Ada formatting conventions: there must be
297
   a decimal point, and at least one digit before and after the
298
   point.  We use GNAT format for NaNs and infinities.  */
299
static void
300
ada_print_floating (const gdb_byte *valaddr, struct type *type,
301
                    struct ui_file *stream)
302
{
303
  char buffer[64];
304
  char *s, *result;
305
  int len;
306
  struct ui_file *tmp_stream = mem_fileopen ();
307
  struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
308
 
309
  print_floating (valaddr, type, tmp_stream);
310
  ui_file_put (tmp_stream, ui_memcpy, buffer);
311
  do_cleanups (cleanups);
312
 
313
  result = buffer;
314
  len = strlen (result);
315
 
316
  /* Modify for Ada rules.  */
317
 
318
  s = strstr (result, "inf");
319
  if (s == NULL)
320
    s = strstr (result, "Inf");
321
  if (s == NULL)
322
    s = strstr (result, "INF");
323
  if (s != NULL)
324
    strcpy (s, "Inf");
325
 
326
  if (s == NULL)
327
    {
328
      s = strstr (result, "nan");
329
      if (s == NULL)
330
        s = strstr (result, "NaN");
331
      if (s == NULL)
332
        s = strstr (result, "Nan");
333
      if (s != NULL)
334
        {
335
          s[0] = s[2] = 'N';
336
          if (result[0] == '-')
337
            result += 1;
338
        }
339
    }
340
 
341
  if (s == NULL && strchr (result, '.') == NULL)
342
    {
343
      s = strchr (result, 'e');
344
      if (s == NULL)
345
        fprintf_filtered (stream, "%s.0", result);
346
      else
347
        fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
348
      return;
349
    }
350
  fprintf_filtered (stream, "%s", result);
351
}
352
 
353
void
354
ada_printchar (int c, struct ui_file *stream)
355
{
356
  fputs_filtered ("'", stream);
357
  ada_emit_char (c, stream, '\'', 1);
358
  fputs_filtered ("'", stream);
359
}
360
 
361
/* [From print_type_scalar in typeprint.c].   Print VAL on STREAM in a
362
   form appropriate for TYPE.  */
363
 
364
void
365
ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
366
{
367
  unsigned int i;
368
  unsigned len;
369
 
370
  type = ada_check_typedef (type);
371
 
372
  switch (TYPE_CODE (type))
373
    {
374
 
375
    case TYPE_CODE_ENUM:
376
      len = TYPE_NFIELDS (type);
377
      for (i = 0; i < len; i++)
378
        {
379
          if (TYPE_FIELD_BITPOS (type, i) == val)
380
            {
381
              break;
382
            }
383
        }
384
      if (i < len)
385
        {
386
          fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
387
        }
388
      else
389
        {
390
          print_longest (stream, 'd', 0, val);
391
        }
392
      break;
393
 
394
    case TYPE_CODE_INT:
395
      print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
396
      break;
397
 
398
    case TYPE_CODE_CHAR:
399
      LA_PRINT_CHAR ((unsigned char) val, stream);
400
      break;
401
 
402
    case TYPE_CODE_BOOL:
403
      fprintf_filtered (stream, val ? "true" : "false");
404
      break;
405
 
406
    case TYPE_CODE_RANGE:
407
      ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
408
      return;
409
 
410
    case TYPE_CODE_UNDEF:
411
    case TYPE_CODE_PTR:
412
    case TYPE_CODE_ARRAY:
413
    case TYPE_CODE_STRUCT:
414
    case TYPE_CODE_UNION:
415
    case TYPE_CODE_FUNC:
416
    case TYPE_CODE_FLT:
417
    case TYPE_CODE_VOID:
418
    case TYPE_CODE_SET:
419
    case TYPE_CODE_STRING:
420
    case TYPE_CODE_ERROR:
421
    case TYPE_CODE_MEMBERPTR:
422
    case TYPE_CODE_METHODPTR:
423
    case TYPE_CODE_METHOD:
424
    case TYPE_CODE_REF:
425
      warning (_("internal error: unhandled type in ada_print_scalar"));
426
      break;
427
 
428
    default:
429
      error (_("Invalid type code in symbol table."));
430
    }
431
  gdb_flush (stream);
432
}
433
 
434
/* Print the character string STRING, printing at most LENGTH characters.
435
   Printing stops early if the number hits print_max; repeat counts
436
   are printed as appropriate.  Print ellipses at the end if we
437
   had to stop before printing LENGTH characters, or if
438
   FORCE_ELLIPSES.   TYPE_LEN is the length (1 or 2) of the character type.
439
 */
440
 
441
static void
442
printstr (struct ui_file *stream, const gdb_byte *string,
443
          unsigned int length, int force_ellipses, int type_len)
444
{
445
  unsigned int i;
446
  unsigned int things_printed = 0;
447
  int in_quotes = 0;
448
  int need_comma = 0;
449
 
450
  if (length == 0)
451
    {
452
      fputs_filtered ("\"\"", stream);
453
      return;
454
    }
455
 
456
  for (i = 0; i < length && things_printed < print_max; i += 1)
457
    {
458
      /* Position of the character we are examining
459
         to see whether it is repeated.  */
460
      unsigned int rep1;
461
      /* Number of repetitions we have detected so far.  */
462
      unsigned int reps;
463
 
464
      QUIT;
465
 
466
      if (need_comma)
467
        {
468
          fputs_filtered (", ", stream);
469
          need_comma = 0;
470
        }
471
 
472
      rep1 = i + 1;
473
      reps = 1;
474
      while (rep1 < length
475
             && char_at (string, rep1, type_len) == char_at (string, i,
476
                                                             type_len))
477
        {
478
          rep1 += 1;
479
          reps += 1;
480
        }
481
 
482
      if (reps > repeat_count_threshold)
483
        {
484
          if (in_quotes)
485
            {
486
              if (inspect_it)
487
                fputs_filtered ("\\\", ", stream);
488
              else
489
                fputs_filtered ("\", ", stream);
490
              in_quotes = 0;
491
            }
492
          fputs_filtered ("'", stream);
493
          ada_emit_char (char_at (string, i, type_len), stream, '\'',
494
                         type_len);
495
          fputs_filtered ("'", stream);
496
          fprintf_filtered (stream, _(" <repeats %u times>"), reps);
497
          i = rep1 - 1;
498
          things_printed += repeat_count_threshold;
499
          need_comma = 1;
500
        }
501
      else
502
        {
503
          if (!in_quotes)
504
            {
505
              if (inspect_it)
506
                fputs_filtered ("\\\"", stream);
507
              else
508
                fputs_filtered ("\"", stream);
509
              in_quotes = 1;
510
            }
511
          ada_emit_char (char_at (string, i, type_len), stream, '"',
512
                         type_len);
513
          things_printed += 1;
514
        }
515
    }
516
 
517
  /* Terminate the quotes if necessary.  */
518
  if (in_quotes)
519
    {
520
      if (inspect_it)
521
        fputs_filtered ("\\\"", stream);
522
      else
523
        fputs_filtered ("\"", stream);
524
    }
525
 
526
  if (force_ellipses || i < length)
527
    fputs_filtered ("...", stream);
528
}
529
 
530
void
531
ada_printstr (struct ui_file *stream, const gdb_byte *string,
532
              unsigned int length, int width, int force_ellipses)
533
{
534
  printstr (stream, string, length, force_ellipses, width);
535
}
536
 
537
 
538
/* Print data of type TYPE located at VALADDR (within GDB), which came from
539
   the inferior at address ADDRESS, onto stdio stream STREAM according to
540
   FORMAT (a letter as for the printf % codes or 0 for natural format).
541
   The data at VALADDR is in target byte order.
542
 
543
   If the data is printed as a string, returns the number of string characters
544
   printed.
545
 
546
   If DEREF_REF is nonzero, then dereference references, otherwise just print
547
   them like pointers.
548
 
549
   RECURSE indicates the amount of indentation to supply before
550
   continuation lines; this amount is roughly twice the value of RECURSE.
551
 
552
   When PRETTY is non-zero, prints record fields on separate lines.
553
   (For some reason, the current version of gdb instead uses a global
554
   variable---prettyprint_arrays--- to causes a similar effect on
555
   arrays.)  */
556
 
557
int
558
ada_val_print (struct type *type, const gdb_byte *valaddr0,
559
               int embedded_offset, CORE_ADDR address,
560
               struct ui_file *stream, int format, int deref_ref,
561
               int recurse, enum val_prettyprint pretty)
562
{
563
  struct ada_val_print_args args;
564
  args.type = type;
565
  args.valaddr0 = valaddr0;
566
  args.embedded_offset = embedded_offset;
567
  args.address = address;
568
  args.stream = stream;
569
  args.format = format;
570
  args.deref_ref = deref_ref;
571
  args.recurse = recurse;
572
  args.pretty = pretty;
573
 
574
  return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
575
}
576
 
577
/* Helper for ada_val_print; used as argument to catch_errors to
578
   unmarshal the arguments to ada_val_print_1, which does the work.  */
579
static int
580
ada_val_print_stub (void *args0)
581
{
582
  struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
583
  return ada_val_print_1 (argsp->type, argsp->valaddr0,
584
                          argsp->embedded_offset, argsp->address,
585
                          argsp->stream, argsp->format, argsp->deref_ref,
586
                          argsp->recurse, argsp->pretty);
587
}
588
 
589
/* See the comment on ada_val_print.  This function differs in that it
590
 * does not catch evaluation errors (leaving that to ada_val_print).  */
591
 
592
static int
593
ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
594
                 int embedded_offset, CORE_ADDR address,
595
                 struct ui_file *stream, int format,
596
                 int deref_ref, int recurse, enum val_prettyprint pretty)
597
{
598
  unsigned int len;
599
  int i;
600
  struct type *elttype;
601
  unsigned int eltlen;
602
  LONGEST val;
603
  const gdb_byte *valaddr = valaddr0 + embedded_offset;
604
 
605
  type = ada_check_typedef (type);
606
 
607
  if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
608
    {
609
      int retn;
610
      struct value *mark = value_mark ();
611
      struct value *val;
612
      val = value_from_contents_and_address (type, valaddr, address);
613
      val = ada_coerce_to_simple_array_ptr (val);
614
      if (val == NULL)
615
        {
616
          fprintf_filtered (stream, "(null)");
617
          retn = 0;
618
        }
619
      else
620
        retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
621
                                VALUE_ADDRESS (val), stream, format,
622
                                deref_ref, recurse, pretty);
623
      value_free_to_mark (mark);
624
      return retn;
625
    }
626
 
627
  valaddr = ada_aligned_value_addr (type, valaddr);
628
  embedded_offset -= valaddr - valaddr0 - embedded_offset;
629
  type = printable_val_type (type, valaddr);
630
 
631
  switch (TYPE_CODE (type))
632
    {
633
    default:
634
      return c_val_print (type, valaddr0, embedded_offset, address, stream,
635
                          format, deref_ref, recurse, pretty);
636
 
637
    case TYPE_CODE_PTR:
638
      {
639
        int ret = c_val_print (type, valaddr0, embedded_offset, address,
640
                               stream, format, deref_ref, recurse, pretty);
641
        if (ada_is_tag_type (type))
642
          {
643
            struct value *val =
644
              value_from_contents_and_address (type, valaddr, address);
645
            const char *name = ada_tag_name (val);
646
            if (name != NULL)
647
              fprintf_filtered (stream, " (%s)", name);
648
            return 0;
649
        }
650
        return ret;
651
      }
652
 
653
    case TYPE_CODE_INT:
654
    case TYPE_CODE_RANGE:
655
      if (ada_is_fixed_point_type (type))
656
        {
657
          LONGEST v = unpack_long (type, valaddr);
658
          int len = TYPE_LENGTH (type);
659
 
660
          fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
661
                            (double) ada_fixed_to_float (type, v));
662
          return 0;
663
        }
664
      else if (ada_is_vax_floating_type (type))
665
        {
666
          struct value *val =
667
            value_from_contents_and_address (type, valaddr, address);
668
          struct value *func = ada_vax_float_print_function (type);
669
          if (func != 0)
670
            {
671
              static struct type *parray_of_char = NULL;
672
              struct value *printable_val;
673
 
674
              if (parray_of_char == NULL)
675
                parray_of_char =
676
                  make_pointer_type
677
                  (create_array_type
678
                   (NULL, builtin_type_char,
679
                    create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
680
 
681
              printable_val =
682
                value_ind (value_cast (parray_of_char,
683
                                       call_function_by_hand (func, 1,
684
                                                              &val)));
685
 
686
              fprintf_filtered (stream, "%s", value_contents (printable_val));
687
              return 0;
688
            }
689
          /* No special printing function.  Do as best we can.  */
690
        }
691
      else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
692
        {
693
          struct type *target_type = TYPE_TARGET_TYPE (type);
694
          if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
695
            {
696
              /* Obscure case of range type that has different length from
697
                 its base type.  Perform a conversion, or we will get a
698
                 nonsense value.  Actually, we could use the same
699
                 code regardless of lengths; I'm just avoiding a cast.  */
700
              struct value *v = value_cast (target_type,
701
                                            value_from_contents_and_address
702
                                            (type, valaddr, 0));
703
              return ada_val_print_1 (target_type, value_contents (v), 0, 0,
704
                                      stream, format, 0, recurse + 1, pretty);
705
            }
706
          else
707
            return ada_val_print_1 (TYPE_TARGET_TYPE (type),
708
                                    valaddr0, embedded_offset,
709
                                    address, stream, format, deref_ref,
710
                                    recurse, pretty);
711
        }
712
      else
713
        {
714
          format = format ? format : output_format;
715
          if (format)
716
            {
717
              print_scalar_formatted (valaddr, type, format, 0, stream);
718
            }
719
          else if (ada_is_system_address_type (type))
720
            {
721
              /* FIXME: We want to print System.Address variables using
722
                 the same format as for any access type.  But for some
723
                 reason GNAT encodes the System.Address type as an int,
724
                 so we have to work-around this deficiency by handling
725
                 System.Address values as a special case.  */
726
              fprintf_filtered (stream, "(");
727
              type_print (type, "", stream, -1);
728
              fprintf_filtered (stream, ") ");
729
              fputs_filtered (paddress (extract_typed_address
730
                                        (valaddr, builtin_type_void_data_ptr)),
731
                              stream);
732
            }
733
          else
734
            {
735
              val_print_type_code_int (type, valaddr, stream);
736
              if (ada_is_character_type (type))
737
                {
738
                  fputs_filtered (" ", stream);
739
                  ada_printchar ((unsigned char) unpack_long (type, valaddr),
740
                                 stream);
741
                }
742
            }
743
          return 0;
744
        }
745
 
746
    case TYPE_CODE_ENUM:
747
      if (format)
748
        {
749
          print_scalar_formatted (valaddr, type, format, 0, stream);
750
          break;
751
        }
752
      len = TYPE_NFIELDS (type);
753
      val = unpack_long (type, valaddr);
754
      for (i = 0; i < len; i++)
755
        {
756
          QUIT;
757
          if (val == TYPE_FIELD_BITPOS (type, i))
758
            {
759
              break;
760
            }
761
        }
762
      if (i < len)
763
        {
764
          const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
765
          if (name[0] == '\'')
766
            fprintf_filtered (stream, "%ld %s", (long) val, name);
767
          else
768
            fputs_filtered (name, stream);
769
        }
770
      else
771
        {
772
          print_longest (stream, 'd', 0, val);
773
        }
774
      break;
775
 
776
    case TYPE_CODE_FLAGS:
777
      if (format)
778
          print_scalar_formatted (valaddr, type, format, 0, stream);
779
      else
780
        val_print_type_code_flags (type, valaddr, stream);
781
      break;
782
 
783
    case TYPE_CODE_FLT:
784
      if (format)
785
        return c_val_print (type, valaddr0, embedded_offset, address, stream,
786
                            format, deref_ref, recurse, pretty);
787
      else
788
        ada_print_floating (valaddr0 + embedded_offset, type, stream);
789
      break;
790
 
791
    case TYPE_CODE_UNION:
792
    case TYPE_CODE_STRUCT:
793
      if (ada_is_bogus_array_descriptor (type))
794
        {
795
          fprintf_filtered (stream, "(...?)");
796
          return 0;
797
        }
798
      else
799
        {
800
          print_record (type, valaddr, stream, format, recurse, pretty);
801
          return 0;
802
        }
803
 
804
    case TYPE_CODE_ARRAY:
805
      elttype = TYPE_TARGET_TYPE (type);
806
      if (elttype == NULL)
807
        eltlen = 0;
808
      else
809
        eltlen = TYPE_LENGTH (elttype);
810
      /* FIXME: This doesn't deal with non-empty arrays of
811
         0-length items (not a typical case!) */
812
      if (eltlen == 0)
813
        len = 0;
814
      else
815
        len = TYPE_LENGTH (type) / eltlen;
816
 
817
          /* For an array of chars, print with string syntax.  */
818
      if (ada_is_string_type (type) && (format == 0 || format == 's'))
819
        {
820
          if (prettyprint_arrays)
821
            {
822
              print_spaces_filtered (2 + 2 * recurse, stream);
823
            }
824
          /* If requested, look for the first null char and only print
825
             elements up to it.  */
826
          if (stop_print_at_null)
827
            {
828
              int temp_len;
829
 
830
              /* Look for a NULL char.  */
831
              for (temp_len = 0;
832
                   temp_len < len && temp_len < print_max
833
                     && char_at (valaddr, temp_len, eltlen) != 0;
834
                   temp_len += 1);
835
              len = temp_len;
836
            }
837
 
838
          printstr (stream, valaddr, len, 0, eltlen);
839
        }
840
      else
841
        {
842
          len = 0;
843
          fprintf_filtered (stream, "(");
844
          print_optional_low_bound (stream, type);
845
          if (TYPE_FIELD_BITSIZE (type, 0) > 0)
846
            val_print_packed_array_elements (type, valaddr, 0, stream,
847
                                             format, recurse, pretty);
848
          else
849
            val_print_array_elements (type, valaddr, address, stream,
850
                                      format, deref_ref, recurse,
851
                                      pretty, 0);
852
          fprintf_filtered (stream, ")");
853
        }
854
      gdb_flush (stream);
855
      return len;
856
 
857
    case TYPE_CODE_REF:
858
      /* For references, the debugger is expected to print the value as
859
         an address if DEREF_REF is null.  But printing an address in place
860
         of the object value would be confusing to an Ada programmer.
861
         So, for Ada values, we print the actual dereferenced value
862
         regardless.  */
863
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
864
 
865
      if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
866
        {
867
          LONGEST deref_val_int = (LONGEST)
868
            unpack_pointer (lookup_pointer_type (builtin_type_void),
869
                            valaddr);
870
          if (deref_val_int != 0)
871
            {
872
              struct value *deref_val =
873
                ada_value_ind (value_from_longest
874
                               (lookup_pointer_type (elttype),
875
                                deref_val_int));
876
              val_print (value_type (deref_val),
877
                         value_contents (deref_val), 0,
878
                         VALUE_ADDRESS (deref_val), stream, format,
879
                         deref_ref, recurse + 1, pretty);
880
            }
881
          else
882
            fputs_filtered ("(null)", stream);
883
        }
884
      else
885
        fputs_filtered ("???", stream);
886
 
887
      break;
888
    }
889
  gdb_flush (stream);
890
  return 0;
891
}
892
 
893
static int
894
print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
895
                    struct ui_file *stream, int format, int recurse,
896
                    enum val_prettyprint pretty, int comma_needed,
897
                    struct type *outer_type, const gdb_byte *outer_valaddr)
898
{
899
  struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
900
  int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
901
 
902
  if (which < 0)
903
    return 0;
904
  else
905
    return print_field_values
906
      (TYPE_FIELD_TYPE (var_type, which),
907
       valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
908
       + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
909
       stream, format, recurse, pretty,
910
       comma_needed, outer_type, outer_valaddr);
911
}
912
 
913
int
914
ada_value_print (struct value *val0, struct ui_file *stream, int format,
915
                 enum val_prettyprint pretty)
916
{
917
  const gdb_byte *valaddr = value_contents (val0);
918
  CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
919
  struct type *type =
920
    ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
921
  struct value *val =
922
    value_from_contents_and_address (type, valaddr, address);
923
 
924
  /* If it is a pointer, indicate what it points to.  */
925
  if (TYPE_CODE (type) == TYPE_CODE_PTR)
926
    {
927
      /* Hack:  don't print (char *) for char strings.  Their
928
         type is indicated by the quoted string anyway.  */
929
      if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
930
          || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
931
          || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
932
        {
933
          fprintf_filtered (stream, "(");
934
          type_print (type, "", stream, -1);
935
          fprintf_filtered (stream, ") ");
936
        }
937
    }
938
  else if (ada_is_array_descriptor_type (type))
939
    {
940
      fprintf_filtered (stream, "(");
941
      type_print (type, "", stream, -1);
942
      fprintf_filtered (stream, ") ");
943
    }
944
  else if (ada_is_bogus_array_descriptor (type))
945
    {
946
      fprintf_filtered (stream, "(");
947
      type_print (type, "", stream, -1);
948
      fprintf_filtered (stream, ") (...?)");
949
      return 0;
950
    }
951
 
952
  if (TYPE_CODE (type) == TYPE_CODE_ARRAY
953
      && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == 0
954
      && TYPE_CODE (TYPE_INDEX_TYPE (type)) == TYPE_CODE_RANGE)
955
    {
956
      /* This is an array of zero-length elements, that is an array
957
         of null records.  This array needs to be printed by hand,
958
         as the standard routine to print arrays relies on the size of
959
         the array elements to be nonzero.  This is because it computes
960
         the number of elements in the array by dividing the array size
961
         by the array element size.  */
962
      fprintf_filtered (stream, "(%d .. %d => ())",
963
                        TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
964
                        TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type)));
965
      return 0;
966
    }
967
 
968
  return (val_print (type, value_contents (val), 0, address,
969
                     stream, format, 1, 0, pretty));
970
}
971
 
972
static void
973
print_record (struct type *type, const gdb_byte *valaddr,
974
              struct ui_file *stream, int format, int recurse,
975
              enum val_prettyprint pretty)
976
{
977
  type = ada_check_typedef (type);
978
 
979
  fprintf_filtered (stream, "(");
980
 
981
  if (print_field_values (type, valaddr, stream, format, recurse, pretty,
982
                          0, type, valaddr) != 0 && pretty)
983
    {
984
      fprintf_filtered (stream, "\n");
985
      print_spaces_filtered (2 * recurse, stream);
986
    }
987
 
988
  fprintf_filtered (stream, ")");
989
}
990
 
991
/* Print out fields of value at VALADDR having structure type TYPE.
992
 
993
   TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
994
   same meanings as in ada_print_value and ada_val_print.
995
 
996
   OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
997
   (used to get discriminant values when printing variant parts).
998
 
999
   COMMA_NEEDED is 1 if fields have been printed at the current recursion
1000
   level, so that a comma is needed before any field printed by this
1001
   call.
1002
 
1003
   Returns 1 if COMMA_NEEDED or any fields were printed.  */
1004
 
1005
static int
1006
print_field_values (struct type *type, const gdb_byte *valaddr,
1007
                    struct ui_file *stream, int format, int recurse,
1008
                    enum val_prettyprint pretty, int comma_needed,
1009
                    struct type *outer_type, const gdb_byte *outer_valaddr)
1010
{
1011
  int i, len;
1012
 
1013
  len = TYPE_NFIELDS (type);
1014
 
1015
  for (i = 0; i < len; i += 1)
1016
    {
1017
      if (ada_is_ignored_field (type, i))
1018
        continue;
1019
 
1020
      if (ada_is_wrapper_field (type, i))
1021
        {
1022
          comma_needed =
1023
            print_field_values (TYPE_FIELD_TYPE (type, i),
1024
                                valaddr
1025
                                + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1026
                                stream, format, recurse, pretty,
1027
                                comma_needed, type, valaddr);
1028
          continue;
1029
        }
1030
      else if (ada_is_variant_part (type, i))
1031
        {
1032
          comma_needed =
1033
            print_variant_part (type, i, valaddr,
1034
                                stream, format, recurse, pretty, comma_needed,
1035
                                outer_type, outer_valaddr);
1036
          continue;
1037
        }
1038
 
1039
      if (comma_needed)
1040
        fprintf_filtered (stream, ", ");
1041
      comma_needed = 1;
1042
 
1043
      if (pretty)
1044
        {
1045
          fprintf_filtered (stream, "\n");
1046
          print_spaces_filtered (2 + 2 * recurse, stream);
1047
        }
1048
      else
1049
        {
1050
          wrap_here (n_spaces (2 + 2 * recurse));
1051
        }
1052
      if (inspect_it)
1053
        {
1054
          if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1055
            fputs_filtered ("\"( ptr \"", stream);
1056
          else
1057
            fputs_filtered ("\"( nodef \"", stream);
1058
          fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1059
                                   language_cplus, DMGL_NO_OPTS);
1060
          fputs_filtered ("\" \"", stream);
1061
          fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1062
                                   language_cplus, DMGL_NO_OPTS);
1063
          fputs_filtered ("\") \"", stream);
1064
        }
1065
      else
1066
        {
1067
          annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1068
          fprintf_filtered (stream, "%.*s",
1069
                            ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1070
                            TYPE_FIELD_NAME (type, i));
1071
          annotate_field_name_end ();
1072
          fputs_filtered (" => ", stream);
1073
          annotate_field_value ();
1074
        }
1075
 
1076
      if (TYPE_FIELD_PACKED (type, i))
1077
        {
1078
          struct value *v;
1079
 
1080
          /* Bitfields require special handling, especially due to byte
1081
             order problems.  */
1082
          if (TYPE_CPLUS_SPECIFIC (type) != NULL
1083
              && TYPE_FIELD_IGNORE (type, i))
1084
            {
1085
              fputs_filtered (_("<optimized out or zero length>"), stream);
1086
            }
1087
          else
1088
            {
1089
              int bit_pos = TYPE_FIELD_BITPOS (type, i);
1090
              int bit_size = TYPE_FIELD_BITSIZE (type, i);
1091
 
1092
              adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1093
              v = ada_value_primitive_packed_val (NULL, valaddr,
1094
                                                  bit_pos / HOST_CHAR_BIT,
1095
                                                  bit_pos % HOST_CHAR_BIT,
1096
                                                  bit_size,
1097
                                                  TYPE_FIELD_TYPE (type, i));
1098
              val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1099
                         stream, format, 0, recurse + 1, pretty);
1100
            }
1101
        }
1102
      else
1103
        ada_val_print (TYPE_FIELD_TYPE (type, i),
1104
                       valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1105
                       0, 0, stream, format, 0, recurse + 1, pretty);
1106
      annotate_field_end ();
1107
    }
1108
 
1109
  return comma_needed;
1110
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.