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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [m2-valprint.c] - Blame information for rev 816

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

Line No. Rev Author Line
1 227 jeremybenn
/* Support for printing Modula 2 values for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006,
4
                 2007, 2008, 2009, 2010 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 "defs.h"
22
#include "symtab.h"
23
#include "gdbtypes.h"
24
#include "expression.h"
25
#include "value.h"
26
#include "valprint.h"
27
#include "language.h"
28
#include "typeprint.h"
29
#include "c-lang.h"
30
#include "m2-lang.h"
31
#include "target.h"
32
 
33
static int print_unpacked_pointer (struct type *type,
34
                                   CORE_ADDR address, CORE_ADDR addr,
35
                                   const struct value_print_options *options,
36
                                   struct ui_file *stream);
37
static void
38
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
39
                         int embedded_offset, CORE_ADDR address,
40
                         struct ui_file *stream, int recurse,
41
                         const struct value_print_options *options,
42
                         int len);
43
 
44
 
45
/* Print function pointer with inferior address ADDRESS onto stdio
46
   stream STREAM.  */
47
 
48
static void
49
print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
50
                                struct ui_file *stream, int addressprint)
51
{
52
  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
53
                                                            &current_target);
54
 
55
  /* If the function pointer is represented by a description, print the
56
     address of the description.  */
57
  if (addressprint && func_addr != address)
58
    {
59
      fputs_filtered ("@", stream);
60
      fputs_filtered (paddress (gdbarch, address), stream);
61
      fputs_filtered (": ", stream);
62
    }
63
  print_address_demangle (gdbarch, func_addr, stream, demangle);
64
}
65
 
66
/* get_long_set_bounds - assigns the bounds of the long set to low and
67
                         high.  */
68
 
69
int
70
get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
71
{
72
  int len, i;
73
 
74
  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
75
    {
76
      len = TYPE_NFIELDS (type);
77
      i = TYPE_N_BASECLASSES (type);
78
      if (len == 0)
79
        return 0;
80
      *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
81
      *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
82
                                                                 len-1)));
83
      return 1;
84
    }
85
  error (_("expecting long_set"));
86
  return 0;
87
}
88
 
89
static void
90
m2_print_long_set (struct type *type, const gdb_byte *valaddr,
91
                   int embedded_offset, CORE_ADDR address,
92
                   struct ui_file *stream)
93
{
94
  int empty_set        = 1;
95
  int element_seen     = 0;
96
  LONGEST previous_low = 0;
97
  LONGEST previous_high= 0;
98
  LONGEST i, low_bound, high_bound;
99
  LONGEST field_low, field_high;
100
  struct type *range;
101
  int len, field;
102
  struct type *target;
103
  int bitval;
104
 
105
  CHECK_TYPEDEF (type);
106
 
107
  fprintf_filtered (stream, "{");
108
  len = TYPE_NFIELDS (type);
109
  if (get_long_set_bounds (type, &low_bound, &high_bound))
110
    {
111
      field = TYPE_N_BASECLASSES (type);
112
      range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
113
    }
114
  else
115
    {
116
      fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
117
      return;
118
    }
119
 
120
  target = TYPE_TARGET_TYPE (range);
121
 
122
  if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
123
    {
124
      for (i = low_bound; i <= high_bound; i++)
125
        {
126
          bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
127
                                    (TYPE_FIELD_BITPOS (type, field) / 8) +
128
                                    valaddr + embedded_offset, i);
129
          if (bitval < 0)
130
            error (_("bit test is out of range"));
131
          else if (bitval > 0)
132
            {
133
              previous_high = i;
134
              if (! element_seen)
135
                {
136
                  if (! empty_set)
137
                    fprintf_filtered (stream, ", ");
138
                  print_type_scalar (target, i, stream);
139
                  empty_set    = 0;
140
                  element_seen = 1;
141
                  previous_low = i;
142
                }
143
            }
144
          else
145
            {
146
              /* bit is not set */
147
              if (element_seen)
148
                {
149
                  if (previous_low+1 < previous_high)
150
                    fprintf_filtered (stream, "..");
151
                  if (previous_low+1 < previous_high)
152
                    print_type_scalar (target, previous_high, stream);
153
                  element_seen = 0;
154
                }
155
            }
156
          if (i == field_high)
157
            {
158
              field++;
159
              if (field == len)
160
                break;
161
              range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
162
              if (get_discrete_bounds (range, &field_low, &field_high) < 0)
163
                break;
164
              target = TYPE_TARGET_TYPE (range);
165
            }
166
        }
167
      if (element_seen)
168
        {
169
          if (previous_low+1 < previous_high)
170
            {
171
              fprintf_filtered (stream, "..");
172
              print_type_scalar (target, previous_high, stream);
173
            }
174
          element_seen = 0;
175
        }
176
      fprintf_filtered (stream, "}");
177
    }
