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