OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [p-valprint.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Support for printing Pascal values for GDB, the GNU debugger.
2
 
3
   Copyright (C) 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009, 2010
4
   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
/* This file is derived from c-valprint.c */
22
 
23
#include "defs.h"
24
#include "gdb_obstack.h"
25
#include "symtab.h"
26
#include "gdbtypes.h"
27
#include "expression.h"
28
#include "value.h"
29
#include "command.h"
30
#include "gdbcmd.h"
31
#include "gdbcore.h"
32
#include "demangle.h"
33
#include "valprint.h"
34
#include "typeprint.h"
35
#include "language.h"
36
#include "target.h"
37
#include "annotate.h"
38
#include "p-lang.h"
39
#include "cp-abi.h"
40
#include "cp-support.h"
41
 
42
 
43
 
44
 
45
/* Print data of type TYPE located at VALADDR (within GDB), which came from
46
   the inferior at address ADDRESS, onto stdio stream STREAM according to
47
   OPTIONS.  The data at VALADDR is in target byte order.
48
 
49
   If the data are a string pointer, returns the number of string characters
50
   printed.  */
51
 
52
 
53
int
54
pascal_val_print (struct type *type, const gdb_byte *valaddr,
55
                  int embedded_offset, CORE_ADDR address,
56
                  struct ui_file *stream, int recurse,
57
                  const struct value_print_options *options)
58
{
59
  struct gdbarch *gdbarch = get_type_arch (type);
60
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
61
  unsigned int i = 0;    /* Number of characters printed */
62
  unsigned len;
63
  struct type *elttype;
64
  unsigned eltlen;
65
  int length_pos, length_size, string_pos;
66
  struct type *char_type;
67
  LONGEST val;
68
  CORE_ADDR addr;
69
 
70
  CHECK_TYPEDEF (type);
71
  switch (TYPE_CODE (type))
72
    {
73
    case TYPE_CODE_ARRAY:
74
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
75
        {
76
          elttype = check_typedef (TYPE_TARGET_TYPE (type));
77
          eltlen = TYPE_LENGTH (elttype);
78
          len = TYPE_LENGTH (type) / eltlen;
79
          if (options->prettyprint_arrays)
80
            {
81
              print_spaces_filtered (2 + 2 * recurse, stream);
82
            }
83
          /* For an array of chars, print with string syntax.  */
84
          if ((eltlen == 1 || eltlen == 2 || eltlen == 4)
85
              && ((TYPE_CODE (elttype) == TYPE_CODE_INT)
86
               || ((current_language->la_language == language_pascal)
87
                   && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
88
              && (options->format == 0 || options->format == 's'))
89
            {
90
              /* If requested, look for the first null char and only print
91
                 elements up to it.  */
92
              if (options->stop_print_at_null)
93
                {
94
                  unsigned int temp_len;
95
 
96
                  /* Look for a NULL char. */
97
                  for (temp_len = 0;
98
                       extract_unsigned_integer (valaddr + embedded_offset +
99
                                                 temp_len * eltlen, eltlen,
100
                                                 byte_order)
101
                       && temp_len < len && temp_len < options->print_max;
102
                       temp_len++);
103
                  len = temp_len;
104
                }
105
 
106
              LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
107
                               valaddr + embedded_offset, len, NULL, 0,
108
                               options);
109
              i = len;
110
            }
111
          else
112
            {
113
              fprintf_filtered (stream, "{");
114
              /* If this is a virtual function table, print the 0th
115
                 entry specially, and the rest of the members normally.  */
116
              if (pascal_object_is_vtbl_ptr_type (elttype))
117
                {
118
                  i = 1;
119
                  fprintf_filtered (stream, "%d vtable entries", len - 1);
120
                }
121
              else
122
                {
123
                  i = 0;
124
                }
125
              val_print_array_elements (type, valaddr + embedded_offset, address, stream,
126
                                        recurse, options, i);
127
              fprintf_filtered (stream, "}");
128
            }
129
          break;
130
        }
131
      /* Array of unspecified length: treat like pointer to first elt.  */
132
      addr = address;
133
      goto print_unpacked_pointer;
134
 
135
    case TYPE_CODE_PTR:
136
      if (options->format && options->format != 's')
137
        {
138
          print_scalar_formatted (valaddr + embedded_offset, type,
139
                                  options, 0, stream);
140
          break;
141
        }
142
      if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
143
        {
144
          /* Print the unmangled name if desired.  */
145
          /* Print vtable entry - we only get here if we ARE using
146
             -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
147
          /* Extract the address, assume that it is unsigned.  */
148
          addr = extract_unsigned_integer (valaddr + embedded_offset,
149
                                           TYPE_LENGTH (type), byte_order);
150
          print_address_demangle (gdbarch, addr, stream, demangle);
151
          break;
152
        }
153
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
154
        {
155
          addr = unpack_pointer (type, valaddr + embedded_offset);
156
        print_unpacked_pointer:
157
          elttype = check_typedef (TYPE_TARGET_TYPE (type));
158
 
159
          if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
160
            {
161
              /* Try to print what function it points to.  */
162
              print_address_demangle (gdbarch, addr, stream, demangle);
163
              /* Return value is irrelevant except for string pointers.  */
164
              return (0);
165
            }
166
 
167
          if (options->addressprint && options->format != 's')
168
            {
169
              fputs_filtered (paddress (gdbarch, addr), stream);
170
            }
171
 
172
          /* For a pointer to char or unsigned char, also print the string
173
             pointed to, unless pointer is null.  */
174
          if (((TYPE_LENGTH (elttype) == 1
175
               && (TYPE_CODE (elttype) == TYPE_CODE_INT
176
                  || TYPE_CODE (elttype) == TYPE_CODE_CHAR))
177
              || ((TYPE_LENGTH (elttype) == 2 || TYPE_LENGTH (elttype) == 4)
178
                  && TYPE_CODE (elttype) == TYPE_CODE_CHAR))
179
              && (options->format == 0 || options->format == 's')
180
              && addr != 0)
181
            {
182
              /* no wide string yet */
183
              i = val_print_string (elttype, addr, -1, stream, options);
184
            }
185
          /* also for pointers to pascal strings */
186
          /* Note: this is Free Pascal specific:
187
             as GDB does not recognize stabs pascal strings
188
             Pascal strings are mapped to records
189
             with lowercase names PM  */
190
          if (is_pascal_string_type (elttype, &length_pos, &length_size,
191
                                     &string_pos, &char_type, NULL)
192
              && addr != 0)
193
            {
194
              ULONGEST string_length;
195
              void *buffer;
196
              buffer = xmalloc (length_size);
197
              read_memory (addr + length_pos, buffer, length_size);
198
              string_length = extract_unsigned_integer (buffer, length_size,
199
                                                        byte_order);
200
              xfree (buffer);
201
              i = val_print_string (char_type ,addr + string_pos, string_length, stream, options);
202
            }
203
          else if (pascal_object_is_vtbl_member (type))
204
            {
205
              /* print vtbl's nicely */
206
              CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
207
 
208
              struct minimal_symbol *msymbol =
209
              lookup_minimal_symbol_by_pc (vt_address);
210
              if ((msymbol != NULL)
211
                  && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
212
                {
213
                  fputs_filtered (" <", stream);
214
                  fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
215
                  fputs_filtered (">", stream);
216
                }
217
              if (vt_address && options->vtblprint)
218
                {
219
                  struct value *vt_val;
220
                  struct symbol *wsym = (struct symbol *) NULL;
221
                  struct type *wtype;
222
                  struct block *block = (struct block *) NULL;
223
                  int is_this_fld;
224
 
225
                  if (msymbol != NULL)
226
                    wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block,
227
                                          VAR_DOMAIN, &is_this_fld);
228
 
229
                  if (wsym)
230
                    {
231
                      wtype = SYMBOL_TYPE (wsym);
232
                    }
233
                  else
234
                    {
235
                      wtype = TYPE_TARGET_TYPE (type);
236
                    }
237
                  vt_val = value_at (wtype, vt_address);
238
                  common_val_print (vt_val, stream, recurse + 1, options,
239
                                    current_language);
240
                  if (options->pretty)
241
                    {
242
                      fprintf_filtered (stream, "\n");
243
                      print_spaces_filtered (2 + 2 * recurse, stream);
244
                    }
245
                }
246
            }
247
 
248
          /* Return number of characters printed, including the terminating
249
             '\0' if we reached the end.  val_print_string takes care including
250
             the terminating '\0' if necessary.  */
251
          return i;
252
        }
253
      break;
254
 
255
    case TYPE_CODE_REF:
256
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
257
      if (options->addressprint)
258
        {
259
          CORE_ADDR addr
260
            = extract_typed_address (valaddr + embedded_offset, type);
261
          fprintf_filtered (stream, "@");
262
          fputs_filtered (paddress (gdbarch, addr), stream);
263
          if (options->deref_ref)
264
            fputs_filtered (": ", stream);
265
        }
266
      /* De-reference the reference.  */
267
      if (options->deref_ref)
268
        {
269
          if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
270
            {
271
              struct value *deref_val =
272
              value_at
273
              (TYPE_TARGET_TYPE (type),
274
               unpack_pointer (type, valaddr + embedded_offset));
275
              common_val_print (deref_val, stream, recurse + 1, options,
276
                                current_language);
277
            }
278
          else
279
            fputs_filtered ("???", stream);
280
        }
281
      break;
282
 
283
    case TYPE_CODE_UNION:
284
      if (recurse && !options->unionprint)
285
        {
286
          fprintf_filtered (stream, "{...}");
287
          break;
288
        }
289
      /* Fall through.  */
290
    case TYPE_CODE_STRUCT:
291
      if (options->vtblprint && pascal_object_is_vtbl_ptr_type (type))
292
        {
293
          /* Print the unmangled name if desired.  */
294
          /* Print vtable entry - we only get here if NOT using
295
             -fvtable_thunks.  (Otherwise, look under TYPE_CODE_PTR.) */
296
          /* Extract the address, assume that it is unsigned.  */
297
          print_address_demangle
298
            (gdbarch,
299
             extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8,
300
                                       TYPE_LENGTH (TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET)), byte_order),
301
             stream, demangle);
302
        }
303
      else
304
        {
305
          if (is_pascal_string_type (type, &length_pos, &length_size,
306
                                     &string_pos, &char_type, NULL))
307
            {
308
              len = extract_unsigned_integer (valaddr + embedded_offset + length_pos, length_size, byte_order);
309
              LA_PRINT_STRING (stream, char_type,
310
                               valaddr + embedded_offset + string_pos,
311
                               len, NULL, 0, options);
312
            }
313
          else
314
            pascal_object_print_value_fields (type, valaddr + embedded_offset, address, stream,
315
                                              recurse, options, NULL, 0);
316
        }
317
      break;
318
 
319
    case TYPE_CODE_ENUM:
320
      if (options->format)
321
        {
322
          print_scalar_formatted (valaddr + embedded_offset, type,
323
                                  options, 0, stream);
324
          break;
325
        }
326
      len = TYPE_NFIELDS (type);
327
      val = unpack_long (type, valaddr + embedded_offset);
328
      for (i = 0; i < len; i++)
329
        {
330
          QUIT;
331
          if (val == TYPE_FIELD_BITPOS (type, i))
332
            {
333
              break;
334
            }
335
        }
336
      if (i < len)
337
        {
338
          fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
339
        }
340
      else
341
        {
342
          print_longest (stream, 'd', 0, val);
343
        }
344
      break;
345
 
346
    case TYPE_CODE_FLAGS:
347
      if (options->format)
348
          print_scalar_formatted (valaddr + embedded_offset, type,
349
                                  options, 0, stream);
350
      else
351
        val_print_type_code_flags (type, valaddr + embedded_offset, stream);
352
      break;
353
 
354
    case TYPE_CODE_FUNC:
355
      if (options->format)
356
        {
357
          print_scalar_formatted (valaddr + embedded_offset, type,
358
                                  options, 0, stream);
359
          break;
360
        }
361
      /* FIXME, we should consider, at least for ANSI C language, eliminating
362
         the distinction made between FUNCs and POINTERs to FUNCs.  */
363
      fprintf_filtered (stream, "{");
364
      type_print (type, "", stream, -1);
365
      fprintf_filtered (stream, "} ");
366
      /* Try to print what function it points to, and its address.  */
367
      print_address_demangle (gdbarch, address, stream, demangle);
368
      break;
369
 
370
    case TYPE_CODE_BOOL:
371
      if (options->format || options->output_format)
372
        {
373
          struct value_print_options opts = *options;
374
          opts.format = (options->format ? options->format
375
                         : options->output_format);
376
          print_scalar_formatted (valaddr + embedded_offset, type,
377
                                  &opts, 0, stream);
378
        }
379
      else
380
        {
381
          val = unpack_long (type, valaddr + embedded_offset);
382
          if (val == 0)
383
            fputs_filtered ("false", stream);
384
          else if (val == 1)
385
            fputs_filtered ("true", stream);
386
          else
387
            {
388
              fputs_filtered ("true (", stream);
389
              fprintf_filtered (stream, "%ld)", (long int) val);
390
            }
391
        }
392
      break;
393
 
394
    case TYPE_CODE_RANGE:
395
      /* FIXME: create_range_type does not set the unsigned bit in a
396
         range type (I think it probably should copy it from the target
397
         type), so we won't print values which are too large to
398
         fit in a signed integer correctly.  */
399
      /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
400
         print with the target type, though, because the size of our type
401
         and the target type might differ).  */
402
      /* FALLTHROUGH */
403
 
404
    case TYPE_CODE_INT:
405
      if (options->format || options->output_format)
406
        {
407
          struct value_print_options opts = *options;
408
          opts.format = (options->format ? options->format
409
                         : options->output_format);
410
          print_scalar_formatted (valaddr + embedded_offset, type,
411
                                  &opts, 0, stream);
412
        }
413
      else
414
        {
415
          val_print_type_code_int (type, valaddr + embedded_offset, stream);
416
        }
417
      break;
418
 
419
    case TYPE_CODE_CHAR:
420
      if (options->format || options->output_format)
421
        {
422
          struct value_print_options opts = *options;
423
          opts.format = (options->format ? options->format
424
                         : options->output_format);
425
          print_scalar_formatted (valaddr + embedded_offset, type,
426
                                  &opts, 0, stream);
427
        }
428
      else
429
        {
430
          val = unpack_long (type, valaddr + embedded_offset);
431
          if (TYPE_UNSIGNED (type))
432
            fprintf_filtered (stream, "%u", (unsigned int) val);
433
          else
434
            fprintf_filtered (stream, "%d", (int) val);
435
          fputs_filtered (" ", stream);
436
          LA_PRINT_CHAR ((unsigned char) val, type, stream);
437
        }
438
      break;
439
 
440
    case TYPE_CODE_FLT:
441
      if (options->format)
442
        {
443
          print_scalar_formatted (valaddr + embedded_offset, type,
444
                                  options, 0, stream);
445
        }
446
      else
447
        {
448
          print_floating (valaddr + embedded_offset, type, stream);
449
        }
450
      break;
451
 
452
    case TYPE_CODE_BITSTRING:
453
    case TYPE_CODE_SET:
454
      elttype = TYPE_INDEX_TYPE (type);
455
      CHECK_TYPEDEF (elttype);
456
      if (TYPE_STUB (elttype))
457
        {
458
          fprintf_filtered (stream, "<incomplete type>");
459
          gdb_flush (stream);
460
          break;
461
        }
462
      else
463
        {
464
          struct type *range = elttype;
465
          LONGEST low_bound, high_bound;
466
          int i;
467
          int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
468
          int need_comma = 0;
469
 
470
          if (is_bitstring)
471
            fputs_filtered ("B'", stream);
472
          else
473
            fputs_filtered ("[", stream);
474
 
475
          i = get_discrete_bounds (range, &low_bound, &high_bound);
476
        maybe_bad_bstring:
477
          if (i < 0)
478
            {
479
              fputs_filtered ("<error value>", stream);
480
              goto done;
481
            }
482
 
483
          for (i = low_bound; i <= high_bound; i++)
484
            {
485
              int element = value_bit_index (type, valaddr + embedded_offset, i);
486
              if (element < 0)
487
                {
488
                  i = element;
489
                  goto maybe_bad_bstring;
490
                }
491
              if (is_bitstring)
492
                fprintf_filtered (stream, "%d", element);
493
              else if (element)
494
                {
495
                  if (need_comma)
496
                    fputs_filtered (", ", stream);
497
                  print_type_scalar (range, i, stream);
498
                  need_comma = 1;
499
 
500
                  if (i + 1 <= high_bound && value_bit_index (type, valaddr + embedded_offset, ++i))
501
                    {
502
                      int j = i;
503
                      fputs_filtered ("..", stream);
504
                      while (i + 1 <= high_bound
505
                             && value_bit_index (type, valaddr + embedded_offset, ++i))
506
                        j = i;
507
                      print_type_scalar (range, j, stream);
508
                    }
509
                }
510
            }
511
        done:
512
          if (is_bitstring)
513
            fputs_filtered ("'", stream);
514
          else
515
            fputs_filtered ("]", stream);
516
        }
517
      break;
518
 
519
    case TYPE_CODE_VOID:
520
      fprintf_filtered (stream, "void");
521
      break;
522
 
523
    case TYPE_CODE_ERROR:
524
      fprintf_filtered (stream, "<error type>");
525
      break;
526
 
527
    case TYPE_CODE_UNDEF:
528
      /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
529
         dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
530
         and no complete type for struct foo in that file.  */
531
      fprintf_filtered (stream, "<incomplete type>");
532
      break;
533
 
534
    default:
535
      error (_("Invalid pascal type code %d in symbol table."), TYPE_CODE (type));
536
    }