178
}
179
 
180
static void
181
m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
182
                          int embedded_offset, CORE_ADDR address,
183
                          struct ui_file *stream, int recurse,
184
                          const struct value_print_options *options)
185
{
186
  struct type *content_type;
187
  CORE_ADDR addr;
188
  LONGEST len;
189
  struct value *val;
190
 
191
  CHECK_TYPEDEF (type);
192
  content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
193
 
194
  addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
195
                         (TYPE_FIELD_BITPOS (type, 0) / 8) +
196
                         valaddr + embedded_offset);
197
 
198
  val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
199
                       addr);
200
  len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
201
 
202
  fprintf_filtered (stream, "{");
203
  m2_print_array_contents (value_type (val), value_contents(val),
204
                           value_embedded_offset (val), addr, stream,
205
                           recurse, options, len);
206
  fprintf_filtered (stream, ", HIGH = %d}", (int) len);
207
}
208
 
209
static int
210
print_unpacked_pointer (struct type *type,
211
                        CORE_ADDR address, CORE_ADDR addr,
212
                        const struct value_print_options *options,
213
                        struct ui_file *stream)
214
{
215
  struct gdbarch *gdbarch = get_type_arch (type);
216
  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
217
 
218
  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
219
    {
220
      /* Try to print what function it points to.  */
221
      print_function_pointer_address (gdbarch, addr, stream,
222
                                      options->addressprint);
223
      /* Return value is irrelevant except for string pointers.  */
224
      return 0;
225
    }
226
 
227
  if (options->addressprint && options->format != 's')
228
    fputs_filtered (paddress (gdbarch, address), stream);
229
 
230
  /* For a pointer to char or unsigned char, also print the string
231
     pointed to, unless pointer is null.  */
232
 
233
  if (TYPE_LENGTH (elttype) == 1
234
      && TYPE_CODE (elttype) == TYPE_CODE_INT
235
      && (options->format == 0 || options->format == 's')
236
      && addr != 0)
237
    return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
238
                             stream, options);
239
 
240
  return 0;
241
}
242
 
243
static void
244
print_variable_at_address (struct type *type,
245
                           const gdb_byte *valaddr,
246
                           struct ui_file *stream,
247
                           int recurse,
248
                           const struct value_print_options *options)
249
{
250
  struct gdbarch *gdbarch = get_type_arch (type);
251
  CORE_ADDR addr = unpack_pointer (type, valaddr);
252
  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
253
 
254
  fprintf_filtered (stream, "[");
255
  fputs_filtered (paddress (gdbarch, addr), stream);
256
  fprintf_filtered (stream, "] : ");
257
 
258
  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
259
    {
260
      struct value *deref_val =
261
        value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
262
      common_val_print (deref_val, stream, recurse, options, current_language);
263
    }
264
  else
265
    fputs_filtered ("???", stream);
266
}
267
 
268
 
269
/* m2_print_array_contents - prints out the contents of an
270
                             array up to a max_print values.
271
                             It prints arrays of char as a string
272
                             and all other data types as comma
273
                             separated values.  */
274
 
275
static void
276
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
277
                         int embedded_offset, CORE_ADDR address,
278
                         struct ui_file *stream, int recurse,
279
                         const struct value_print_options *options,
280
                         int len)
