gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2014 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 "exceptions.h"
  38 #include "typeprint.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 extern void _initialize_cp_valprint (void);
  78
  79 static void cp_print_static_field (struct type *, struct value *,
  80                                    struct ui_file *, int,
  81                                    const struct value_print_options *);
  82
  83 static void cp_print_value (struct type *, struct type *,
  84                             const gdb_byte *, int,
  85                             CORE_ADDR, struct ui_file *,
  86                             int, const struct value *,
  87                             const struct value_print_options *,
  88                             struct type **);
  89
  90
  91 /* GCC versions after 2.4.5 use this.  */
  92 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
  93
  94 /* Return truth value for assertion that TYPE is of the type
  95    "pointer to virtual function".  */
  96
  97 int
  98 cp_is_vtbl_ptr_type (struct type *type)
  99 {
 100   const char *typename = type_name_no_tag (type);
 101
 102   return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
 103 }
 104
 105 /* Return truth value for the assertion that TYPE is of the type
 106    "pointer to virtual function table".  */
 107
 108 int
 109 cp_is_vtbl_member (struct type *type)
 110 {
 111   /* With older versions of g++, the vtbl field pointed to an array of
 112      structures.  Nowadays it points directly to the structure.  */
 113   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 114     {
 115       type = TYPE_TARGET_TYPE (type);
 116       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 117         {
 118           type = TYPE_TARGET_TYPE (type);
 119           if (TYPE_CODE (type) == TYPE_CODE_STRUCT    /* if not using thunks */
 120               || TYPE_CODE (type) == TYPE_CODE_PTR)   /* if using thunks */
 121             {
 122               /* Virtual functions tables are full of pointers
 123                  to virtual functions.  */
 124               return cp_is_vtbl_ptr_type (type);
 125             }
 126         }
 127       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)  /* if not using thunks */
 128         {
 129           return cp_is_vtbl_ptr_type (type);
 130         }
 131       else if (TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
 132         {
 133           /* The type name of the thunk pointer is NULL when using
 134              dwarf2.  We could test for a pointer to a function, but
 135              there is no type info for the virtual table either, so it
 136              wont help.  */
 137           return cp_is_vtbl_ptr_type (type);
 138         }
 139     }
 140   return 0;
 141 }
 142
 143 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 144    print out a structure's fields: cp_print_value_fields and
 145    cp_print_value.
 146
 147    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
 148    meanings as in cp_print_value and c_val_print.
 149
 150    2nd argument REAL_TYPE is used to carry over the type of the
 151    derived class across the recursion to base classes.
 152
 153    DONT_PRINT is an array of baseclass types that we should not print,
 154    or zero if called from top level.  */
 155
 156 void
 157 cp_print_value_fields (struct type *type, struct type *real_type,
 158                        const gdb_byte *valaddr, int offset,
 159                        CORE_ADDR address, struct ui_file *stream,
 160                        int recurse, const struct value *val,
 161                        const struct value_print_options *options,
 162                        struct type **dont_print_vb,
 163                        int dont_print_statmem)
 164 {
 165   int i, len, n_baseclasses;
 166   int fields_seen = 0;
 167   static int last_set_recurse = -1;
 168
 169   CHECK_TYPEDEF (type);
 170
 171   if (recurse == 0)
 172     {
 173       /* Any object can be left on obstacks only during an unexpected
 174          error.  */
 175
 176       if (obstack_object_size (&dont_print_statmem_obstack) > 0)
 177         {
 178           obstack_free (&dont_print_statmem_obstack, NULL);
 179           obstack_begin (&dont_print_statmem_obstack,
 180                          32 * sizeof (CORE_ADDR));
 181         }
 182       if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
 183         {
 184           obstack_free (&dont_print_stat_array_obstack, NULL);
 185           obstack_begin (&dont_print_stat_array_obstack,
 186                          32 * sizeof (struct type *));
 187         }
 188     }
 189
 190   fprintf_filtered (stream, "{");
 191   len = TYPE_NFIELDS (type);
 192   n_baseclasses = TYPE_N_BASECLASSES (type);
 193
 194   /* First, print out baseclasses such that we don't print
 195      duplicates of virtual baseclasses.  */
 196
 197   if (n_baseclasses > 0)
 198     cp_print_value (type, real_type, valaddr,
 199                     offset, address, stream,
 200                     recurse + 1, val, options,
 201                     dont_print_vb);
 202
 203   /* Second, print out data fields */
 204
 205   /* If there are no data fields, skip this part */
 206   if (len == n_baseclasses || !len)
 207     fprintf_filtered (stream, "<No data fields>");
 208   else
 209     {
 210       size_t statmem_obstack_initial_size = 0;
 211       size_t stat_array_obstack_initial_size = 0;
 212       struct type *vptr_basetype = NULL;
 213       int vptr_fieldno;
 214
 215       if (dont_print_statmem == 0)
 216         {
 217           statmem_obstack_initial_size =
 218             obstack_object_size (&dont_print_statmem_obstack);
 219
 220           if (last_set_recurse != recurse)
 221             {
 222               stat_array_obstack_initial_size =
 223                 obstack_object_size (&dont_print_stat_array_obstack);
 224
 225               last_set_recurse = recurse;
 226             }
 227         }
 228
 229       vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
 230       for (i = n_baseclasses; i < len; i++)
 231         {
 232           /* If requested, skip printing of static fields.  */
 233           if (!options->static_field_print
 234               && field_is_static (&TYPE_FIELD (type, i)))
 235             continue;
 236
 237           if (fields_seen)
 238             fprintf_filtered (stream, ", ");
 239           else if (n_baseclasses > 0)
 240             {
 241               if (options->prettyformat)
 242                 {
 243                   fprintf_filtered (stream, "\n");
 244                   print_spaces_filtered (2 + 2 * recurse, stream);
 245                   fputs_filtered ("members of ", stream);
 246                   fputs_filtered (type_name_no_tag (type), stream);
 247                   fputs_filtered (": ", stream);
 248                 }
 249             }
 250           fields_seen = 1;
 251
 252           if (options->prettyformat)
 253             {
 254               fprintf_filtered (stream, "\n");
 255               print_spaces_filtered (2 + 2 * recurse, stream);
 256             }
 257           else
 258             {
 259               wrap_here (n_spaces (2 + 2 * recurse));
 260             }
 261
 262           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 263
 264           if (field_is_static (&TYPE_FIELD (type, i)))
 265             fputs_filtered ("static ", stream);
 266           fprintf_symbol_filtered (stream,
 267                                    TYPE_FIELD_NAME (type, i),
 268                                    current_language->la_language,
 269                                    DMGL_PARAMS | DMGL_ANSI);
 270           annotate_field_name_end ();
 271           /* Do not print leading '=' in case of anonymous
 272              unions.  */
 273           if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 274             fputs_filtered (" = ", stream);
 275           annotate_field_value ();
 276
 277           if (!field_is_static (&TYPE_FIELD (type, i))
 278               && TYPE_FIELD_PACKED (type, i))
 279             {
 280               struct value *v;
 281
 282               /* Bitfields require special handling, especially due to
 283                  byte order problems.  */
 284               if (TYPE_FIELD_IGNORE (type, i))
 285                 {
 286                   fputs_filtered ("<optimized out or zero length>", stream);
 287                 }
 288               else if (value_bits_synthetic_pointer (val,
 289                                                      TYPE_FIELD_BITPOS (type,
 290                                                                         i),
 291                                                      TYPE_FIELD_BITSIZE (type,
 292                                                                          i)))
 293                 {
 294                   fputs_filtered (_("<synthetic pointer>"), stream);
 295                 }
 296               else if (!value_bits_valid (val,
 297                                           TYPE_FIELD_BITPOS (type, i),
 298                                           TYPE_FIELD_BITSIZE (type, i)))
 299                 {
 300                   val_print_optimized_out (val, stream);
 301                 }
 302               else
 303                 {
 304                   struct value_print_options opts = *options;
 305
 306                   opts.deref_ref = 0;
 307
 308                   v = value_field_bitfield (type, i, valaddr, offset, val);
 309
 310                   common_val_print (v, stream, recurse + 1, &opts,
 311                                     current_language);
 312                 }
 313             }
 314           else
 315             {
 316               if (TYPE_FIELD_IGNORE (type, i))
 317                 {
 318                   fputs_filtered ("<optimized out or zero length>",
 319                                   stream);
 320                 }
 321               else if (field_is_static (&TYPE_FIELD (type, i)))
 322                 {
 323                   volatile struct gdb_exception ex;
 324                   struct value *v = NULL;
 325
 326                   TRY_CATCH (ex, RETURN_MASK_ERROR)
 327                     {
 328                       v = value_static_field (type, i);
 329                     }
 330
 331                   if (ex.reason < 0)
 332                     fprintf_filtered (stream,
 333                                       _("<error reading variable: %s>"),
 334                                       ex.message);
 335                   cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 336                                          v, stream, recurse + 1,
 337                                          options);
 338                 }
 339               else if (i == vptr_fieldno && type == vptr_basetype)
 340                 {
 341                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
 342                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
 343
 344                   if (valprint_check_validity (stream, i_type, i_offset, val))
 345                     {
 346                       CORE_ADDR addr;
 347
 348                       addr = extract_typed_address (valaddr + i_offset, i_type);
 349                       print_function_pointer_address (options,
 350                                                       get_type_arch (type),
 351                                                       addr, stream);
 352                     }
 353                 }
 354               else
 355                 {
 356                   struct value_print_options opts = *options;
 357
 358                   opts.deref_ref = 0;
 359                   val_print (TYPE_FIELD_TYPE (type, i),
 360                              valaddr,
 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
 379               void *free_to_ptr =
 380                 obstack_next_free (&dont_print_statmem_obstack) -
 381                 (obstack_final_size - statmem_obstack_initial_size);
 382
 383               obstack_free (&dont_print_statmem_obstack,
 384                             free_to_ptr);
 385             }
 386
 387           if (last_set_recurse != recurse)
 388             {
 389               size_t obstack_final_size =
 390                 obstack_object_size (&dont_print_stat_array_obstack);
 391
 392               if (obstack_final_size > stat_array_obstack_initial_size)
 393                 {
 394                   void *free_to_ptr =
 395                     obstack_next_free (&dont_print_stat_array_obstack)
 396                     - (obstack_final_size
 397                        - stat_array_obstack_initial_size);
 398
 399                   obstack_free (&dont_print_stat_array_obstack,
 400                                 free_to_ptr);
 401                 }
 402               last_set_recurse = -1;
 403             }
 404         }
 405
 406       if (options->prettyformat)
 407         {
 408           fprintf_filtered (stream, "\n");
 409           print_spaces_filtered (2 * recurse, stream);
 410         }
 411     }                           /* if there are data fields */
 412
 413   fprintf_filtered (stream, "}");
 414 }
 415
 416 /* Like cp_print_value_fields, but find the runtime type of the object
 417    and pass it as the `real_type' argument to cp_print_value_fields.
 418    This function is a hack to work around the fact that
 419    common_val_print passes the embedded offset to val_print, but not
 420    the enclosing type.  */
 421
 422 void
 423 cp_print_value_fields_rtti (struct type *type,
 424                             const gdb_byte *valaddr, int offset,
 425                             CORE_ADDR address,
 426                             struct ui_file *stream, int recurse,
 427                             const struct value *val,
 428                             const struct value_print_options *options,
 429                             struct type **dont_print_vb,
 430                             int dont_print_statmem)
 431 {
 432   struct type *real_type = NULL;
 433
 434   /* We require all bits to be valid in order to attempt a
 435      conversion.  */
 436   if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
 437                         TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 438     {
 439       struct value *value;
 440       int full, top, using_enc;
 441
 442       /* Ugh, we have to convert back to a value here.  */
 443       value = value_from_contents_and_address (type, valaddr + offset,
 444                                                address + offset);
 445       type = value_type (value);
 446       /* We don't actually care about most of the result here -- just
 447          the type.  We already have the correct offset, due to how
 448          val_print was initially called.  */
 449       real_type = value_rtti_type (value, &full, &top, &using_enc);
 450     }
 451
 452   if (!real_type)
 453     real_type = type;
 454
 455   cp_print_value_fields (type, real_type, valaddr, offset,
 456                          address, stream, recurse, val, options,
 457                          dont_print_vb, dont_print_statmem);
 458 }
 459
 460 /* Special val_print routine to avoid printing multiple copies of
 461    virtual baseclasses.  */
 462
 463 static void
 464 cp_print_value (struct type *type, struct type *real_type,
 465                 const gdb_byte *valaddr, int offset,
 466                 CORE_ADDR address, struct ui_file *stream,
 467                 int recurse, const struct value *val,
 468                 const struct value_print_options *options,
 469                 struct type **dont_print_vb)
 470 {
 471   struct type **last_dont_print
 472     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 473   struct obstack tmp_obstack = dont_print_vb_obstack;
 474   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 475   int thisoffset;
 476   struct type *thistype;
 477
 478   if (dont_print_vb == 0)
 479     {
 480       /* If we're at top level, carve out a completely fresh chunk of
 481          the obstack and use that until this particular invocation
 482          returns.  */
 483       /* Bump up the high-water mark.  Now alpha is omega.  */
 484       obstack_finish (&dont_print_vb_obstack);
 485     }
 486
 487   for (i = 0; i < n_baseclasses; i++)
 488     {
 489       int boffset = 0;
 490       int skip;
 491       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 492       const char *basename = TYPE_NAME (baseclass);
 493       const gdb_byte *base_valaddr = NULL;
 494       const struct value *base_val = NULL;
 495       volatile struct gdb_exception ex;
 496
 497       if (BASETYPE_VIA_VIRTUAL (type, i))
 498         {
 499           struct type **first_dont_print
 500             = (struct type **) obstack_base (&dont_print_vb_obstack);
 501
 502           int j = (struct type **)
 503             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 504
 505           while (--j >= 0)
 506             if (baseclass == first_dont_print[j])
 507               goto flush_it;
 508
 509           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 510         }
 511
 512       thisoffset = offset;
 513       thistype = real_type;
 514
 515       TRY_CATCH (ex, RETURN_MASK_ERROR)
 516         {
 517           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 518         }
 519       if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
 520         skip = -1;
 521       else if (ex.reason < 0)
 522         skip = 1;
 523       else
 524         {
 525           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 = 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       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
 719 /* Find the field in *DOMAIN, or its non-virtual base classes, with
 720    bit offset OFFSET.  Set *DOMAIN to the containing type and *FIELDNO
 721    to the containing field number.  If OFFSET is not exactly at the
 722    start of some field, set *DOMAIN to NULL.  */
 723
 724 static void
 725 cp_find_class_member (struct type **domain_p, int *fieldno,
 726                       LONGEST offset)
 727 {
 728   struct type *domain;
 729   unsigned int i;
 730   unsigned len;
 731
 732   *domain_p = check_typedef (*domain_p);
 733   domain = *domain_p;
 734   len = TYPE_NFIELDS (domain);
 735
 736   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 737     {
 738       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 739
 740       QUIT;
 741       if (offset == bitpos)
 742         {
 743           *fieldno = i;
 744           return;
 745         }
 746     }
 747
 748   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 749     {
 750       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 751       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
 752
 753       if (offset >= bitpos && offset < bitpos + bitsize)
 754         {
 755           *domain_p = TYPE_FIELD_TYPE (domain, i);
 756           cp_find_class_member (domain_p, fieldno, offset - bitpos);
 757           return;
 758         }
 759     }
 760
 761   *domain_p = NULL;
 762 }
 763
 764 void
 765 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 766                        struct ui_file *stream, char *prefix)
 767 {
 768   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 769
 770   /* VAL is a byte offset into the structure type DOMAIN.
 771      Find the name of the field for that offset and
 772      print it.  */
 773   struct type *domain = TYPE_DOMAIN_TYPE (type);
 774   LONGEST val;
 775   int fieldno;
 776
 777   val = extract_signed_integer (valaddr,
 778                                 TYPE_LENGTH (type),
 779                                 byte_order);
 780
 781   /* Pointers to data members are usually byte offsets into an object.
 782      Because a data member can have offset zero, and a NULL pointer to
 783      member must be distinct from any valid non-NULL pointer to
 784      member, either the value is biased or the NULL value has a
 785      special representation; both are permitted by ISO C++.  HP aCC
 786      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 787      and other compilers which use the Itanium ABI use -1 as the NULL
 788      value.  GDB only supports that last form; to add support for
 789      another form, make this into a cp-abi hook.  */
 790
 791   if (val == -1)
 792     {
 793       fprintf_filtered (stream, "NULL");
 794       return;
 795     }
 796
 797   cp_find_class_member (&domain, &fieldno, val << 3);
 798
 799   if (domain != NULL)
 800     {
 801       const char *name;
 802
 803       fputs_filtered (prefix, stream);
 804       name = type_name_no_tag (domain);
 805       if (name)
 806         fputs_filtered (name, stream);
 807       else
 808         c_type_print_base (domain, stream, 0, 0, &type_print_raw_options);
 809       fprintf_filtered (stream, "::");
 810       fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
 811     }
 812   else
 813     fprintf_filtered (stream, "%ld", (long) val);
 814 }
 815
 816
 817 void
 818 _initialize_cp_valprint (void)
 819 {
 820   add_setshow_boolean_cmd ("static-members", class_support,
 821                            &user_print_options.static_field_print, _("\
 822 Set printing of C++ static members."), _("\
 823 Show printing of C++ static members."), NULL,
 824                            NULL,
 825                            show_static_field_print,
 826                            &setprintlist, &showprintlist);
 827
 828   add_setshow_boolean_cmd ("vtbl", class_support,
 829                            &user_print_options.vtblprint, _("\
 830 Set printing of C++ virtual function tables."), _("\
 831 Show printing of C++ virtual function tables."), NULL,
 832                            NULL,
 833                            show_vtblprint,
 834                            &setprintlist, &showprintlist);
 835
 836   add_setshow_boolean_cmd ("object", class_support,
 837                            &user_print_options.objectprint, _("\
 838 Set printing of object's derived type based on vtable info."), _("\
 839 Show printing of object's derived type based on vtable info."), NULL,
 840                            NULL,
 841                            show_objectprint,
 842                            &setprintlist, &showprintlist);
 843
 844   obstack_begin (&dont_print_stat_array_obstack,
 845                  32 * sizeof (struct type *));
 846   obstack_begin (&dont_print_statmem_obstack,
 847                  32 * sizeof (CORE_ADDR));
 848   obstack_begin (&dont_print_vb_obstack,
 849                  32 * sizeof (struct type *));
 850 }