537
  gdb_flush (stream);
538
  return (0);
539
}
540
 
541
int
542
pascal_value_print (struct value *val, struct ui_file *stream,
543
                    const struct value_print_options *options)
544
{
545
  struct type *type = value_type (val);
546
 
547
  /* If it is a pointer, indicate what it points to.
548
 
549
     Print type also if it is a reference.
550
 
551
     Object pascal: if it is a member pointer, we will take care
552
     of that when we print it.  */
553
  if (TYPE_CODE (type) == TYPE_CODE_PTR
554
      || TYPE_CODE (type) == TYPE_CODE_REF)
555
    {
556
      /* Hack:  remove (char *) for char strings.  Their
557
         type is indicated by the quoted string anyway. */
558
      if (TYPE_CODE (type) == TYPE_CODE_PTR
559
          && TYPE_NAME (type) == NULL
560
          && TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
561
          && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
562
        {
563
          /* Print nothing */
564
        }
565
      else
566
        {
567
          fprintf_filtered (stream, "(");
568
          type_print (type, "", stream, -1);
569
          fprintf_filtered (stream, ") ");
570
        }
571
    }
572
  return common_val_print (val, stream, 0, options, current_language);
573
}
574
 
575
 
576
static void
577
show_pascal_static_field_print (struct ui_file *file, int from_tty,
578
                                struct cmd_list_element *c, const char *value)
579
{
580
  fprintf_filtered (file, _("Printing of pascal static members is %s.\n"),
581
                    value);
582
}
583
 
584
static struct obstack dont_print_vb_obstack;
585
static struct obstack dont_print_statmem_obstack;
586
 
587
static void pascal_object_print_static_field (struct value *,
588
                                              struct ui_file *, int,
589
                                              const struct value_print_options *);
590
 
591
static void pascal_object_print_value (struct type *, const gdb_byte *,
592
                                       CORE_ADDR, struct ui_file *, int,
593
                                       const struct value_print_options *,
594
                                       struct type **);
595
 
596
/* It was changed to this after 2.4.5.  */
597
const char pascal_vtbl_ptr_name[] =
598
{'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
599
 
600
/* Return truth value for assertion that TYPE is of the type
601
   "pointer to virtual function".  */
602
 
603
int
604
pascal_object_is_vtbl_ptr_type (struct type *type)
605
{
606
  char *typename = type_name_no_tag (type);
607
 
608
  return (typename != NULL
609
          && strcmp (typename, pascal_vtbl_ptr_name) == 0);
610
}
611
 
612
/* Return truth value for the assertion that TYPE is of the type
613
   "pointer to virtual function table".  */
614
 
615
int
616
pascal_object_is_vtbl_member (struct type *type)
617
{
618
  if (TYPE_CODE (type) == TYPE_CODE_PTR)
619
    {
620
      type = TYPE_TARGET_TYPE (type);
621
      if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
622
        {
623
          type = TYPE_TARGET_TYPE (type);
624
          if (TYPE_CODE (type) == TYPE_CODE_STRUCT      /* if not using thunks */
625
              || TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
626
            {
627
              /* Virtual functions tables are full of pointers
628
                 to virtual functions. */
629
              return pascal_object_is_vtbl_ptr_type (type);
630
            }
631
        }
632
    }
633
  return 0;
634
}
635
 
636
/* Mutually recursive subroutines of pascal_object_print_value and
637
   c_val_print to print out a structure's fields:
638
   pascal_object_print_value_fields and pascal_object_print_value.
639
 
640
   TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
641
   same meanings as in pascal_object_print_value and c_val_print.
642
 
643
   DONT_PRINT is an array of baseclass types that we
644
   should not print, or zero if called from top level.  */
645
 
646
void
647
pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
648
                                  CORE_ADDR address, struct ui_file *stream,
649
                                  int recurse,
650
                                  const struct value_print_options *options,
651
                                  struct type **dont_print_vb,
652
                                  int dont_print_statmem)
653
{
654
  int i, len, n_baseclasses;
655
  char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
656
 
657
  CHECK_TYPEDEF (type);
658
 
659
  fprintf_filtered (stream, "{");
660
  len = TYPE_NFIELDS (type);
661
  n_baseclasses = TYPE_N_BASECLASSES (type);
662
 
663
  /* Print out baseclasses such that we don't print
664
     duplicates of virtual baseclasses.  */
665
  if (n_baseclasses > 0)
666
    pascal_object_print_value (type, valaddr, address, stream,
667
                               recurse + 1, options, dont_print_vb);
668
 
669
  if (!len && n_baseclasses == 1)
670
    fprintf_filtered (stream, "<No data fields>");
671
  else
672
    {
673
      struct obstack tmp_obstack = dont_print_statmem_obstack;
674
      int fields_seen = 0;
675
 
676
      if (dont_print_statmem == 0)
677
        {
678
          /* If we're at top level, carve out a completely fresh
679
             chunk of the obstack and use that until this particular
680
             invocation returns.  */
681
          obstack_finish (&dont_print_statmem_obstack);
682
        }
683
 
684
      for (i = n_baseclasses; i < len; i++)
685
        {
686
          /* If requested, skip printing of static fields.  */
687
          if (!options->pascal_static_field_print
688
              && field_is_static (&TYPE_FIELD (type, i)))
689
            continue;
690
          if (fields_seen)
691
            fprintf_filtered (stream, ", ");
692
          else if (n_baseclasses > 0)
693
            {
694
              if (options->pretty)
695
                {
696
                  fprintf_filtered (stream, "\n");
697
                  print_spaces_filtered (2 + 2 * recurse, stream);
698
                  fputs_filtered ("members of ", stream);
699
                  fputs_filtered (type_name_no_tag (type), stream);
700
                  fputs_filtered (": ", stream);
701
                }
702
            }
703
          fields_seen = 1;
704
 
705
          if (options->pretty)
706
            {
707
              fprintf_filtered (stream, "\n");
708
              print_spaces_filtered (2 + 2 * recurse, stream);
709
            }
710
          else
711
            {
712
              wrap_here (n_spaces (2 + 2 * recurse));
713
            }
714
          if (options->inspect_it)
715
            {
716
              if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
717
                fputs_filtered ("\"( ptr \"", stream);
718
              else
719
                fputs_filtered ("\"( nodef \"", stream);
720
              if (field_is_static (&TYPE_FIELD (type, i)))
721
                fputs_filtered ("static ", stream);
722
              fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
723
                                       language_cplus,
724
                                       DMGL_PARAMS | DMGL_ANSI);
725
              fputs_filtered ("\" \"", stream);
726
              fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
727
                                       language_cplus,
728
                                       DMGL_PARAMS | DMGL_ANSI);
729
              fputs_filtered ("\") \"", stream);
730
            }
731
          else
732
            {
733
              annotate_field_begin (TYPE_FIELD_TYPE (type, i));
734
 
735
              if (field_is_static (&TYPE_FIELD (type, i)))
736
                fputs_filtered ("static ", stream);
737
              fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
738
                                       language_cplus,
739
                                       DMGL_PARAMS | DMGL_ANSI);
740
              annotate_field_name_end ();
741
              fputs_filtered (" = ", stream);
742
              annotate_field_value ();
743
            }
744
 
745
          if (!field_is_static (&TYPE_FIELD (type, i))
746
              && TYPE_FIELD_PACKED (type, i))
747
            {
748
              struct value *v;
749
 
750
              /* Bitfields require special handling, especially due to byte
751
                 order problems.  */
752
              if (TYPE_FIELD_IGNORE (type, i))
753
                {
754
                  fputs_filtered ("<optimized out or zero length>", stream);
755
                }
756
              else
757
                {
758
                  struct value_print_options opts = *options;
759
                  v = value_from_longest (TYPE_FIELD_TYPE (type, i),
760
                                   unpack_field_as_long (type, valaddr, i));
761
 
762
                  opts.deref_ref = 0;
763
                  common_val_print (v, stream, recurse + 1, &opts,
764
                                    current_language);
765
                }
766
            }
767
          else
768
            {
769
              if (TYPE_FIELD_IGNORE (type, i))
770
                {
771
                  fputs_filtered ("<optimized out or zero length>", stream);
772
                }
773
              else if (field_is_static (&TYPE_FIELD (type, i)))
774
                {
775
                  /* struct value *v = value_static_field (type, i); v4.17 specific */
776
                  struct value *v;
777
                  v = value_from_longest (TYPE_FIELD_TYPE (type, i),
778
                                   unpack_field_as_long (type, valaddr, i));
779
 
780
                  if (v == NULL)
781
                    fputs_filtered ("<optimized out>", stream);
782
                  else
783
                    pascal_object_print_static_field (v, stream, recurse + 1,
784
                                                      options);
785
                }
786
              else
787
                {
788
                  struct value_print_options opts = *options;
789
                  opts.deref_ref = 0;
790
                  /* val_print (TYPE_FIELD_TYPE (type, i),
791
                     valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
792
                     address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
793
                     stream, format, 0, recurse + 1, pretty); */
794
                  val_print (TYPE_FIELD_TYPE (type, i),
795
                             valaddr, TYPE_FIELD_BITPOS (type, i) / 8,
796
                             address + TYPE_FIELD_BITPOS (type, i) / 8,
797
                             stream, recurse + 1, &opts,
798
                             current_language);
799
                }
800
            }
801
          annotate_field_end ();
802
        }
803
 
804
      if (dont_print_statmem == 0)
805
        {
806
          /* Free the space used to deal with the printing
807
             of the members from top level.  */
808
          obstack_free (&dont_print_statmem_obstack, last_dont_print);
809
          dont_print_statmem_obstack = tmp_obstack;
810
        }
811
 
812
      if (options->pretty)
813
        {
814
          fprintf_filtered (stream, "\n");
815
          print_spaces_filtered (2 * recurse, stream);
816
        }
817
    }