281
{
282
  int eltlen;
283
  CHECK_TYPEDEF (type);
284
 
285
  if (TYPE_LENGTH (type) > 0)
286
    {
287
      eltlen = TYPE_LENGTH (type);
288
      if (options->prettyprint_arrays)
289
        print_spaces_filtered (2 + 2 * recurse, stream);
290
      /* For an array of chars, print with string syntax.  */
291
      if (eltlen == 1 &&
292
          ((TYPE_CODE (type) == TYPE_CODE_INT)
293
           || ((current_language->la_language == language_m2)
294
               && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
295
          && (options->format == 0 || options->format == 's'))
296
        val_print_string (type, address, len+1, stream, options);
297
      else
298
        {
299
          fprintf_filtered (stream, "{");
300
          val_print_array_elements (type, valaddr + embedded_offset,
301
                                    address, stream, recurse, options, 0);
302
          fprintf_filtered (stream, "}");
303
        }
304
    }
305
}
306
 
307
 
308
/* Print data of type TYPE located at VALADDR (within GDB), which came from
309
   the inferior at address ADDRESS, onto stdio stream STREAM according to
310
   OPTIONS.  The data at VALADDR is in target byte order.
311
 
312
   If the data are a string pointer, returns the number of string characters
313
   printed.  */
314
 
315
int
316
m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
317
              CORE_ADDR address, struct ui_file *stream, int recurse,
318
              const struct value_print_options *options)
319
{
320
  struct gdbarch *gdbarch = get_type_arch (type);
321
  unsigned int i = 0;    /* Number of characters printed */
322
  unsigned len;
323
  struct type *elttype;
324
  unsigned eltlen;
325
  int length_pos, length_size, string_pos;
326
  int char_size;
327
  LONGEST val;
328
  CORE_ADDR addr;
329
 
330
  CHECK_TYPEDEF (type);
331
  switch (TYPE_CODE (type))
332
    {
333
    case TYPE_CODE_ARRAY:
334
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
335
        {
336
          elttype = check_typedef (TYPE_TARGET_TYPE (type));
337
          eltlen = TYPE_LENGTH (elttype);
338
          len = TYPE_LENGTH (type) / eltlen;
339
          if (options->prettyprint_arrays)
340
            print_spaces_filtered (2 + 2 * recurse, stream);
341
          /* For an array of chars, print with string syntax.  */
342
          if (eltlen == 1 &&
343
              ((TYPE_CODE (elttype) == TYPE_CODE_INT)
344
               || ((current_language->la_language == language_m2)
345
                   && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
346
              && (options->format == 0 || options->format == 's'))
347
            {
348
              /* If requested, look for the first null char and only print
349
                 elements up to it.  */
350
              if (options->stop_print_at_null)
351
                {
352
                  unsigned int temp_len;
353
 
354
                  /* Look for a NULL char. */
355
                  for (temp_len = 0;
356
                       (valaddr + embedded_offset)[temp_len]
357
                         && temp_len < len && temp_len < options->print_max;
358
                       temp_len++);
359
                  len = temp_len;
360
                }
361
 
362
              LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
363
                               valaddr + embedded_offset, len, NULL,
364
                               0, options);
365
              i = len;
366
            }
367
          else
368
            {
369
              fprintf_filtered (stream, "{");
370
              val_print_array_elements (type, valaddr + embedded_offset,
371
                                        address, stream, recurse, options, 0);
372
              fprintf_filtered (stream, "}");
373
            }
374
          break;
375
        }
376
      /* Array of unspecified length: treat like pointer to first elt.  */
377
      print_unpacked_pointer (type, address, address, options, stream);
378
      break;
379
 
380
    case TYPE_CODE_PTR:
381
      if (TYPE_CONST (type))
382
        print_variable_at_address (type, valaddr + embedded_offset,
383
                                   stream, recurse, options);
384
      else if (options->format && options->format != 's')
385
        print_scalar_formatted (valaddr + embedded_offset, type,
386
                                options, 0, stream);
387
      else
388
        {
389
          addr = unpack_pointer (type, valaddr + embedded_offset);
390
          print_unpacked_pointer (type, addr, address, options, stream);
391
        }
392
      break;
393
 
394
    case TYPE_CODE_REF:
395
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
396
      if (options->addressprint)
397
        {
398
          CORE_ADDR addr
399
            = extract_typed_address (valaddr + embedded_offset, type);
400
          fprintf_filtered (stream, "@");
401
          fputs_filtered (paddress (gdbarch, addr), stream);
402
          if (options->deref_ref)
403
            fputs_filtered (": ", stream);
404
        }
405
      /* De-reference the reference.  */
406
      if (options->deref_ref)
407
        {
408
          if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
409
            {
410
              struct value *deref_val =
411
                value_at
412
                (TYPE_TARGET_TYPE (type),
413
                 unpack_pointer (type, valaddr + embedded_offset));
414
              common_val_print (deref_val, stream, recurse, options,
415
                                current_language);
416
            }
417
          else
418
            fputs_filtered ("???", stream);
419
        }
420
      break;
421
 
422
    case TYPE_CODE_UNION:
423
      if (recurse && !options->unionprint)
424
        {
425
          fprintf_filtered (stream, "{...}");
426
          break;
427
        }
428
      /* Fall through.  */
429
    case TYPE_CODE_STRUCT:
430
      if (m2_is_long_set (type))
431
        m2_print_long_set (type, valaddr, embedded_offset, address,
432
                           stream);
433
      else if (m2_is_unbounded_array (type))
434
        m2_print_unbounded_array (type, valaddr, embedded_offset,
435
                                  address, stream, recurse, options);
436
      else
437
        cp_print_value_fields (type, type, valaddr, embedded_offset,
438
                               address, stream, recurse, options, NULL, 0);
439
      break;
440
 
441
    case TYPE_CODE_ENUM:
442
      if (options->format)
443
        {
444
          print_scalar_formatted (valaddr + embedded_offset, type,
445
                                  options, 0, stream);
446
          break;
447
        }
448
      len = TYPE_NFIELDS (type);
449
      val = unpack_long (type, valaddr + embedded_offset);
450
      for (i = 0; i < len; i++)
451
        {
452
          QUIT;
453
          if (val == TYPE_FIELD_BITPOS (type, i))
454
            {
455
              break;
456
            }
457
        }
458
      if (i < len)
459
        {
460
          fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
461
        }
462
      else
463
        {
464
          print_longest (stream, 'd', 0, val);
465
        }
466
      break;
467
 
468
    case TYPE_CODE_FUNC:
469
      if (options->format)
470
        {
471
          print_scalar_formatted (valaddr + embedded_offset, type,
472
                                  options, 0, stream);
473
          break;
474
        }
475
      /* FIXME, we should consider, at least for ANSI C language, eliminating
476
         the distinction made between FUNCs and POINTERs to FUNCs.  */
477
      fprintf_filtered (stream, "{");
478
      type_print (type, "", stream, -1);
479
      fprintf_filtered (stream, "} ");
480
      /* Try to print what function it points to, and its address.  */
481
      print_address_demangle (gdbarch, address, stream, demangle);
482
      break;
483
 
484
    case TYPE_CODE_BOOL:
485
      if (options->format || options->output_format)
486
        {
487
          struct value_print_options opts = *options;
488
          opts.format = (options->format ? options->format
489
                         : options->output_format);
490
          print_scalar_formatted (valaddr + embedded_offset, type,
491
                                  &opts, 0, stream);
492
        }
493
      else
494
        {
495
          val = unpack_long (type, valaddr + embedded_offset);
496
          if (val == 0)
497
            fputs_filtered ("FALSE", stream);
498
          else if (val == 1)
499
            fputs_filtered ("TRUE", stream);
500
          else
501
            fprintf_filtered (stream, "%ld)", (long int) val);
502
        }
503
      break;
504
 
505
    case TYPE_CODE_RANGE:
506
      if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
507
        {
508
          m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
509
                        address, stream, recurse, options);
510
          break;
511
        }
512
      /* FIXME: create_range_type does not set the unsigned bit in a
513
         range type (I think it probably should copy it from the target
514
         type), so we won't print values which are too large to
515
         fit in a signed integer correctly.  */
516
      /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
517
         print with the target type, though, because the size of our type
518
         and the target type might differ).  */
519
      /* FALLTHROUGH */
520
 
521
    case TYPE_CODE_INT:
522
      if (options->format || options->output_format)
523
        {
524
          struct value_print_options opts = *options;
525
          opts.format = (options->format ? options->format
526
                         : options->output_format);
527
          print_scalar_formatted (valaddr + embedded_offset, type,
528
                                  &opts, 0, stream);
529
        }
530
      else
531
        val_print_type_code_int (type, valaddr + embedded_offset, stream);
532
      break;
533
 
534
    case TYPE_CODE_CHAR:
535
      if (options->format || options->output_format)
536
        {
537
          struct value_print_options opts = *options;
538
          opts.format = (options->format ? options->format
539
                         : options->output_format);
540
          print_scalar_formatted (valaddr + embedded_offset, type,
541
                                  &opts, 0, stream);
542
        }
543
      else
544
        {
545
          val = unpack_long (type, valaddr + embedded_offset);
546
          if (TYPE_UNSIGNED (type))
547
            fprintf_filtered (stream, "%u", (unsigned int) val);
548
          else
549
            fprintf_filtered (stream, "%d", (int) val);
550
          fputs_filtered (" ", stream);
551
          LA_PRINT_CHAR ((unsigned char) val, type, stream);
552
        }
553
      break;
554
 
555
    case TYPE_CODE_FLT:
556
      if (options->format)
557
        print_scalar_formatted (valaddr + embedded_offset, type,
558
                                options, 0, stream);
559
      else
560
        print_floating (valaddr + embedded_offset, type, stream);
561
      break;
562
 
563
    case TYPE_CODE_METHOD:
564
      break;
565
 
566
    case TYPE_CODE_BITSTRING:
567
    case TYPE_CODE_SET:
568
      elttype = TYPE_INDEX_TYPE (type);
569
      CHECK_TYPEDEF (elttype);
570
      if (TYPE_STUB (elttype))
571
        {
572
          fprintf_filtered (stream, _("<incomplete type>"));
573
          gdb_flush (stream);
574
          break;
575
        }
576
      else
577
        {
578
          struct type *range = elttype;
579
          LONGEST low_bound, high_bound;
580
          int i;
581
          int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
582
          int need_comma = 0;
583
 
584
          if (is_bitstring)
585
            fputs_filtered ("B'", stream);
586
          else
587
            fputs_filtered ("{", stream);
588
 
589
          i = get_discrete_bounds (range, &low_bound, &high_bound);
590
        maybe_bad_bstring:
591
          if (i < 0)
592
            {
593
              fputs_filtered (_("<error value>"), stream);
594
              goto done;
595
            }
596
 
597
          for (i = low_bound; i <= high_bound; i++)
598
            {
599
              int element = value_bit_index (type, valaddr + embedded_offset,
600
                                             i);
601
              if (element < 0)
602
                {
603
                  i = element;
604
                  goto maybe_bad_bstring;
605
                }
606
              if (is_bitstring)
607
                fprintf_filtered (stream, "%d", element);
608
              else if (element)
609
                {
610
                  if (need_comma)
611
                    fputs_filtered (", ", stream);
612
                  print_type_scalar (range, i, stream);
613
                  need_comma = 1;
614
 
615
                  if (i + 1 <= high_bound
616
                      && value_bit_index (type, valaddr + embedded_offset,
617
                                          ++i))
618
                    {
619
                      int j = i;
620
                      fputs_filtered ("..", stream);
621
                      while (i + 1 <= high_bound
622
                             && value_bit_index (type,
623
                                                 valaddr + embedded_offset,
624
                                                 ++i))
625
                        j = i;
626
                      print_type_scalar (range, j, stream);
627
                    }
628
                }
629
            }
630
        done:
631
          if (is_bitstring)
632
            fputs_filtered ("'", stream);
633
          else
634
            fputs_filtered ("}", stream);
635
        }
636
      break;
637
 
638
    case TYPE_CODE_VOID:
639
      fprintf_filtered (stream, "void");
640
      break;
641
 
642
    case TYPE_CODE_ERROR:
643
      fprintf_filtered (stream, _("<error type>"));
644
      break;
645
 
646
    case TYPE_CODE_UNDEF:
647
      /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
648
         dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
649
         and no complete type for struct foo in that file.  */
650
      fprintf_filtered (stream, _("<incomplete type>"));
651
      break;
652
 
653
    default:
654
      error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
655
    }
656
  gdb_flush (stream);
657
  return (0);
658
}

powered by: WebSVN 2.1.0

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