gdb/cp-valprint.c

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