818
  fprintf_filtered (stream, "}");
819
}
820
 
821
/* Special val_print routine to avoid printing multiple copies of virtual
822
   baseclasses.  */
823
 
824
static void
825
pascal_object_print_value (struct type *type, const gdb_byte *valaddr,
826
                           CORE_ADDR address, struct ui_file *stream,
827
                           int recurse,
828
                           const struct value_print_options *options,
829
                           struct type **dont_print_vb)
830
{
831
  struct type **last_dont_print
832
  = (struct type **) obstack_next_free (&dont_print_vb_obstack);
833
  struct obstack tmp_obstack = dont_print_vb_obstack;
834
  int i, n_baseclasses = TYPE_N_BASECLASSES (type);
835
 
836
  if (dont_print_vb == 0)
837
    {
838
      /* If we're at top level, carve out a completely fresh
839
         chunk of the obstack and use that until this particular
840
         invocation returns.  */
841
      /* Bump up the high-water mark.  Now alpha is omega.  */
842
      obstack_finish (&dont_print_vb_obstack);
843
    }
844
 
845
  for (i = 0; i < n_baseclasses; i++)
846
    {
847
      int boffset;
848
      struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
849
      char *basename = type_name_no_tag (baseclass);
850
      const gdb_byte *base_valaddr;
851
 
852
      if (BASETYPE_VIA_VIRTUAL (type, i))
853
        {
854
          struct type **first_dont_print
855
          = (struct type **) obstack_base (&dont_print_vb_obstack);
856
 
857
          int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
858
          - first_dont_print;
859
 
860
          while (--j >= 0)
861
            if (baseclass == first_dont_print[j])
862
              goto flush_it;
863
 
864
          obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
865
        }
866
 
867
      boffset = baseclass_offset (type, i, valaddr, address);
868
 
869
      if (options->pretty)
870
        {
871
          fprintf_filtered (stream, "\n");
872
          print_spaces_filtered (2 * recurse, stream);
873
        }
874
      fputs_filtered ("<", stream);
875
      /* Not sure what the best notation is in the case where there is no
876
         baseclass name.  */
877
 
878
      fputs_filtered (basename ? basename : "", stream);
879
      fputs_filtered ("> = ", stream);
880
 
881
      /* The virtual base class pointer might have been clobbered by the
882
         user program. Make sure that it still points to a valid memory
883
         location.  */
884
 
885
      if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type)))
