gdb/cp-valprint.c

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