gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdb_obstack.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "value.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28 #include "demangle.h"
  29 #include "annotate.h"
  30 #include "c-lang.h"
  31 #include "target.h"
  32 #include "cp-abi.h"
  33 #include "valprint.h"
  34 #include "cp-support.h"
  35 #include "language.h"
  36 #include "extension.h"
  37 #include "typeprint.h"
  38 #include "gdbsupport/byte-vector.h"
  39 #include "gdbarch.h"
  40 #include "cli/cli-style.h"
  41
  42 static struct obstack dont_print_vb_obstack;
  43 static struct obstack dont_print_statmem_obstack;
  44 static struct obstack dont_print_stat_array_obstack;
  45
  46 static void cp_print_static_field (struct type *, struct value *,
  47                                    struct ui_file *, int,
  48                                    const struct value_print_options *);
  49
  50 static void cp_print_value (struct type *, struct type *,
  51                             LONGEST,
  52                             CORE_ADDR, struct ui_file *,
  53                             int, struct value *,
  54                             const struct value_print_options *,
  55                             struct type **);
  56
  57
  58 /* GCC versions after 2.4.5 use this.  */
  59 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
  60
  61 /* Return truth value for assertion that TYPE is of the type
  62    "pointer to virtual function".  */
  63
  64 int
  65 cp_is_vtbl_ptr_type (struct type *type)
  66 {
  67   const char *type_name = TYPE_NAME (type);
  68
  69   return (type_name != NULL && !strcmp (type_name, vtbl_ptr_name));
  70 }
  71
  72 /* Return truth value for the assertion that TYPE is of the type
  73    "pointer to virtual function table".  */
  74
  75 int
  76 cp_is_vtbl_member (struct type *type)
  77 {
  78   /* With older versions of g++, the vtbl field pointed to an array of
  79      structures.  Nowadays it points directly to the structure.  */
  80   if (TYPE_CODE (type) == TYPE_CODE_PTR)
  81     {
  82       type = TYPE_TARGET_TYPE (type);
  83       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
  84         {
  85           type = TYPE_TARGET_TYPE (type);
  86           if (TYPE_CODE (type) == TYPE_CODE_STRUCT    /* if not using thunks */
  87               || TYPE_CODE (type) == TYPE_CODE_PTR)   /* if using thunks */
  88             {
  89               /* Virtual functions tables are full of pointers
  90                  to virtual functions.  */
  91               return cp_is_vtbl_ptr_type (type);
  92             }
  93         }
  94       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)  /* if not using thunks */
  95         {
  96           return cp_is_vtbl_ptr_type (type);
  97         }
  98       else if (TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
  99         {
 100           /* The type name of the thunk pointer is NULL when using
 101              dwarf2.  We could test for a pointer to a function, but
 102              there is no type info for the virtual table either, so it
 103              wont help.  */
 104           return cp_is_vtbl_ptr_type (type);
 105         }
 106     }
 107   return 0;
 108 }
 109
 110 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 111    print out a structure's fields: cp_print_value_fields and
 112    cp_print_value.
 113
 114    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
 115    meanings as in cp_print_value and c_val_print.
 116
 117    2nd argument REAL_TYPE is used to carry over the type of the
 118    derived class across the recursion to base classes.
 119
 120    DONT_PRINT is an array of baseclass types that we should not print,
 121    or zero if called from top level.  */
 122
 123 void
 124 cp_print_value_fields (struct type *type, struct type *real_type,
 125                        LONGEST offset,
 126                        CORE_ADDR address, struct ui_file *stream,
 127                        int recurse, struct value *val,
 128                        const struct value_print_options *options,
 129                        struct type **dont_print_vb,
 130                        int dont_print_statmem)
 131 {
 132   int i, len, n_baseclasses;
 133   int fields_seen = 0;
 134   static int last_set_recurse = -1;
 135
 136   type = check_typedef (type);
 137
 138   if (recurse == 0)
 139     {
 140       /* Any object can be left on obstacks only during an unexpected
 141          error.  */
 142
 143       if (obstack_object_size (&dont_print_statmem_obstack) > 0)
 144         {
 145           obstack_free (&dont_print_statmem_obstack, NULL);
 146           obstack_begin (&dont_print_statmem_obstack,
 147                          32 * sizeof (CORE_ADDR));
 148         }
 149       if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
 150         {
 151           obstack_free (&dont_print_stat_array_obstack, NULL);
 152           obstack_begin (&dont_print_stat_array_obstack,
 153                          32 * sizeof (struct type *));
 154         }
 155     }
 156
 157   fprintf_filtered (stream, "{");
 158   len = TYPE_NFIELDS (type);
 159   n_baseclasses = TYPE_N_BASECLASSES (type);
 160
 161   /* First, print out baseclasses such that we don't print
 162      duplicates of virtual baseclasses.  */
 163
 164   if (n_baseclasses > 0)
 165     cp_print_value (type, real_type,
 166                     offset, address, stream,
 167                     recurse + 1, val, options,
 168                     dont_print_vb);
 169
 170   /* Second, print out data fields */
 171
 172   /* If there are no data fields, skip this part */
 173   if (len == n_baseclasses || !len)
 174     fprintf_styled (stream, metadata_style.style (), "<No data fields>");
 175   else
 176     {
 177       size_t statmem_obstack_initial_size = 0;
 178       size_t stat_array_obstack_initial_size = 0;
 179       struct type *vptr_basetype = NULL;
 180       int vptr_fieldno;
 181
 182       if (dont_print_statmem == 0)
 183         {
 184           statmem_obstack_initial_size =
 185             obstack_object_size (&dont_print_statmem_obstack);
 186
 187           if (last_set_recurse != recurse)
 188             {
 189               stat_array_obstack_initial_size =
 190                 obstack_object_size (&dont_print_stat_array_obstack);
 191
 192               last_set_recurse = recurse;
 193             }
 194         }
 195
 196       vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
 197       for (i = n_baseclasses; i < len; i++)
 198         {
 199           const gdb_byte *valaddr = value_contents_for_printing (val);
 200
 201           /* If requested, skip printing of static fields.  */
 202           if (!options->static_field_print
 203               && field_is_static (&TYPE_FIELD (type, i)))
 204             continue;
 205
 206           if (fields_seen)
 207             {
 208               fputs_filtered (",", stream);
 209               if (!options->prettyformat)
 210                 fputs_filtered (" ", stream);
 211             }
 212           else if (n_baseclasses > 0)
 213             {
 214               if (options->prettyformat)
 215                 {
 216                   fprintf_filtered (stream, "\n");
 217                   print_spaces_filtered (2 + 2 * recurse, stream);
 218                   fputs_filtered ("members of ", stream);
 219                   fputs_filtered (TYPE_NAME (type), stream);
 220                   fputs_filtered (":", stream);
 221                 }
 222             }
 223           fields_seen = 1;
 224
 225           if (options->prettyformat)
 226             {
 227               fprintf_filtered (stream, "\n");
 228               print_spaces_filtered (2 + 2 * recurse, stream);
 229             }
 230           else
 231             {
 232               wrap_here (n_spaces (2 + 2 * recurse));
 233             }
 234
 235           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 236
 237           if (field_is_static (&TYPE_FIELD (type, i)))
 238             fputs_filtered ("static ", stream);
 239           fprintf_symbol_filtered (stream,
 240                                    TYPE_FIELD_NAME (type, i),
 241                                    current_language->la_language,
 242                                    DMGL_PARAMS | DMGL_ANSI);
 243           annotate_field_name_end ();
 244
 245           /* We tweak various options in a few cases below.  */
 246           value_print_options options_copy = *options;
 247           value_print_options *opts = &options_copy;
 248
 249           /* Do not print leading '=' in case of anonymous
 250              unions.  */
 251           if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 252             fputs_filtered (" = ", stream);
 253           else
 254             {
 255               /* If this is an anonymous field then we want to consider it
 256                  as though it is at its parent's depth when it comes to the
 257                  max print depth.  */
 258               if (opts->max_depth != -1 && opts->max_depth < INT_MAX)
 259                 ++opts->max_depth;
 260             }
 261           annotate_field_value ();
 262
 263           if (!field_is_static (&TYPE_FIELD (type, i))
 264               && TYPE_FIELD_PACKED (type, i))
 265             {
 266               struct value *v;
 267
 268               /* Bitfields require special handling, especially due to
 269                  byte order problems.  */
 270               if (TYPE_FIELD_IGNORE (type, i))
 271                 {
 272                   fputs_styled ("<optimized out or zero length>",
 273                                 metadata_style.style (), stream);
 274                 }
 275               else if (value_bits_synthetic_pointer (val,
 276                                                      TYPE_FIELD_BITPOS (type,
 277                                                                         i),
 278                                                      TYPE_FIELD_BITSIZE (type,
 279                                                                          i)))
 280                 {
 281                   fputs_styled (_("<synthetic pointer>"),
 282                                 metadata_style.style (), stream);
 283                 }
 284               else
 285                 {
 286                   opts->deref_ref = 0;
 287
 288                   v = value_field_bitfield (type, i, valaddr, offset, val);
 289
 290                   common_val_print (v, stream, recurse + 1,
 291                                     opts, current_language);
 292                 }
 293             }
 294           else
 295             {
 296               if (TYPE_FIELD_IGNORE (type, i))
 297                 {
 298                   fputs_styled ("<optimized out or zero length>",
 299                                 metadata_style.style (), stream);
 300                 }
 301               else if (field_is_static (&TYPE_FIELD (type, i)))
 302                 {
 303                   try
 304                     {
 305                       struct value *v = value_static_field (type, i);
 306
 307                       cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 308                                              v, stream, recurse + 1,
 309                                              opts);
 310                     }
 311                   catch (const gdb_exception_error &ex)
 312                     {
 313                       fprintf_styled (stream, metadata_style.style (),
 314                                       _("<error reading variable: %s>"),
 315                                       ex.what ());
 316                     }
 317                 }
 318               else if (i == vptr_fieldno && type == vptr_basetype)
 319                 {
 320                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
 321                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
 322
 323                   if (valprint_check_validity (stream, i_type, i_offset, val))
 324                     {
 325                       CORE_ADDR addr;
 326
 327                       addr = extract_typed_address (valaddr + i_offset, i_type);
 328                       print_function_pointer_address (opts,
 329                                                       get_type_arch (type),
 330                                                       addr, stream);
 331                     }
 332                 }
 333               else
 334                 {
 335                   opts->deref_ref = 0;
 336                   val_print (TYPE_FIELD_TYPE (type, i),
 337                              offset + TYPE_FIELD_BITPOS (type, i) / 8,
 338                              address,
 339                              stream, recurse + 1, val, opts,
 340                              current_language);
 341                 }
 342             }
 343           annotate_field_end ();
 344         }
 345
 346       if (dont_print_statmem == 0)
 347         {
 348           size_t obstack_final_size =
 349            obstack_object_size (&dont_print_statmem_obstack);
 350
 351           if (obstack_final_size > statmem_obstack_initial_size)
 352             {
 353               /* In effect, a pop of the printed-statics stack.  */
 354               size_t shrink_bytes
 355                 = statmem_obstack_initial_size - obstack_final_size;
 356               obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
 357             }
 358
 359           if (last_set_recurse != recurse)
 360             {
 361               obstack_final_size =
 362                 obstack_object_size (&dont_print_stat_array_obstack);
 363
 364               if (obstack_final_size > stat_array_obstack_initial_size)
 365                 {
 366                   void *free_to_ptr =
 367                     (char *) obstack_next_free (&dont_print_stat_array_obstack)
 368                     - (obstack_final_size
 369                        - stat_array_obstack_initial_size);
 370
 371                   obstack_free (&dont_print_stat_array_obstack,
 372                                 free_to_ptr);
 373                 }
 374               last_set_recurse = -1;
 375             }
 376         }
 377
 378       if (options->prettyformat)
 379         {
 380           fprintf_filtered (stream, "\n");
 381           print_spaces_filtered (2 * recurse, stream);
 382         }
 383     }                           /* if there are data fields */
 384
 385   fprintf_filtered (stream, "}");
 386 }
 387
 388 /* Like cp_print_value_fields, but find the runtime type of the object
 389    and pass it as the `real_type' argument to cp_print_value_fields.
 390    This function is a hack to work around the fact that
 391    common_val_print passes the embedded offset to val_print, but not
 392    the enclosing type.  */
 393
 394 void
 395 cp_print_value_fields_rtti (struct type *type,
 396                             const gdb_byte *valaddr, LONGEST offset,
 397                             CORE_ADDR address,
 398                             struct ui_file *stream, int recurse,
 399                             struct value *val,
 400                             const struct value_print_options *options,
 401                             struct type **dont_print_vb,
 402                             int dont_print_statmem)
 403 {
 404   struct type *real_type = NULL;
 405
 406   /* We require all bits to be valid in order to attempt a
 407      conversion.  */
 408   if (!value_bits_any_optimized_out (val,
 409                                      TARGET_CHAR_BIT * offset,
 410                                      TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 411     {
 412       struct value *value;
 413       int full, using_enc;
 414       LONGEST top;
 415
 416       /* Ugh, we have to convert back to a value here.  */
 417       value = value_from_contents_and_address (type, valaddr + offset,
 418                                                address + offset);
 419       type = value_type (value);
 420       /* We don't actually care about most of the result here -- just
 421          the type.  We already have the correct offset, due to how
 422          val_print was initially called.  */
 423       real_type = value_rtti_type (value, &full, &top, &using_enc);
 424     }
 425
 426   if (!real_type)
 427     real_type = type;
 428
 429   cp_print_value_fields (type, real_type, offset,
 430                          address, stream, recurse, val, options,
 431                          dont_print_vb, dont_print_statmem);
 432 }
 433
 434 /* Special val_print routine to avoid printing multiple copies of
 435    virtual baseclasses.  */
 436
 437 static void
 438 cp_print_value (struct type *type, struct type *real_type,
 439                 LONGEST offset,
 440                 CORE_ADDR address, struct ui_file *stream,
 441                 int recurse, struct value *val,
 442                 const struct value_print_options *options,
 443                 struct type **dont_print_vb)
 444 {
 445   struct type **last_dont_print
 446     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 447   struct obstack tmp_obstack = dont_print_vb_obstack;
 448   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 449   LONGEST thisoffset;
 450   struct type *thistype;
 451   const gdb_byte *valaddr = value_contents_for_printing (val);
 452
 453   if (dont_print_vb == 0)
 454     {
 455       /* If we're at top level, carve out a completely fresh chunk of
 456          the obstack and use that until this particular invocation
 457          returns.  */
 458       /* Bump up the high-water mark.  Now alpha is omega.  */
 459       obstack_finish (&dont_print_vb_obstack);
 460     }
 461
 462   for (i = 0; i < n_baseclasses; i++)
 463     {
 464       LONGEST boffset = 0;
 465       int skip = 0;
 466       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 467       const char *basename = TYPE_NAME (baseclass);
 468       struct value *base_val = NULL;
 469
 470       if (BASETYPE_VIA_VIRTUAL (type, i))
 471         {
 472           struct type **first_dont_print
 473             = (struct type **) obstack_base (&dont_print_vb_obstack);
 474
 475           int j = (struct type **)
 476             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 477
 478           while (--j >= 0)
 479             if (baseclass == first_dont_print[j])
 480               goto flush_it;
 481
 482           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 483         }
 484
 485       thisoffset = offset;
 486       thistype = real_type;
 487
 488       try
 489         {
 490           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 491         }
 492       catch (const gdb_exception_error &ex)
 493         {
 494           if (ex.error == NOT_AVAILABLE_ERROR)
 495             skip = -1;
 496           else
 497             skip = 1;
 498         }
 499
 500       if (skip == 0)
 501         {
 502           if (BASETYPE_VIA_VIRTUAL (type, i))
 503             {
 504               /* The virtual base class pointer might have been
 505                  clobbered by the user program. Make sure that it
 506                  still points to a valid memory location.  */
 507
 508               if ((boffset + offset) < 0
 509                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 510                 {
 511                   gdb::byte_vector buf (TYPE_LENGTH (baseclass));
 512
 513                   if (target_read_memory (address + boffset, buf.data (),
 514                                           TYPE_LENGTH (baseclass)) != 0)
 515                     skip = 1;
 516                   base_val = value_from_contents_and_address (baseclass,
 517                                                               buf.data (),
 518                                                               address + boffset);
 519                   baseclass = value_type (base_val);
 520                   thisoffset = 0;
 521                   boffset = 0;
 522                   thistype = baseclass;
 523                 }
 524               else
 525                 {
 526                   base_val = val;
 527                 }
 528             }
 529           else
 530             {
 531               base_val = val;
 532             }
 533         }
 534
 535       /* Now do the printing.  */
 536       if (options->prettyformat)
 537         {
 538           fprintf_filtered (stream, "\n");
 539           print_spaces_filtered (2 * recurse, stream);
 540         }
 541       fputs_filtered ("<", stream);
 542       /* Not sure what the best notation is in the case where there is
 543          no baseclass name.  */
 544       fputs_filtered (basename ? basename : "", stream);
 545       fputs_filtered ("> = ", stream);
 546
 547       if (skip < 0)
 548         val_print_unavailable (stream);
 549       else if (skip > 0)
 550         val_print_invalid_address (stream);
 551       else
 552         {
 553           int result = 0;
 554
 555           if (options->max_depth > -1
 556               && recurse >= options->max_depth)
 557             {
 558               const struct language_defn *language = current_language;
 559               gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
 560               fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
 561             }
 562           else
 563             {
 564               /* Attempt to run an extension language pretty-printer on the
 565                  baseclass if possible.  */
 566               if (!options->raw)
 567                 result
 568                   = apply_ext_lang_val_pretty_printer (baseclass,
 569                                                        thisoffset + boffset,
 570                                                        value_address (base_val),
 571                                                        stream, recurse,
 572                                                        base_val, options,
 573                                                        current_language);
 574
 575               if (!result)
 576                 cp_print_value_fields (baseclass, thistype,
 577                                        thisoffset + boffset,
 578                                        value_address (base_val),
 579                                        stream, recurse, base_val, options,
 580                                        ((struct type **)
 581                                         obstack_base (&dont_print_vb_obstack)),
 582                                        0);
 583             }
 584         }
 585       fputs_filtered (", ", stream);
 586
 587     flush_it:
 588       ;
 589     }
 590
 591   if (dont_print_vb == 0)
 592     {
 593       /* Free the space used to deal with the printing
 594          of this type from top level.  */
 595       obstack_free (&dont_print_vb_obstack, last_dont_print);
 596       /* Reset watermark so that we can continue protecting
 597          ourselves from whatever we were protecting ourselves.  */
 598       dont_print_vb_obstack = tmp_obstack;
 599     }
 600 }
 601
 602 /* Print value of a static member.  To avoid infinite recursion when
 603    printing a class that contains a static instance of the class, we
 604    keep the addresses of all printed static member classes in an
 605    obstack and refuse to print them more than once.
 606
 607    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 608    have the same meanings as in c_val_print.  */
 609
 610 static void
 611 cp_print_static_field (struct type *type,
 612                        struct value *val,
 613                        struct ui_file *stream,
 614                        int recurse,
 615                        const struct value_print_options *options)
 616 {
 617   struct value_print_options opts;
 618
 619   if (value_entirely_optimized_out (val))
 620     {
 621       val_print_optimized_out (val, stream);
 622       return;
 623     }
 624
 625   struct type *real_type = check_typedef (type);
 626   if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
 627     {
 628       CORE_ADDR *first_dont_print;
 629       CORE_ADDR addr;
 630       int i;
 631
 632       first_dont_print
 633         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 634       i = obstack_object_size (&dont_print_statmem_obstack)
 635         / sizeof (CORE_ADDR);
 636
 637       while (--i >= 0)
 638         {
 639           if (value_address (val) == first_dont_print[i])
 640             {
 641               fputs_styled (_("<same as static member of an already"
 642                               " seen type>"),
 643                             metadata_style.style (), stream);
 644               return;
 645             }
 646         }
 647
 648       addr = value_address (val);
 649       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 650                     sizeof (CORE_ADDR));
 651       cp_print_value_fields (type, value_enclosing_type (val),
 652                              value_embedded_offset (val), addr,
 653                              stream, recurse, val,
 654                              options, NULL, 1);
 655       return;
 656     }
 657
 658   if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
 659     {
 660       struct type **first_dont_print;
 661       int i;
 662       struct type *target_type = TYPE_TARGET_TYPE (type);
 663
 664       first_dont_print
 665         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 666       i = obstack_object_size (&dont_print_stat_array_obstack)
 667         / sizeof (struct type *);
 668
 669       while (--i >= 0)
 670         {
 671           if (target_type == first_dont_print[i])
 672             {
 673               fputs_styled (_("<same as static member of an already"
 674                               " seen type>"),
 675                             metadata_style.style (), stream);
 676               return;
 677             }
 678         }
 679
 680       obstack_grow (&dont_print_stat_array_obstack,
 681                     (char *) &target_type,
 682                     sizeof (struct type *));
 683     }
 684
 685   opts = *options;
 686   opts.deref_ref = 0;
 687   val_print (type,
 688              value_embedded_offset (val),
 689              value_address (val),
 690              stream, recurse, val,
 691              &opts, current_language);
 692 }
 693
 694 /* Find the field in *SELF, or its non-virtual base classes, with
 695    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
 696    to the containing field number.  If OFFSET is not exactly at the
 697    start of some field, set *SELF to NULL.  */
 698
 699 static void
 700 cp_find_class_member (struct type **self_p, int *fieldno,
 701                       LONGEST offset)
 702 {
 703   struct type *self;
 704   unsigned int i;
 705   unsigned len;
 706
 707   *self_p = check_typedef (*self_p);
 708   self = *self_p;
 709   len = TYPE_NFIELDS (self);
 710
 711   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
 712     {
 713       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 714
 715       QUIT;
 716       if (offset == bitpos)
 717         {
 718           *fieldno = i;
 719           return;
 720         }
 721     }
 722
 723   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 724     {
 725       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 726       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
 727
 728       if (offset >= bitpos && offset < bitpos + bitsize)
 729         {
 730           *self_p = TYPE_FIELD_TYPE (self, i);
 731           cp_find_class_member (self_p, fieldno, offset - bitpos);
 732           return;
 733         }
 734     }
 735
 736   *self_p = NULL;
 737 }
 738
 739 void
 740 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 741                        struct ui_file *stream, const char *prefix)
 742 {
 743   enum bfd_endian byte_order = type_byte_order (type);
 744
 745   /* VAL is a byte offset into the structure type SELF_TYPE.
 746      Find the name of the field for that offset and
 747      print it.  */
 748   struct type *self_type = TYPE_SELF_TYPE (type);
 749   LONGEST val;
 750   int fieldno;
 751
 752   val = extract_signed_integer (valaddr,
 753                                 TYPE_LENGTH (type),
 754                                 byte_order);
 755
 756   /* Pointers to data members are usually byte offsets into an object.
 757      Because a data member can have offset zero, and a NULL pointer to
 758      member must be distinct from any valid non-NULL pointer to
 759      member, either the value is biased or the NULL value has a
 760      special representation; both are permitted by ISO C++.  HP aCC
 761      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 762      and other compilers which use the Itanium ABI use -1 as the NULL
 763      value.  GDB only supports that last form; to add support for
 764      another form, make this into a cp-abi hook.  */
 765
 766   if (val == -1)
 767     {
 768       fprintf_filtered (stream, "NULL");
 769       return;
 770     }
 771
 772   cp_find_class_member (&self_type, &fieldno, val << 3);
 773
 774   if (self_type != NULL)
 775     {
 776       const char *name;
 777
 778       fputs_filtered (prefix, stream);
 779       name = TYPE_NAME (self_type);
 780       if (name)
 781         fputs_filtered (name, stream);
 782       else
 783         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 784       fprintf_filtered (stream, "::");
 785       fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
 786     }
 787   else
 788     fprintf_filtered (stream, "%ld", (long) val);
 789 }
 790
 791
 792 void
 793 _initialize_cp_valprint (void)
 794 {
 795   obstack_begin (&dont_print_stat_array_obstack,
 796                  32 * sizeof (struct type *));
 797   obstack_begin (&dont_print_statmem_obstack,
 798                  32 * sizeof (CORE_ADDR));
 799   obstack_begin (&dont_print_vb_obstack,
 800                  32 * sizeof (struct type *));
 801 }