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             fprintf_filtered (stream, ", ");
 239           else if (n_baseclasses > 0)
 240             {
 241               if (options->prettyformat)
 242                 {
 243                   fprintf_filtered (stream, "\n");
 244                   print_spaces_filtered (2 + 2 * recurse, stream);
 245                   fputs_filtered ("members of ", stream);
 246                   fputs_filtered (TYPE_NAME (type), stream);
 247                   fputs_filtered (": ", stream);
 248                 }
 249             }
 250           fields_seen = 1;
 251
 252           if (options->prettyformat)
 253             {
 254               fprintf_filtered (stream, "\n");
 255               print_spaces_filtered (2 + 2 * recurse, stream);
 256             }
 257           else
 258             {
 259               wrap_here (n_spaces (2 + 2 * recurse));
 260             }
 261
 262           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 263
 264           if (field_is_static (&TYPE_FIELD (type, i)))
 265             fputs_filtered ("static ", stream);
 266           fprintf_symbol_filtered (stream,
 267                                    TYPE_FIELD_NAME (type, i),
 268                                    current_language->la_language,
 269                                    DMGL_PARAMS | DMGL_ANSI);
 270           annotate_field_name_end ();
 271           /* Do not print leading '=' in case of anonymous
 272              unions.  */
 273           if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 274             fputs_filtered (" = ", stream);
 275           annotate_field_value ();
 276
 277           if (!field_is_static (&TYPE_FIELD (type, i))
 278               && TYPE_FIELD_PACKED (type, i))
 279             {
 280               struct value *v;
 281
 282               /* Bitfields require special handling, especially due to
 283                  byte order problems.  */
 284               if (TYPE_FIELD_IGNORE (type, i))
 285                 {
 286                   fputs_filtered ("<optimized out or zero length>", stream);
 287                 }
 288               else if (value_bits_synthetic_pointer (val,
 289                                                      TYPE_FIELD_BITPOS (type,
 290                                                                         i),
 291                                                      TYPE_FIELD_BITSIZE (type,
 292                                                                          i)))
 293                 {
 294                   fputs_filtered (_("<synthetic pointer>"), stream);
 295                 }
 296               else
 297                 {
 298                   struct value_print_options opts = *options;
 299
 300                   opts.deref_ref = 0;
 301
 302                   v = value_field_bitfield (type, i, valaddr, offset, val);
 303
 304                   common_val_print (v, stream, recurse + 1, &opts,
 305                                     current_language);
 306                 }
 307             }
 308           else
 309             {
 310               if (TYPE_FIELD_IGNORE (type, i))
 311                 {
 312                   fputs_filtered ("<optimized out or zero length>",
 313                                   stream);
 314                 }
 315               else if (field_is_static (&TYPE_FIELD (type, i)))
 316                 {
 317                   TRY
 318                     {
 319                       struct value *v = value_static_field (type, i);
 320
 321                       cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 322                                              v, stream, recurse + 1,
 323                                              options);
 324                     }
 325                   CATCH (ex, RETURN_MASK_ERROR)
 326                     {
 327                       fprintf_filtered (stream,
 328                                         _("<error reading variable: %s>"),
 329                                         ex.message);
 330                     }
 331                   END_CATCH
 332                 }
 333               else if (i == vptr_fieldno && type == vptr_basetype)
 334                 {
 335                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
 336                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
 337
 338                   if (valprint_check_validity (stream, i_type, i_offset, val))
 339                     {
 340                       CORE_ADDR addr;
 341
 342                       addr = extract_typed_address (valaddr + i_offset, i_type);
 343                       print_function_pointer_address (options,
 344                                                       get_type_arch (type),
 345                                                       addr, stream);
 346                     }
 347                 }
 348               else
 349                 {
 350                   struct value_print_options opts = *options;
 351
 352                   opts.deref_ref = 0;
 353                   val_print (TYPE_FIELD_TYPE (type, i),
 354                              offset + TYPE_FIELD_BITPOS (type, i) / 8,
 355                              address,
 356                              stream, recurse + 1, val, &opts,
 357                              current_language);
 358                 }
 359             }
 360           annotate_field_end ();
 361         }
 362
 363       if (dont_print_statmem == 0)
 364         {
 365           size_t obstack_final_size =
 366            obstack_object_size (&dont_print_statmem_obstack);
 367
 368           if (obstack_final_size > statmem_obstack_initial_size)
 369             {
 370               /* In effect, a pop of the printed-statics stack.  */
 371               size_t shrink_bytes
 372                 = statmem_obstack_initial_size - obstack_final_size;
 373               obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
 374             }
 375
 376           if (last_set_recurse != recurse)
 377             {
 378               obstack_final_size =
 379                 obstack_object_size (&dont_print_stat_array_obstack);
 380
 381               if (obstack_final_size > stat_array_obstack_initial_size)
 382                 {
 383                   void *free_to_ptr =
 384                     (char *) obstack_next_free (&dont_print_stat_array_obstack)
 385                     - (obstack_final_size
 386                        - stat_array_obstack_initial_size);
 387
 388                   obstack_free (&dont_print_stat_array_obstack,
 389                                 free_to_ptr);
 390                 }
 391               last_set_recurse = -1;
 392             }
 393         }
 394
 395       if (options->prettyformat)
 396         {
 397           fprintf_filtered (stream, "\n");
 398           print_spaces_filtered (2 * recurse, stream);
 399         }
 400     }                           /* if there are data fields */
 401
 402   fprintf_filtered (stream, "}");
 403 }
 404
 405 /* Like cp_print_value_fields, but find the runtime type of the object
 406    and pass it as the `real_type' argument to cp_print_value_fields.
 407    This function is a hack to work around the fact that
 408    common_val_print passes the embedded offset to val_print, but not
 409    the enclosing type.  */
 410
 411 void
 412 cp_print_value_fields_rtti (struct type *type,
 413                             const gdb_byte *valaddr, LONGEST offset,
 414                             CORE_ADDR address,
 415                             struct ui_file *stream, int recurse,
 416                             struct value *val,
 417                             const struct value_print_options *options,
 418                             struct type **dont_print_vb,
 419                             int dont_print_statmem)
 420 {
 421   struct type *real_type = NULL;
 422
 423   /* We require all bits to be valid in order to attempt a
 424      conversion.  */
 425   if (!value_bits_any_optimized_out (val,
 426                                      TARGET_CHAR_BIT * offset,
 427                                      TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 428     {
 429       struct value *value;
 430       int full, using_enc;
 431       LONGEST top;
 432
 433       /* Ugh, we have to convert back to a value here.  */
 434       value = value_from_contents_and_address (type, valaddr + offset,
 435                                                address + offset);
 436       type = value_type (value);
 437       /* We don't actually care about most of the result here -- just
 438          the type.  We already have the correct offset, due to how
 439          val_print was initially called.  */
 440       real_type = value_rtti_type (value, &full, &top, &using_enc);
 441     }
 442
 443   if (!real_type)
 444     real_type = type;
 445
 446   cp_print_value_fields (type, real_type, offset,
 447                          address, stream, recurse, val, options,
 448                          dont_print_vb, dont_print_statmem);
 449 }
 450
 451 /* Special val_print routine to avoid printing multiple copies of
 452    virtual baseclasses.  */
 453
 454 static void
 455 cp_print_value (struct type *type, struct type *real_type,
 456                 LONGEST offset,
 457                 CORE_ADDR address, struct ui_file *stream,
 458                 int recurse, struct value *val,
 459                 const struct value_print_options *options,
 460                 struct type **dont_print_vb)
 461 {
 462   struct type **last_dont_print
 463     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 464   struct obstack tmp_obstack = dont_print_vb_obstack;
 465   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 466   LONGEST thisoffset;
 467   struct type *thistype;
 468   const gdb_byte *valaddr = value_contents_for_printing (val);
 469
 470   if (dont_print_vb == 0)
 471     {
 472       /* If we're at top level, carve out a completely fresh chunk of
 473          the obstack and use that until this particular invocation
 474          returns.  */
 475       /* Bump up the high-water mark.  Now alpha is omega.  */
 476       obstack_finish (&dont_print_vb_obstack);
 477     }
 478
 479   for (i = 0; i < n_baseclasses; i++)
 480     {
 481       LONGEST boffset = 0;
 482       int skip = 0;
 483       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 484       const char *basename = TYPE_NAME (baseclass);
 485       struct value *base_val = NULL;
 486
 487       if (BASETYPE_VIA_VIRTUAL (type, i))
 488         {
 489           struct type **first_dont_print
 490             = (struct type **) obstack_base (&dont_print_vb_obstack);
 491
 492           int j = (struct type **)
 493             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 494
 495           while (--j >= 0)
 496             if (baseclass == first_dont_print[j])
 497               goto flush_it;
 498
 499           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 500         }
 501
 502       thisoffset = offset;
 503       thistype = real_type;
 504
 505       TRY
 506         {
 507           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 508         }
 509       CATCH (ex, RETURN_MASK_ERROR)
 510         {
 511           if (ex.error == NOT_AVAILABLE_ERROR)
 512             skip = -1;
 513           else
 514             skip = 1;
 515         }
 516       END_CATCH
 517
 518       if (skip == 0)
 519         {
 520           if (BASETYPE_VIA_VIRTUAL (type, i))
 521             {
 522               /* The virtual base class pointer might have been
 523                  clobbered by the user program. Make sure that it
 524                  still points to a valid memory location.  */
 525
 526               if ((boffset + offset) < 0
 527                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 528                 {
 529                   gdb::byte_vector buf (TYPE_LENGTH (baseclass));
 530
 531                   if (target_read_memory (address + boffset, buf.data (),
 532                                           TYPE_LENGTH (baseclass)) != 0)
 533                     skip = 1;
 534                   base_val = value_from_contents_and_address (baseclass,
 535                                                               buf.data (),
 536                                                               address + boffset);
 537                   baseclass = value_type (base_val);
 538                   thisoffset = 0;
 539                   boffset = 0;
 540                   thistype = baseclass;
 541                 }
 542               else
 543                 {
 544                   base_val = val;
 545                 }
 546             }
 547           else
 548             {
 549               base_val = val;
 550             }
 551         }
 552
 553       /* Now do the printing.  */
 554       if (options->prettyformat)
 555         {
 556           fprintf_filtered (stream, "\n");
 557           print_spaces_filtered (2 * recurse, stream);
 558         }
 559       fputs_filtered ("<", stream);
 560       /* Not sure what the best notation is in the case where there is
 561          no baseclass name.  */
 562       fputs_filtered (basename ? basename : "", stream);
 563       fputs_filtered ("> = ", stream);
 564
 565       if (skip < 0)
 566         val_print_unavailable (stream);
 567       else if (skip > 0)
 568         val_print_invalid_address (stream);
 569       else
 570         {
 571           int result = 0;
 572
 573           /* Attempt to run an extension language pretty-printer on the
 574              baseclass if possible.  */
 575           if (!options->raw)
 576             result
 577               = apply_ext_lang_val_pretty_printer (baseclass,
 578                                                    thisoffset + boffset,
 579                                                    value_address (base_val),
 580                                                    stream, recurse,
 581                                                    base_val, options,
 582                                                    current_language);
 583
 584           if (!result)
 585             cp_print_value_fields (baseclass, thistype,
 586                                    thisoffset + boffset,
 587                                    value_address (base_val),
 588                                    stream, recurse, base_val, options,
 589                                    ((struct type **)
 590                                     obstack_base (&dont_print_vb_obstack)),
 591                                    0);
 592         }
 593       fputs_filtered (", ", stream);
 594
 595     flush_it:
 596       ;
 597     }
 598
 599   if (dont_print_vb == 0)
 600     {
 601       /* Free the space used to deal with the printing
 602          of this type from top level.  */
 603       obstack_free (&dont_print_vb_obstack, last_dont_print);
 604       /* Reset watermark so that we can continue protecting
 605          ourselves from whatever we were protecting ourselves.  */
 606       dont_print_vb_obstack = tmp_obstack;
 607     }
 608 }
 609
 610 /* Print value of a static member.  To avoid infinite recursion when
 611    printing a class that contains a static instance of the class, we
 612    keep the addresses of all printed static member classes in an
 613    obstack and refuse to print them more than once.
 614
 615    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 616    have the same meanings as in c_val_print.  */
 617
 618 static void
 619 cp_print_static_field (struct type *type,
 620                        struct value *val,
 621                        struct ui_file *stream,
 622                        int recurse,
 623                        const struct value_print_options *options)
 624 {
 625   struct value_print_options opts;
 626
 627   if (value_entirely_optimized_out (val))
 628     {
 629       val_print_optimized_out (val, stream);
 630       return;
 631     }
 632
 633   struct type *real_type = check_typedef (type);
 634   if (TYPE_CODE (real_type) == TYPE_CODE_STRUCT)
 635     {
 636       CORE_ADDR *first_dont_print;
 637       CORE_ADDR addr;
 638       int i;
 639
 640       first_dont_print
 641         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 642       i = obstack_object_size (&dont_print_statmem_obstack)
 643         / sizeof (CORE_ADDR);
 644
 645       while (--i >= 0)
 646         {
 647           if (value_address (val) == first_dont_print[i])
 648             {
 649               fputs_filtered ("<same as static member of an already"
 650                               " seen type>",
 651                               stream);
 652               return;
 653             }
 654         }
 655
 656       addr = value_address (val);
 657       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 658                     sizeof (CORE_ADDR));
 659       cp_print_value_fields (type, value_enclosing_type (val),
 660                              value_embedded_offset (val), addr,
 661                              stream, recurse, val,
 662                              options, NULL, 1);
 663       return;
 664     }
 665
 666   if (TYPE_CODE (real_type) == TYPE_CODE_ARRAY)
 667     {
 668       struct type **first_dont_print;
 669       int i;
 670       struct type *target_type = TYPE_TARGET_TYPE (type);
 671
 672       first_dont_print
 673         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 674       i = obstack_object_size (&dont_print_stat_array_obstack)
 675         / sizeof (struct type *);
 676
 677       while (--i >= 0)
 678         {
 679           if (target_type == first_dont_print[i])
 680             {
 681               fputs_filtered ("<same as static member of an already"
 682                               " seen type>",
 683                               stream);
 684               return;
 685             }
 686         }
 687
 688       obstack_grow (&dont_print_stat_array_obstack,
 689                     (char *) &target_type,
 690                     sizeof (struct type *));
 691     }
 692
 693   opts = *options;
 694   opts.deref_ref = 0;
 695   val_print (type,
 696              value_embedded_offset (val),
 697              value_address (val),
 698              stream, recurse, val,
 699              &opts, current_language);
 700 }
 701
 702 /* Find the field in *SELF, or its non-virtual base classes, with
 703    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
 704    to the containing field number.  If OFFSET is not exactly at the
 705    start of some field, set *SELF to NULL.  */
 706
 707 static void
 708 cp_find_class_member (struct type **self_p, int *fieldno,
 709                       LONGEST offset)
 710 {
 711   struct type *self;
 712   unsigned int i;
 713   unsigned len;
 714
 715   *self_p = check_typedef (*self_p);
 716   self = *self_p;
 717   len = TYPE_NFIELDS (self);
 718
 719   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
 720     {
 721       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 722
 723       QUIT;
 724       if (offset == bitpos)
 725         {
 726           *fieldno = i;
 727           return;
 728         }
 729     }
 730
 731   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 732     {
 733       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 734       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
 735
 736       if (offset >= bitpos && offset < bitpos + bitsize)
 737         {
 738           *self_p = TYPE_FIELD_TYPE (self, i);
 739           cp_find_class_member (self_p, fieldno, offset - bitpos);
 740           return;
 741         }
 742     }
 743
 744   *self_p = NULL;
 745 }
 746
 747 void
 748 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 749                        struct ui_file *stream, const char *prefix)
 750 {
 751   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 752
 753   /* VAL is a byte offset into the structure type SELF_TYPE.
 754      Find the name of the field for that offset and
 755      print it.  */
 756   struct type *self_type = TYPE_SELF_TYPE (type);
 757   LONGEST val;
 758   int fieldno;
 759
 760   val = extract_signed_integer (valaddr,
 761                                 TYPE_LENGTH (type),
 762                                 byte_order);
 763
 764   /* Pointers to data members are usually byte offsets into an object.
 765      Because a data member can have offset zero, and a NULL pointer to
 766      member must be distinct from any valid non-NULL pointer to
 767      member, either the value is biased or the NULL value has a
 768      special representation; both are permitted by ISO C++.  HP aCC
 769      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 770      and other compilers which use the Itanium ABI use -1 as the NULL
 771      value.  GDB only supports that last form; to add support for
 772      another form, make this into a cp-abi hook.  */
 773
 774   if (val == -1)
 775     {
 776       fprintf_filtered (stream, "NULL");
 777       return;
 778     }
 779
 780   cp_find_class_member (&self_type, &fieldno, val << 3);
 781
 782   if (self_type != NULL)
 783     {
 784       const char *name;
 785
 786       fputs_filtered (prefix, stream);
 787       name = TYPE_NAME (self_type);
 788       if (name)
 789         fputs_filtered (name, stream);
 790       else
 791         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 792       fprintf_filtered (stream, "::");
 793       fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
 794     }
 795   else
 796     fprintf_filtered (stream, "%ld", (long) val);
 797 }
 798
 799
 800 void
 801 _initialize_cp_valprint (void)
 802 {
 803   add_setshow_boolean_cmd ("static-members", class_support,
 804                            &user_print_options.static_field_print, _("\
 805 Set printing of C++ static members."), _("\
 806 Show printing of C++ static members."), NULL,
 807                            NULL,
 808                            show_static_field_print,
 809                            &setprintlist, &showprintlist);
 810
 811   add_setshow_boolean_cmd ("vtbl", class_support,
 812                            &user_print_options.vtblprint, _("\
 813 Set printing of C++ virtual function tables."), _("\
 814 Show printing of C++ virtual function tables."), NULL,
 815                            NULL,
 816                            show_vtblprint,
 817                            &setprintlist, &showprintlist);
 818
 819   add_setshow_boolean_cmd ("object", class_support,
 820                            &user_print_options.objectprint, _("\
 821 Set printing of object's derived type based on vtable info."), _("\
 822 Show printing of object's derived type based on vtable info."), NULL,
 823                            NULL,
 824                            show_objectprint,
 825                            &setprintlist, &showprintlist);
 826
 827   obstack_begin (&dont_print_stat_array_obstack,
 828                  32 * sizeof (struct type *));
 829   obstack_begin (&dont_print_statmem_obstack,
 830                  32 * sizeof (CORE_ADDR));
 831   obstack_begin (&dont_print_vb_obstack,
 832                  32 * sizeof (struct type *));
 833 }