gdb/cp-valprint.c

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