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