gdb/cp-valprint.c

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