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