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