gdb/cp-valprint.c

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