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       const gdb_byte *base_valaddr = NULL;
 494       struct value *base_val = NULL;
 495
 496       if (BASETYPE_VIA_VIRTUAL (type, i))
 497         {
 498           struct type **first_dont_print
 499             = (struct type **) obstack_base (&dont_print_vb_obstack);
 500
 501           int j = (struct type **)
 502             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 503
 504           while (--j >= 0)
 505             if (baseclass == first_dont_print[j])
 506               goto flush_it;
 507
 508           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 509         }
 510
 511       thisoffset = offset;
 512       thistype = real_type;
 513
 514       TRY
 515         {
 516           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 517         }
 518       CATCH (ex, RETURN_MASK_ERROR)
 519         {
 520           if (ex.error == NOT_AVAILABLE_ERROR)
 521             skip = -1;
 522           else
 523             skip = 1;
 524         }
 525       END_CATCH
 526
 527       if (skip == 0)
 528         {
 529           if (BASETYPE_VIA_VIRTUAL (type, i))
 530             {
 531               /* The virtual base class pointer might have been
 532                  clobbered by the user program. Make sure that it
 533                  still points to a valid memory location.  */
 534
 535               if ((boffset + offset) < 0
 536                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 537                 {
 538                   gdb_byte *buf;
 539                   struct cleanup *back_to;
 540
 541                   buf = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass));
 542                   back_to = make_cleanup (xfree, buf);
 543
 544                   if (target_read_memory (address + boffset, buf,
 545                                           TYPE_LENGTH (baseclass)) != 0)
 546                     skip = 1;
 547                   base_val = value_from_contents_and_address (baseclass,
 548                                                               buf,
 549                                                               address + boffset);
 550                   baseclass = value_type (base_val);
 551                   thisoffset = 0;
 552                   boffset = 0;
 553                   thistype = baseclass;
 554                   base_valaddr = value_contents_for_printing_const (base_val);
 555                   do_cleanups (back_to);
 556                 }
 557               else
 558                 {
 559                   base_valaddr = valaddr;
 560                   base_val = val;
 561                 }
 562             }
 563           else
 564             {
 565               base_valaddr = valaddr;
 566               base_val = val;
 567             }
 568         }
 569
 570       /* Now do the printing.  */
 571       if (options->prettyformat)
 572         {
 573           fprintf_filtered (stream, "\n");
 574           print_spaces_filtered (2 * recurse, stream);
 575         }
 576       fputs_filtered ("<", stream);
 577       /* Not sure what the best notation is in the case where there is
 578          no baseclass name.  */
 579       fputs_filtered (basename ? basename : "", stream);
 580       fputs_filtered ("> = ", stream);
 581
 582       if (skip < 0)
 583         val_print_unavailable (stream);
 584       else if (skip > 0)
 585         val_print_invalid_address (stream);
 586       else
 587         {
 588           int result = 0;
 589
 590           /* Attempt to run an extension language pretty-printer on the
 591              baseclass if possible.  */
 592           if (!options->raw)
 593             result
 594               = apply_ext_lang_val_pretty_printer (baseclass, base_valaddr,
 595                                                    thisoffset + boffset,
 596                                                    value_address (base_val),
 597                                                    stream, recurse,
 598                                                    base_val, options,
 599                                                    current_language);
 600
 601           if (!result)
 602             cp_print_value_fields (baseclass, thistype,
 603                                    thisoffset + boffset,
 604                                    value_address (base_val),
 605                                    stream, recurse, base_val, options,
 606                                    ((struct type **)
 607                                     obstack_base (&dont_print_vb_obstack)),
 608                                    0);
 609         }
 610       fputs_filtered (", ", stream);
 611
 612     flush_it:
 613       ;
 614     }
 615
 616   if (dont_print_vb == 0)
 617     {
 618       /* Free the space used to deal with the printing
 619          of this type from top level.  */
 620       obstack_free (&dont_print_vb_obstack, last_dont_print);
 621       /* Reset watermark so that we can continue protecting
 622          ourselves from whatever we were protecting ourselves.  */
 623       dont_print_vb_obstack = tmp_obstack;
 624     }
 625 }
 626
 627 /* Print value of a static member.  To avoid infinite recursion when
 628    printing a class that contains a static instance of the class, we
 629    keep the addresses of all printed static member classes in an
 630    obstack and refuse to print them more than once.
 631
 632    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 633    have the same meanings as in c_val_print.  */
 634
 635 static void
 636 cp_print_static_field (struct type *type,
 637                        struct value *val,
 638                        struct ui_file *stream,
 639                        int recurse,
 640                        const struct value_print_options *options)
 641 {
 642   struct value_print_options opts;
 643
 644   if (value_entirely_optimized_out (val))
 645     {
 646       val_print_optimized_out (val, stream);
 647       return;
 648     }
 649
 650   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 651     {
 652       CORE_ADDR *first_dont_print;
 653       CORE_ADDR addr;
 654       int i;
 655
 656       first_dont_print
 657         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 658       i = obstack_object_size (&dont_print_statmem_obstack)
 659         / sizeof (CORE_ADDR);
 660
 661       while (--i >= 0)
 662         {
 663           if (value_address (val) == first_dont_print[i])
 664             {
 665               fputs_filtered ("<same as static member of an already"
 666                               " seen type>",
 667                               stream);
 668               return;
 669             }
 670         }
 671
 672       addr = value_address (val);
 673       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 674                     sizeof (CORE_ADDR));
 675       type = check_typedef (type);
 676       cp_print_value_fields (type, value_enclosing_type (val),
 677                              value_embedded_offset (val), addr,
 678                              stream, recurse, val,
 679                              options, NULL, 1);
 680       return;
 681     }
 682
 683   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 684     {
 685       struct type **first_dont_print;
 686       int i;
 687       struct type *target_type = TYPE_TARGET_TYPE (type);
 688
 689       first_dont_print
 690         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 691       i = obstack_object_size (&dont_print_stat_array_obstack)
 692         / sizeof (struct type *);
 693
 694       while (--i >= 0)
 695         {
 696           if (target_type == first_dont_print[i])
 697             {
 698               fputs_filtered ("<same as static member of an already"
 699                               " seen type>",
 700                               stream);
 701               return;
 702             }
 703         }
 704
 705       obstack_grow (&dont_print_stat_array_obstack,
 706                     (char *) &target_type,
 707                     sizeof (struct type *));
 708     }
 709
 710   opts = *options;
 711   opts.deref_ref = 0;
 712   val_print (type,
 713              value_embedded_offset (val),
 714              value_address (val),
 715              stream, recurse, val,
 716              &opts, current_language);
 717 }
 718
 719 /* Find the field in *SELF, or its non-virtual base classes, with
 720    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
 721    to the containing field number.  If OFFSET is not exactly at the
 722    start of some field, set *SELF to NULL.  */
 723
 724 static void
 725 cp_find_class_member (struct type **self_p, int *fieldno,
 726                       LONGEST offset)
 727 {
 728   struct type *self;
 729   unsigned int i;
 730   unsigned len;
 731
 732   *self_p = check_typedef (*self_p);
 733   self = *self_p;
 734   len = TYPE_NFIELDS (self);
 735
 736   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
 737     {
 738       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 739
 740       QUIT;
 741       if (offset == bitpos)
 742         {
 743           *fieldno = i;
 744           return;
 745         }
 746     }
 747
 748   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 749     {
 750       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 751       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
 752
 753       if (offset >= bitpos && offset < bitpos + bitsize)
 754         {
 755           *self_p = TYPE_FIELD_TYPE (self, i);
 756           cp_find_class_member (self_p, fieldno, offset - bitpos);
 757           return;
 758         }
 759     }
 760
 761   *self_p = NULL;
 762 }
 763
 764 void
 765 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 766                        struct ui_file *stream, char *prefix)
 767 {
 768   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 769
 770   /* VAL is a byte offset into the structure type SELF_TYPE.
 771      Find the name of the field for that offset and
 772      print it.  */
 773   struct type *self_type = TYPE_SELF_TYPE (type);
 774   LONGEST val;
 775   int fieldno;
 776
 777   val = extract_signed_integer (valaddr,
 778                                 TYPE_LENGTH (type),
 779                                 byte_order);
 780
 781   /* Pointers to data members are usually byte offsets into an object.
 782      Because a data member can have offset zero, and a NULL pointer to
 783      member must be distinct from any valid non-NULL pointer to
 784      member, either the value is biased or the NULL value has a
 785      special representation; both are permitted by ISO C++.  HP aCC
 786      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 787      and other compilers which use the Itanium ABI use -1 as the NULL
 788      value.  GDB only supports that last form; to add support for
 789      another form, make this into a cp-abi hook.  */
 790
 791   if (val == -1)
 792     {
 793       fprintf_filtered (stream, "NULL");
 794       return;
 795     }
 796
 797   cp_find_class_member (&self_type, &fieldno, val << 3);
 798
 799   if (self_type != NULL)
 800     {
 801       const char *name;
 802
 803       fputs_filtered (prefix, stream);
 804       name = type_name_no_tag (self_type);
 805       if (name)
 806         fputs_filtered (name, stream);
 807       else
 808         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 809       fprintf_filtered (stream, "::");
 810       fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
 811     }
 812   else
 813     fprintf_filtered (stream, "%ld", (long) val);
 814 }
 815
 816
 817 void
 818 _initialize_cp_valprint (void)
 819 {
 820   add_setshow_boolean_cmd ("static-members", class_support,
 821                            &user_print_options.static_field_print, _("\
 822 Set printing of C++ static members."), _("\
 823 Show printing of C++ static members."), NULL,
 824                            NULL,
 825                            show_static_field_print,
 826                            &setprintlist, &showprintlist);
 827
 828   add_setshow_boolean_cmd ("vtbl", class_support,
 829                            &user_print_options.vtblprint, _("\
 830 Set printing of C++ virtual function tables."), _("\
 831 Show printing of C++ virtual function tables."), NULL,
 832                            NULL,
 833                            show_vtblprint,
 834                            &setprintlist, &showprintlist);
 835
 836   add_setshow_boolean_cmd ("object", class_support,
 837                            &user_print_options.objectprint, _("\
 838 Set printing of object's derived type based on vtable info."), _("\
 839 Show printing of object's derived type based on vtable info."), NULL,
 840                            NULL,
 841                            show_objectprint,
 842                            &setprintlist, &showprintlist);
 843
 844   obstack_begin (&dont_print_stat_array_obstack,
 845                  32 * sizeof (struct type *));
 846   obstack_begin (&dont_print_statmem_obstack,
 847                  32 * sizeof (CORE_ADDR));
 848   obstack_begin (&dont_print_vb_obstack,
 849                  32 * sizeof (struct type *));
 850 }