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                             const gdb_byte *, int,
  84                             CORE_ADDR, struct ui_file *,
  85                             int, const struct value *,
  86                             const struct value_print_options *,
  87                             struct type **);
  88
  89
  90 /* GCC versions after 2.4.5 use this.  */
  91 EXPORTED_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                        const gdb_byte *valaddr, int offset,
 158                        CORE_ADDR address, struct ui_file *stream,
 159                        int recurse, const 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, valaddr,
 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           /* If requested, skip printing of static fields.  */
 232           if (!options->static_field_print
 233               && field_is_static (&TYPE_FIELD (type, i)))
 234             continue;
 235
 236           if (fields_seen)
 237             fprintf_filtered (stream, ", ");
 238           else if (n_baseclasses > 0)
 239             {
 240               if (options->prettyformat)
 241                 {
 242                   fprintf_filtered (stream, "\n");
 243                   print_spaces_filtered (2 + 2 * recurse, stream);
 244                   fputs_filtered ("members of ", stream);
 245                   fputs_filtered (type_name_no_tag (type), stream);
 246                   fputs_filtered (": ", stream);
 247                 }
 248             }
 249           fields_seen = 1;
 250
 251           if (options->prettyformat)
 252             {
 253               fprintf_filtered (stream, "\n");
 254               print_spaces_filtered (2 + 2 * recurse, stream);
 255             }
 256           else
 257             {
 258               wrap_here (n_spaces (2 + 2 * recurse));
 259             }
 260
 261           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 262
 263           if (field_is_static (&TYPE_FIELD (type, i)))
 264             fputs_filtered ("static ", stream);
 265           fprintf_symbol_filtered (stream,
 266                                    TYPE_FIELD_NAME (type, i),
 267                                    current_language->la_language,
 268                                    DMGL_PARAMS | DMGL_ANSI);
 269           annotate_field_name_end ();
 270           /* Do not print leading '=' in case of anonymous
 271              unions.  */
 272           if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 273             fputs_filtered (" = ", stream);
 274           annotate_field_value ();
 275
 276           if (!field_is_static (&TYPE_FIELD (type, i))
 277               && TYPE_FIELD_PACKED (type, i))
 278             {
 279               struct value *v;
 280
 281               /* Bitfields require special handling, especially due to
 282                  byte order problems.  */
 283               if (TYPE_FIELD_IGNORE (type, i))
 284                 {
 285                   fputs_filtered ("<optimized out or zero length>", stream);
 286                 }
 287               else if (value_bits_synthetic_pointer (val,
 288                                                      TYPE_FIELD_BITPOS (type,
 289                                                                         i),
 290                                                      TYPE_FIELD_BITSIZE (type,
 291                                                                          i)))
 292                 {
 293                   fputs_filtered (_("<synthetic pointer>"), stream);
 294                 }
 295               else
 296                 {
 297                   struct value_print_options opts = *options;
 298
 299                   opts.deref_ref = 0;
 300
 301                   v = value_field_bitfield (type, i, valaddr, offset, val);
 302
 303                   common_val_print (v, stream, recurse + 1, &opts,
 304                                     current_language);
 305                 }
 306             }
 307           else
 308             {
 309               if (TYPE_FIELD_IGNORE (type, i))
 310                 {
 311                   fputs_filtered ("<optimized out or zero length>",
 312                                   stream);
 313                 }
 314               else if (field_is_static (&TYPE_FIELD (type, i)))
 315                 {
 316                   struct value *v = NULL;
 317
 318                   TRY
 319                     {
 320                       v = value_static_field (type, i);
 321                     }
 322
 323                   CATCH (ex, RETURN_MASK_ERROR)
 324                     {
 325                       fprintf_filtered (stream,
 326                                         _("<error reading variable: %s>"),
 327                                         ex.message);
 328                     }
 329                   END_CATCH
 330
 331                   cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 332                                          v, stream, recurse + 1,
 333                                          options);
 334                 }
 335               else if (i == vptr_fieldno && type == vptr_basetype)
 336                 {
 337                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
 338                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
 339
 340                   if (valprint_check_validity (stream, i_type, i_offset, val))
 341                     {
 342                       CORE_ADDR addr;
 343
 344                       addr = extract_typed_address (valaddr + i_offset, i_type);
 345                       print_function_pointer_address (options,
 346                                                       get_type_arch (type),
 347                                                       addr, stream);
 348                     }
 349                 }
 350               else
 351                 {
 352                   struct value_print_options opts = *options;
 353
 354                   opts.deref_ref = 0;
 355                   val_print (TYPE_FIELD_TYPE (type, i),
 356                              valaddr,
 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
 375               void *free_to_ptr =
 376                 (char *) obstack_next_free (&dont_print_statmem_obstack) -
 377                 (obstack_final_size - statmem_obstack_initial_size);
 378
 379               obstack_free (&dont_print_statmem_obstack,
 380                             free_to_ptr);
 381             }
 382
 383           if (last_set_recurse != recurse)
 384             {
 385               size_t 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, int offset,
 421                             CORE_ADDR address,
 422                             struct ui_file *stream, int recurse,
 423                             const 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, top, using_enc;
 438
 439       /* Ugh, we have to convert back to a value here.  */
 440       value = value_from_contents_and_address (type, valaddr + offset,
 441                                                address + offset);
 442       type = value_type (value);
 443       /* We don't actually care about most of the result here -- just
 444          the type.  We already have the correct offset, due to how
 445          val_print was initially called.  */
 446       real_type = value_rtti_type (value, &full, &top, &using_enc);
 447     }
 448
 449   if (!real_type)
 450     real_type = type;
 451
 452   cp_print_value_fields (type, real_type, valaddr, offset,
 453                          address, stream, recurse, val, options,
 454                          dont_print_vb, dont_print_statmem);
 455 }
 456
 457 /* Special val_print routine to avoid printing multiple copies of
 458    virtual baseclasses.  */
 459
 460 static void
 461 cp_print_value (struct type *type, struct type *real_type,
 462                 const gdb_byte *valaddr, int offset,
 463                 CORE_ADDR address, struct ui_file *stream,
 464                 int recurse, const struct value *val,
 465                 const struct value_print_options *options,
 466                 struct type **dont_print_vb)
 467 {
 468   struct type **last_dont_print
 469     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 470   struct obstack tmp_obstack = dont_print_vb_obstack;
 471   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 472   int thisoffset;
 473   struct type *thistype;
 474
 475   if (dont_print_vb == 0)
 476     {
 477       /* If we're at top level, carve out a completely fresh chunk of
 478          the obstack and use that until this particular invocation
 479          returns.  */
 480       /* Bump up the high-water mark.  Now alpha is omega.  */
 481       obstack_finish (&dont_print_vb_obstack);
 482     }
 483
 484   for (i = 0; i < n_baseclasses; i++)
 485     {
 486       int boffset = 0;
 487       int skip = 0;
 488       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 489       const char *basename = TYPE_NAME (baseclass);
 490       const gdb_byte *base_valaddr = NULL;
 491       const struct value *base_val = NULL;
 492
 493       if (BASETYPE_VIA_VIRTUAL (type, i))
 494         {
 495           struct type **first_dont_print
 496             = (struct type **) obstack_base (&dont_print_vb_obstack);
 497
 498           int j = (struct type **)
 499             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 500
 501           while (--j >= 0)
 502             if (baseclass == first_dont_print[j])
 503               goto flush_it;
 504
 505           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 506         }
 507
 508       thisoffset = offset;
 509       thistype = real_type;
 510
 511       TRY
 512         {
 513           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 514         }
 515       CATCH (ex, RETURN_MASK_ERROR)
 516         {
 517           if (ex.error == NOT_AVAILABLE_ERROR)
 518             skip = -1;
 519           else
 520             skip = 1;
 521         }
 522       END_CATCH
 523
 524       if (skip == 0)
 525         {
 526           if (BASETYPE_VIA_VIRTUAL (type, i))
 527             {
 528               /* The virtual base class pointer might have been
 529                  clobbered by the user program. Make sure that it
 530                  still points to a valid memory location.  */
 531
 532               if ((boffset + offset) < 0
 533                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 534                 {
 535                   gdb_byte *buf;
 536                   struct cleanup *back_to;
 537
 538                   buf = (gdb_byte *) xmalloc (TYPE_LENGTH (baseclass));
 539                   back_to = make_cleanup (xfree, buf);
 540
 541                   if (target_read_memory (address + boffset, buf,
 542                                           TYPE_LENGTH (baseclass)) != 0)
 543                     skip = 1;
 544                   base_val = value_from_contents_and_address (baseclass,
 545                                                               buf,
 546                                                               address + boffset);
 547                   baseclass = value_type (base_val);
 548                   thisoffset = 0;
 549                   boffset = 0;
 550                   thistype = baseclass;
 551                   base_valaddr = value_contents_for_printing_const (base_val);
 552                   do_cleanups (back_to);
 553                 }
 554               else
 555                 {
 556                   base_valaddr = valaddr;
 557                   base_val = val;
 558                 }
 559             }
 560           else
 561             {
 562               base_valaddr = valaddr;
 563               base_val = val;
 564             }
 565         }
 566
 567       /* Now do the printing.  */
 568       if (options->prettyformat)
 569         {
 570           fprintf_filtered (stream, "\n");
 571           print_spaces_filtered (2 * recurse, stream);
 572         }
 573       fputs_filtered ("<", stream);
 574       /* Not sure what the best notation is in the case where there is
 575          no baseclass name.  */
 576       fputs_filtered (basename ? basename : "", stream);
 577       fputs_filtered ("> = ", stream);
 578
 579       if (skip < 0)
 580         val_print_unavailable (stream);
 581       else if (skip > 0)
 582         val_print_invalid_address (stream);
 583       else
 584         {
 585           int result = 0;
 586
 587           /* Attempt to run an extension language pretty-printer on the
 588              baseclass if possible.  */
 589           if (!options->raw)
 590             result
 591               = apply_ext_lang_val_pretty_printer (baseclass, base_valaddr,
 592                                                    thisoffset + boffset,
 593                                                    value_address (base_val),
 594                                                    stream, recurse,
 595                                                    base_val, options,
 596                                                    current_language);
 597
 598           if (!result)
 599             cp_print_value_fields (baseclass, thistype, base_valaddr,
 600                                    thisoffset + boffset,
 601                                    value_address (base_val),
 602                                    stream, recurse, base_val, options,
 603                                    ((struct type **)
 604                                     obstack_base (&dont_print_vb_obstack)),
 605                                    0);
 606         }
 607       fputs_filtered (", ", stream);
 608
 609     flush_it:
 610       ;
 611     }
 612
 613   if (dont_print_vb == 0)
 614     {
 615       /* Free the space used to deal with the printing
 616          of this type from top level.  */
 617       obstack_free (&dont_print_vb_obstack, last_dont_print);
 618       /* Reset watermark so that we can continue protecting
 619          ourselves from whatever we were protecting ourselves.  */
 620       dont_print_vb_obstack = tmp_obstack;
 621     }
 622 }
 623
 624 /* Print value of a static member.  To avoid infinite recursion when
 625    printing a class that contains a static instance of the class, we
 626    keep the addresses of all printed static member classes in an
 627    obstack and refuse to print them more than once.
 628
 629    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 630    have the same meanings as in c_val_print.  */
 631
 632 static void
 633 cp_print_static_field (struct type *type,
 634                        struct value *val,
 635                        struct ui_file *stream,
 636                        int recurse,
 637                        const struct value_print_options *options)
 638 {
 639   struct value_print_options opts;
 640
 641   if (value_entirely_optimized_out (val))
 642     {
 643       val_print_optimized_out (val, stream);
 644       return;
 645     }
 646
 647   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 648     {
 649       CORE_ADDR *first_dont_print;
 650       CORE_ADDR addr;
 651       int i;
 652
 653       first_dont_print
 654         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 655       i = obstack_object_size (&dont_print_statmem_obstack)
 656         / sizeof (CORE_ADDR);
 657
 658       while (--i >= 0)
 659         {
 660           if (value_address (val) == first_dont_print[i])
 661             {
 662               fputs_filtered ("<same as static member of an already"
 663                               " seen type>",
 664                               stream);
 665               return;
 666             }
 667         }
 668
 669       addr = value_address (val);
 670       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 671                     sizeof (CORE_ADDR));
 672       type = check_typedef (type);
 673       cp_print_value_fields (type, value_enclosing_type (val),
 674                              value_contents_for_printing (val),
 675                              value_embedded_offset (val), addr,
 676                              stream, recurse, val,
 677                              options, NULL, 1);
 678       return;
 679     }
 680
 681   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 682     {
 683       struct type **first_dont_print;
 684       int i;
 685       struct type *target_type = TYPE_TARGET_TYPE (type);
 686
 687       first_dont_print
 688         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 689       i = obstack_object_size (&dont_print_stat_array_obstack)
 690         / sizeof (struct type *);
 691
 692       while (--i >= 0)
 693         {
 694           if (target_type == first_dont_print[i])
 695             {
 696               fputs_filtered ("<same as static member of an already"
 697                               " seen type>",
 698                               stream);
 699               return;
 700             }
 701         }
 702
 703       obstack_grow (&dont_print_stat_array_obstack,
 704                     (char *) &target_type,
 705                     sizeof (struct type *));
 706     }
 707
 708   opts = *options;
 709   opts.deref_ref = 0;
 710   val_print (type, value_contents_for_printing (val),
 711              value_embedded_offset (val),
 712              value_address (val),
 713              stream, recurse, val,
 714              &opts, current_language);
 715 }
 716
 717 /* Find the field in *SELF, or its non-virtual base classes, with
 718    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
 719    to the containing field number.  If OFFSET is not exactly at the
 720    start of some field, set *SELF to NULL.  */
 721
 722 static void
 723 cp_find_class_member (struct type **self_p, int *fieldno,
 724                       LONGEST offset)
 725 {
 726   struct type *self;
 727   unsigned int i;
 728   unsigned len;
 729
 730   *self_p = check_typedef (*self_p);
 731   self = *self_p;
 732   len = TYPE_NFIELDS (self);
 733
 734   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
 735     {
 736       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 737
 738       QUIT;
 739       if (offset == bitpos)
 740         {
 741           *fieldno = i;
 742           return;
 743         }
 744     }
 745
 746   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 747     {
 748       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 749       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (self, i));
 750
 751       if (offset >= bitpos && offset < bitpos + bitsize)
 752         {
 753           *self_p = TYPE_FIELD_TYPE (self, i);
 754           cp_find_class_member (self_p, fieldno, offset - bitpos);
 755           return;
 756         }
 757     }
 758
 759   *self_p = NULL;
 760 }
 761
 762 void
 763 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 764                        struct ui_file *stream, char *prefix)
 765 {
 766   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 767
 768   /* VAL is a byte offset into the structure type SELF_TYPE.
 769      Find the name of the field for that offset and
 770      print it.  */
 771   struct type *self_type = TYPE_SELF_TYPE (type);
 772   LONGEST val;
 773   int fieldno;
 774
 775   val = extract_signed_integer (valaddr,
 776                                 TYPE_LENGTH (type),
 777                                 byte_order);
 778
 779   /* Pointers to data members are usually byte offsets into an object.
 780      Because a data member can have offset zero, and a NULL pointer to
 781      member must be distinct from any valid non-NULL pointer to
 782      member, either the value is biased or the NULL value has a
 783      special representation; both are permitted by ISO C++.  HP aCC
 784      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 785      and other compilers which use the Itanium ABI use -1 as the NULL
 786      value.  GDB only supports that last form; to add support for
 787      another form, make this into a cp-abi hook.  */
 788
 789   if (val == -1)
 790     {
 791       fprintf_filtered (stream, "NULL");
 792       return;
 793     }
 794
 795   cp_find_class_member (&self_type, &fieldno, val << 3);
 796
 797   if (self_type != NULL)
 798     {
 799       const char *name;
 800
 801       fputs_filtered (prefix, stream);
 802       name = type_name_no_tag (self_type);
 803       if (name)
 804         fputs_filtered (name, stream);
 805       else
 806         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 807       fprintf_filtered (stream, "::");
 808       fputs_filtered (TYPE_FIELD_NAME (self_type, fieldno), stream);
 809     }
 810   else
 811     fprintf_filtered (stream, "%ld", (long) val);
 812 }
 813
 814
 815 void
 816 _initialize_cp_valprint (void)
 817 {
 818   add_setshow_boolean_cmd ("static-members", class_support,
 819                            &user_print_options.static_field_print, _("\
 820 Set printing of C++ static members."), _("\
 821 Show printing of C++ static members."), NULL,
 822                            NULL,
 823                            show_static_field_print,
 824                            &setprintlist, &showprintlist);
 825
 826   add_setshow_boolean_cmd ("vtbl", class_support,
 827                            &user_print_options.vtblprint, _("\
 828 Set printing of C++ virtual function tables."), _("\
 829 Show printing of C++ virtual function tables."), NULL,
 830                            NULL,
 831                            show_vtblprint,
 832                            &setprintlist, &showprintlist);
 833
 834   add_setshow_boolean_cmd ("object", class_support,
 835                            &user_print_options.objectprint, _("\
 836 Set printing of object's derived type based on vtable info."), _("\
 837 Show printing of object's derived type based on vtable info."), NULL,
 838                            NULL,
 839                            show_objectprint,
 840                            &setprintlist, &showprintlist);
 841
 842   obstack_begin (&dont_print_stat_array_obstack,
 843                  32 * sizeof (struct type *));
 844   obstack_begin (&dont_print_statmem_obstack,
 845                  32 * sizeof (CORE_ADDR));
 846   obstack_begin (&dont_print_vb_obstack,
 847                  32 * sizeof (struct type *));
 848 }