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