886
        {
887
          /* FIXME (alloc): not safe is baseclass is really really big. */
888
          gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
889
          base_valaddr = buf;
890
          if (target_read_memory (address + boffset, buf,
891
                                  TYPE_LENGTH (baseclass)) != 0)
892
            boffset = -1;
893
        }
894
      else
895
        base_valaddr = valaddr + boffset;
896
 
897
      if (boffset == -1)
898
        fprintf_filtered (stream, "<invalid address>");
899
      else
900
        pascal_object_print_value_fields (baseclass, base_valaddr, address + boffset,
901
                                          stream, recurse, options,
902
                     (struct type **) obstack_base (&dont_print_vb_obstack),
903
                                          0);
904
      fputs_filtered (", ", stream);
905
 
906
    flush_it:
907
      ;
908
    }
909
 
910
  if (dont_print_vb == 0)
911
    {
912
      /* Free the space used to deal with the printing
913
         of this type from top level.  */
914
      obstack_free (&dont_print_vb_obstack, last_dont_print);
915
      /* Reset watermark so that we can continue protecting
916
         ourselves from whatever we were protecting ourselves.  */
917
      dont_print_vb_obstack = tmp_obstack;
918
    }
919
}
920
 
921
/* Print value of a static member.
922
   To avoid infinite recursion when printing a class that contains
923
   a static instance of the class, we keep the addresses of all printed
924
   static member classes in an obstack and refuse to print them more
925
   than once.
926
 
927
   VAL contains the value to print, STREAM, RECURSE, and OPTIONS
928
   have the same meanings as in c_val_print.  */
