gdb/cp-valprint.c

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