gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2013 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 "gdb_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 "python/python.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->pretty)
 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->pretty)
 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           if (options->inspect_it)
 263             {
 264               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 265                 fputs_filtered ("\"( ptr \"", stream);
 266               else
 267                 fputs_filtered ("\"( nodef \"", stream);
 268               if (field_is_static (&TYPE_FIELD (type, i)))
 269                 fputs_filtered ("static ", stream);
 270               fprintf_symbol_filtered (stream,
 271                                        TYPE_FIELD_NAME (type, i),
 272                                        current_language->la_language,
 273                                        DMGL_PARAMS | DMGL_ANSI);
 274               fputs_filtered ("\" \"", stream);
 275               fprintf_symbol_filtered (stream,
 276                                        TYPE_FIELD_NAME (type, i),
 277                                        current_language->la_language,
 278                                        DMGL_PARAMS | DMGL_ANSI);
 279               fputs_filtered ("\") \"", stream);
 280             }
 281           else
 282             {
 283               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 284
 285               if (field_is_static (&TYPE_FIELD (type, i)))
 286                 fputs_filtered ("static ", stream);
 287               fprintf_symbol_filtered (stream,
 288                                        TYPE_FIELD_NAME (type, i),
 289                                        current_language->la_language,
 290                                        DMGL_PARAMS | DMGL_ANSI);
 291               annotate_field_name_end ();
 292               /* Do not print leading '=' in case of anonymous
 293                  unions.  */
 294               if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 295                 fputs_filtered (" = ", stream);
 296               annotate_field_value ();
 297             }
 298
 299           if (!field_is_static (&TYPE_FIELD (type, i))
 300               && TYPE_FIELD_PACKED (type, i))
 301             {
 302               struct value *v;
 303
 304               /* Bitfields require special handling, especially due to
 305                  byte order problems.  */
 306               if (TYPE_FIELD_IGNORE (type, i))
 307                 {
 308                   fputs_filtered ("<optimized out or zero length>", stream);
 309                 }
 310               else if (value_bits_synthetic_pointer (val,
 311                                                      TYPE_FIELD_BITPOS (type,
 312                                                                         i),
 313                                                      TYPE_FIELD_BITSIZE (type,
 314                                                                          i)))
 315                 {
 316                   fputs_filtered (_("<synthetic pointer>"), stream);
 317                 }
 318               else if (!value_bits_valid (val,
 319                                           TYPE_FIELD_BITPOS (type, i),
 320                                           TYPE_FIELD_BITSIZE (type, i)))
 321                 {
 322                   val_print_optimized_out (stream);
 323                 }
 324               else
 325                 {
 326                   struct value_print_options opts = *options;
 327
 328                   opts.deref_ref = 0;
 329
 330                   v = value_field_bitfield (type, i, valaddr, offset, val);
 331
 332                   common_val_print (v, stream, recurse + 1, &opts,
 333                                     current_language);
 334                 }
 335             }
 336           else
 337             {
 338               if (TYPE_FIELD_IGNORE (type, i))
 339                 {
 340                   fputs_filtered ("<optimized out or zero length>",
 341                                   stream);
 342                 }
 343               else if (field_is_static (&TYPE_FIELD (type, i)))
 344                 {
 345                   volatile struct gdb_exception ex;
 346                   struct value *v = NULL;
 347
 348                   TRY_CATCH (ex, RETURN_MASK_ERROR)
 349                     {
 350                       v = value_static_field (type, i);
 351                     }
 352
 353                   if (ex.reason < 0)
 354                     fprintf_filtered (stream,
 355                                       _("<error reading variable: %s>"),
 356                                       ex.message);
 357                   else if (v == NULL)
 358                     val_print_optimized_out (stream);
 359                   else
 360                     cp_print_static_field (TYPE_FIELD_TYPE (type, i),
 361                                            v, stream, recurse + 1,
 362                                            options);
 363                 }
 364               else if (i == vptr_fieldno && type == vptr_basetype)
 365                 {
 366                   int i_offset = offset + TYPE_FIELD_BITPOS (type, i) / 8;
 367                   struct type *i_type = TYPE_FIELD_TYPE (type, i);
 368
 369                   if (valprint_check_validity (stream, i_type, i_offset, val))
 370                     {
 371                       CORE_ADDR addr;
 372
 373                       addr = extract_typed_address (valaddr + i_offset, i_type);
 374                       print_function_pointer_address (options,
 375                                                       get_type_arch (type),
 376                                                       addr, stream);
 377                     }
 378                 }
 379               else
 380                 {
 381                   struct value_print_options opts = *options;
 382
 383                   opts.deref_ref = 0;
 384                   val_print (TYPE_FIELD_TYPE (type, i),
 385                              valaddr,
 386                              offset + TYPE_FIELD_BITPOS (type, i) / 8,
 387                              address,
 388                              stream, recurse + 1, val, &opts,
 389                              current_language);
 390                 }
 391             }
 392           annotate_field_end ();
 393         }
 394
 395       if (dont_print_statmem == 0)
 396         {
 397           int obstack_final_size =
 398            obstack_object_size (&dont_print_statmem_obstack);
 399
 400           if (obstack_final_size > statmem_obstack_initial_size)
 401             {
 402               /* In effect, a pop of the printed-statics stack.  */
 403
 404               void *free_to_ptr =
 405                 obstack_next_free (&dont_print_statmem_obstack) -
 406                 (obstack_final_size - statmem_obstack_initial_size);
 407
 408               obstack_free (&dont_print_statmem_obstack,
 409                             free_to_ptr);
 410             }
 411
 412           if (last_set_recurse != recurse)
 413             {
 414               int obstack_final_size =
 415                 obstack_object_size (&dont_print_stat_array_obstack);
 416
 417               if (obstack_final_size > stat_array_obstack_initial_size)
 418                 {
 419                   void *free_to_ptr =
 420                     obstack_next_free (&dont_print_stat_array_obstack)
 421                     - (obstack_final_size
 422                        - stat_array_obstack_initial_size);
 423
 424                   obstack_free (&dont_print_stat_array_obstack,
 425                                 free_to_ptr);
 426                 }
 427               last_set_recurse = -1;
 428             }
 429         }
 430
 431       if (options->pretty)
 432         {
 433           fprintf_filtered (stream, "\n");
 434           print_spaces_filtered (2 * recurse, stream);
 435         }
 436     }                           /* if there are data fields */
 437
 438   fprintf_filtered (stream, "}");
 439 }
 440
 441 /* Like cp_print_value_fields, but find the runtime type of the object
 442    and pass it as the `real_type' argument to cp_print_value_fields.
 443    This function is a hack to work around the fact that
 444    common_val_print passes the embedded offset to val_print, but not
 445    the enclosing type.  */
 446
 447 void
 448 cp_print_value_fields_rtti (struct type *type,
 449                             const gdb_byte *valaddr, int offset,
 450                             CORE_ADDR address,
 451                             struct ui_file *stream, int recurse,
 452                             const struct value *val,
 453                             const struct value_print_options *options,
 454                             struct type **dont_print_vb,
 455                             int dont_print_statmem)
 456 {
 457   struct type *real_type = NULL;
 458
 459   /* We require all bits to be valid in order to attempt a
 460      conversion.  */
 461   if (value_bits_valid (val, TARGET_CHAR_BIT * offset,
 462                         TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 463     {
 464       struct value *value;
 465       int full, top, using_enc;
 466
 467       /* Ugh, we have to convert back to a value here.  */
 468       value = value_from_contents_and_address (type, valaddr + offset,
 469                                                address + offset);
 470       /* We don't actually care about most of the result here -- just
 471          the type.  We already have the correct offset, due to how
 472          val_print was initially called.  */
 473       real_type = value_rtti_type (value, &full, &top, &using_enc);
 474     }
 475
 476   if (!real_type)
 477     real_type = type;
 478
 479   cp_print_value_fields (type, real_type, valaddr, offset,
 480                          address, stream, recurse, val, options,
 481                          dont_print_vb, dont_print_statmem);
 482 }
 483
 484 /* Special val_print routine to avoid printing multiple copies of
 485    virtual baseclasses.  */
 486
 487 static void
 488 cp_print_value (struct type *type, struct type *real_type,
 489                 const gdb_byte *valaddr, int offset,
 490                 CORE_ADDR address, struct ui_file *stream,
 491                 int recurse, const struct value *val,
 492                 const struct value_print_options *options,
 493                 struct type **dont_print_vb)
 494 {
 495   struct type **last_dont_print
 496     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 497   struct obstack tmp_obstack = dont_print_vb_obstack;
 498   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 499   int thisoffset;
 500   struct type *thistype;
 501
 502   if (dont_print_vb == 0)
 503     {
 504       /* If we're at top level, carve out a completely fresh chunk of
 505          the obstack and use that until this particular invocation
 506          returns.  */
 507       /* Bump up the high-water mark.  Now alpha is omega.  */
 508       obstack_finish (&dont_print_vb_obstack);
 509     }
 510
 511   for (i = 0; i < n_baseclasses; i++)
 512     {
 513       int boffset = 0;
 514       int skip;
 515       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 516       const char *basename = TYPE_NAME (baseclass);
 517       const gdb_byte *base_valaddr = NULL;
 518       const struct value *base_val = NULL;
 519       volatile struct gdb_exception ex;
 520
 521       if (BASETYPE_VIA_VIRTUAL (type, i))
 522         {
 523           struct type **first_dont_print
 524             = (struct type **) obstack_base (&dont_print_vb_obstack);
 525
 526           int j = (struct type **)
 527             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 528
 529           while (--j >= 0)
 530             if (baseclass == first_dont_print[j])
 531               goto flush_it;
 532
 533           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 534         }
 535
 536       thisoffset = offset;
 537       thistype = real_type;
 538
 539       TRY_CATCH (ex, RETURN_MASK_ERROR)
 540         {
 541           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 542         }
 543       if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
 544         skip = -1;
 545       else if (ex.reason < 0)
 546         skip = 1;
 547       else
 548         {
 549           skip = 0;
 550
 551           if (BASETYPE_VIA_VIRTUAL (type, i))
 552             {
 553               /* The virtual base class pointer might have been
 554                  clobbered by the user program. Make sure that it
 555                  still points to a valid memory location.  */
 556
 557               if ((boffset + offset) < 0
 558                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 559                 {
 560                   gdb_byte *buf;
 561                   struct cleanup *back_to;
 562
 563                   buf = xmalloc (TYPE_LENGTH (baseclass));
 564                   back_to = make_cleanup (xfree, buf);
 565
 566                   if (target_read_memory (address + boffset, buf,
 567                                           TYPE_LENGTH (baseclass)) != 0)
 568                     skip = 1;
 569                   base_val = value_from_contents_and_address (baseclass,
 570                                                               buf,
 571                                                               address + boffset);
 572                   thisoffset = 0;
 573                   boffset = 0;
 574                   thistype = baseclass;
 575                   base_valaddr = value_contents_for_printing_const (base_val);
 576                   do_cleanups (back_to);
 577                 }
 578               else
 579                 {
 580                   base_valaddr = valaddr;
 581                   base_val = val;
 582                 }
 583             }
 584           else
 585             {
 586               base_valaddr = valaddr;
 587               base_val = val;
 588             }
 589         }
 590
 591       /* Now do the printing.  */
 592       if (options->pretty)
 593         {
 594           fprintf_filtered (stream, "\n");
 595           print_spaces_filtered (2 * recurse, stream);
 596         }
 597       fputs_filtered ("<", stream);
 598       /* Not sure what the best notation is in the case where there is
 599          no baseclass name.  */
 600       fputs_filtered (basename ? basename : "", stream);
 601       fputs_filtered ("> = ", stream);
 602
 603       if (skip < 0)
 604         val_print_unavailable (stream);
 605       else if (skip > 0)
 606         val_print_invalid_address (stream);
 607       else
 608         {
 609           int result = 0;
 610
 611           /* Attempt to run the Python pretty-printers on the
 612              baseclass if possible.  */
 613           if (!options->raw)
 614             result = apply_val_pretty_printer (baseclass, base_valaddr,
 615                                                thisoffset + boffset,
 616                                                value_address (base_val),
 617                                                stream, recurse, base_val,
 618                                                options, current_language);
 619
 620
 621
 622           if (!result)
 623             cp_print_value_fields (baseclass, thistype, base_valaddr,
 624                                    thisoffset + boffset,
 625                                    value_address (base_val),
 626                                    stream, recurse, base_val, options,
 627                                    ((struct type **)
 628                                     obstack_base (&dont_print_vb_obstack)),
 629                                    0);
 630         }
 631       fputs_filtered (", ", stream);
 632
 633     flush_it:
 634       ;
 635     }
 636
 637   if (dont_print_vb == 0)
 638     {
 639       /* Free the space used to deal with the printing
 640          of this type from top level.  */
 641       obstack_free (&dont_print_vb_obstack, last_dont_print);
 642       /* Reset watermark so that we can continue protecting
 643          ourselves from whatever we were protecting ourselves.  */
 644       dont_print_vb_obstack = tmp_obstack;
 645     }
 646 }
 647
 648 /* Print value of a static member.  To avoid infinite recursion when
 649    printing a class that contains a static instance of the class, we
 650    keep the addresses of all printed static member classes in an
 651    obstack and refuse to print them more than once.
 652
 653    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 654    have the same meanings as in c_val_print.  */
 655
 656 static void
 657 cp_print_static_field (struct type *type,
 658                        struct value *val,
 659                        struct ui_file *stream,
 660                        int recurse,
 661                        const struct value_print_options *options)
 662 {
 663   struct value_print_options opts;
 664
 665   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 666     {
 667       CORE_ADDR *first_dont_print;
 668       CORE_ADDR addr;
 669       int i;
 670
 671       first_dont_print
 672         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 673       i = obstack_object_size (&dont_print_statmem_obstack)
 674         / sizeof (CORE_ADDR);
 675
 676       while (--i >= 0)
 677         {
 678           if (value_address (val) == first_dont_print[i])
 679             {
 680               fputs_filtered ("<same as static member of an already"
 681                               " seen type>",
 682                               stream);
 683               return;
 684             }
 685         }
 686
 687       addr = value_address (val);
 688       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 689                     sizeof (CORE_ADDR));
 690       CHECK_TYPEDEF (type);
 691       cp_print_value_fields (type, value_enclosing_type (val),
 692                              value_contents_for_printing (val),
 693                              value_embedded_offset (val), addr,
 694                              stream, recurse, val,
 695                              options, NULL, 1);
 696       return;
 697     }
 698
 699   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 700     {
 701       struct type **first_dont_print;
 702       int i;
 703       struct type *target_type = TYPE_TARGET_TYPE (type);
 704
 705       first_dont_print
 706         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 707       i = obstack_object_size (&dont_print_stat_array_obstack)
 708         / sizeof (struct type *);
 709
 710       while (--i >= 0)
 711         {
 712           if (target_type == first_dont_print[i])
 713             {
 714               fputs_filtered ("<same as static member of an already"
 715                               " seen type>",
 716                               stream);
 717               return;
 718             }
 719         }
 720
 721       obstack_grow (&dont_print_stat_array_obstack,
 722                     (char *) &target_type,
 723                     sizeof (struct type *));
 724     }
 725
 726   opts = *options;
 727   opts.deref_ref = 0;
 728   val_print (type, value_contents_for_printing (val),
 729              value_embedded_offset (val),
 730              value_address (val),
 731              stream, recurse, val,
 732              &opts, current_language);
 733 }
 734
 735
 736 /* Find the field in *DOMAIN, or its non-virtual base classes, with
 737    bit offset OFFSET.  Set *DOMAIN to the containing type and *FIELDNO
 738    to the containing field number.  If OFFSET is not exactly at the
 739    start of some field, set *DOMAIN to NULL.  */
 740
 741 static void
 742 cp_find_class_member (struct type **domain_p, int *fieldno,
 743                       LONGEST offset)
 744 {
 745   struct type *domain;
 746   unsigned int i;
 747   unsigned len;
 748
 749   *domain_p = check_typedef (*domain_p);
 750   domain = *domain_p;
 751   len = TYPE_NFIELDS (domain);
 752
 753   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 754     {
 755       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 756
 757       QUIT;
 758       if (offset == bitpos)
 759         {
 760           *fieldno = i;
 761           return;
 762         }
 763     }
 764
 765   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 766     {
 767       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 768       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
 769
 770       if (offset >= bitpos && offset < bitpos + bitsize)
 771         {
 772           *domain_p = TYPE_FIELD_TYPE (domain, i);
 773           cp_find_class_member (domain_p, fieldno, offset - bitpos);
 774           return;
 775         }
 776     }
 777
 778   *domain_p = NULL;
 779 }
 780
 781 void
 782 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 783                        struct ui_file *stream, char *prefix)
 784 {
 785   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 786
 787   /* VAL is a byte offset into the structure type DOMAIN.
 788      Find the name of the field for that offset and
 789      print it.  */
 790   struct type *domain = TYPE_DOMAIN_TYPE (type);
 791   LONGEST val;
 792   unsigned int fieldno;
 793
 794   val = extract_signed_integer (valaddr,
 795                                 TYPE_LENGTH (type),
 796                                 byte_order);
 797
 798   /* Pointers to data members are usually byte offsets into an object.
 799      Because a data member can have offset zero, and a NULL pointer to
 800      member must be distinct from any valid non-NULL pointer to
 801      member, either the value is biased or the NULL value has a
 802      special representation; both are permitted by ISO C++.  HP aCC
 803      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 804      and other compilers which use the Itanium ABI use -1 as the NULL
 805      value.  GDB only supports that last form; to add support for
 806      another form, make this into a cp-abi hook.  */
 807
 808   if (val == -1)
 809     {
 810       fprintf_filtered (stream, "NULL");
 811       return;
 812     }
 813
 814   cp_find_class_member (&domain, &fieldno, val << 3);
 815
 816   if (domain != NULL)
 817     {
 818       const char *name;
 819
 820       fputs_filtered (prefix, stream);
 821       name = type_name_no_tag (domain);
 822       if (name)
 823         fputs_filtered (name, stream);
 824       else
 825         c_type_print_base (domain, stream, 0, 0, &type_print_raw_options);
 826       fprintf_filtered (stream, "::");
 827       fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
 828     }
 829   else
 830     fprintf_filtered (stream, "%ld", (long) val);
 831 }
 832
 833
 834 void
 835 _initialize_cp_valprint (void)
 836 {
 837   add_setshow_boolean_cmd ("static-members", class_support,
 838                            &user_print_options.static_field_print, _("\
 839 Set printing of C++ static members."), _("\
 840 Show printing of C++ static members."), NULL,
 841                            NULL,
 842                            show_static_field_print,
 843                            &setprintlist, &showprintlist);
 844
 845   add_setshow_boolean_cmd ("vtbl", class_support,
 846                            &user_print_options.vtblprint, _("\
 847 Set printing of C++ virtual function tables."), _("\
 848 Show printing of C++ virtual function tables."), NULL,
 849                            NULL,
 850                            show_vtblprint,
 851                            &setprintlist, &showprintlist);
 852
 853   add_setshow_boolean_cmd ("object", class_support,
 854                            &user_print_options.objectprint, _("\
 855 Set printing of object's derived type based on vtable info."), _("\
 856 Show printing of object's derived type based on vtable info."), NULL,
 857                            NULL,
 858                            show_objectprint,
 859                            &setprintlist, &showprintlist);
 860
 861   obstack_begin (&dont_print_stat_array_obstack,
 862                  32 * sizeof (struct type *));
 863   obstack_begin (&dont_print_statmem_obstack,
 864                  32 * sizeof (CORE_ADDR));
 865   obstack_begin (&dont_print_vb_obstack,
 866                  32 * sizeof (struct type *));
 867 }