929
 
930
static void
931
pascal_object_print_static_field (struct value *val,
932
                                  struct ui_file *stream,
933
                                  int recurse,
934
                                  const struct value_print_options *options)
935
{
936
  struct type *type = value_type (val);
937
  struct value_print_options opts;
938
 
939
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
940
    {
941
      CORE_ADDR *first_dont_print, addr;
942
      int i;
943
 
944
      first_dont_print
945
        = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
946
      i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
947
        - first_dont_print;
948
 
949
      while (--i >= 0)
950
        {
951
          if (value_address (val) == first_dont_print[i])
952
            {
953
              fputs_filtered ("<same as static member of an already seen type>",
954
                              stream);
955
              return;
956
            }
957
        }
958
 
959
      addr = value_address (val);
960
      obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
961
                    sizeof (CORE_ADDR));
962
 
963
      CHECK_TYPEDEF (type);
964
      pascal_object_print_value_fields (type, value_contents (val), addr,
965
                                        stream, recurse, options, NULL, 1);
966
      return;
967
    }
968
 
969
  opts = *options;
970
  opts.deref_ref = 0;
971
  common_val_print (val, stream, recurse, &opts, current_language);
972
}
973
 
974
extern initialize_file_ftype _initialize_pascal_valprint; /* -Wmissing-prototypes */
975
 
976
void
977
_initialize_pascal_valprint (void)
978
{
979
  add_setshow_boolean_cmd ("pascal_static-members", class_support,
980
                           &user_print_options.pascal_static_field_print, _("\
981
Set printing of pascal static members."), _("\
982
Show printing of pascal static members."), NULL,
983
                           NULL,
984
                           show_pascal_static_field_print,
985
                           &setprintlist, &showprintlist);
986
}

powered by: WebSVN 2.1.0

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