gdb/cp-valprint.c

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