contrib/gdb-7/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 #include "exceptions.h"
  41
  42 /* Controls printing of vtbl's.  */
  43 static void
  44 show_vtblprint (struct ui_file *file, int from_tty,
  45                 struct cmd_list_element *c, const char *value)
  46 {
  47   fprintf_filtered (file, _("\
  48 Printing of C++ virtual function tables is %s.\n"),
  49                     value);
  50 }
  51
  52 /* Controls looking up an object's derived type using what we find in
  53    its vtables.  */
  54 static void
  55 show_objectprint (struct ui_file *file, int from_tty,
  56                   struct cmd_list_element *c,
  57                   const char *value)
  58 {
  59   fprintf_filtered (file, _("\
  60 Printing of object's derived type based on vtable info is %s.\n"),
  61                     value);
  62 }
  63
  64 static void
  65 show_static_field_print (struct ui_file *file, int from_tty,
  66                          struct cmd_list_element *c,
  67                          const char *value)
  68 {
  69   fprintf_filtered (file,
  70                     _("Printing of C++ static members is %s.\n"),
  71                     value);
  72 }
  73
  74
  75 static struct obstack dont_print_vb_obstack;
  76 static struct obstack dont_print_statmem_obstack;
  77 static struct obstack dont_print_stat_array_obstack;
  78
  79 extern void _initialize_cp_valprint (void);
  80
  81 static void cp_print_static_field (struct type *, struct value *,
  82                                    struct ui_file *, int,
  83                                    const struct value_print_options *);
  84
  85 static void cp_print_value (struct type *, struct type *,
  86                             const gdb_byte *, int,
  87                             CORE_ADDR, struct ui_file *,
  88                             int, const struct value *,
  89                             const struct value_print_options *,
  90                             struct type **);
  91
  92
  93 /* GCC versions after 2.4.5 use this.  */
  94 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
  95
  96 /* Return truth value for assertion that TYPE is of the type
  97    "pointer to virtual function".  */
  98
  99 int
 100 cp_is_vtbl_ptr_type (struct type *type)
 101 {
 102   char *typename = type_name_no_tag (type);
 103
 104   return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
 105 }
 106
 107 /* Return truth value for the assertion that TYPE is of the type
 108    "pointer to virtual function table".  */
 109
 110 int
 111 cp_is_vtbl_member (struct type *type)
 112 {
 113   /* With older versions of g++, the vtbl field pointed to an array of
 114      structures.  Nowadays it points directly to the structure.  */
 115   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 116     {
 117       type = TYPE_TARGET_TYPE (type);
 118       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 119         {
 120           type = TYPE_TARGET_TYPE (type);
 121           if (TYPE_CODE (type) == TYPE_CODE_STRUCT    /* if not using thunks */
 122               || TYPE_CODE (type) == TYPE_CODE_PTR)   /* if using thunks */
 123             {
 124               /* Virtual functions tables are full of pointers
 125                  to virtual functions.  */
 126               return cp_is_vtbl_ptr_type (type);
 127             }
 128         }
 129       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)  /* if not using thunks */
 130         {
 131           return cp_is_vtbl_ptr_type (type);
 132         }
 133       else if (TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
 134         {
 135           /* The type name of the thunk pointer is NULL when using
 136              dwarf2.  We could test for a pointer to a function, but
 137              there is no type info for the virtual table either, so it
 138              wont help.  */
 139           return cp_is_vtbl_ptr_type (type);
 140         }
 141     }
 142   return 0;
 143 }
 144
 145 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 146    print out a structure's fields: cp_print_value_fields and
 147    cp_print_value.
 148
 149    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
 150    meanings as in cp_print_value and c_val_print.
 151
 152    2nd argument REAL_TYPE is used to carry over the type of the
 153    derived class across the recursion to base classes.
 154
 155    DONT_PRINT is an array of baseclass types that we should not print,
 156    or zero if called from top level.  */
 157
 158 void
 159 cp_print_value_fields (struct type *type, struct type *real_type,
 160                        const gdb_byte *valaddr, int offset,
 161                        CORE_ADDR address, struct ui_file *stream,
 162                        int recurse, const struct value *val,
 163                        const struct value_print_options *options,
 164                        struct type **dont_print_vb,
 165                        int dont_print_statmem)
 166 {
 167   int i, len, n_baseclasses;
 168   int fields_seen = 0;
 169   static int last_set_recurse = -1;
 170
 171   CHECK_TYPEDEF (type);
 172
 173   if (recurse == 0)
 174     {
 175       /* Any object can be left on obstacks only during an unexpected
 176          error.  */
 177
 178       if (obstack_object_size (&dont_print_statmem_obstack) > 0)
 179         {
 180           obstack_free (&dont_print_statmem_obstack, NULL);
 181           obstack_begin (&dont_print_statmem_obstack,
 182                          32 * sizeof (CORE_ADDR));
 183         }
 184       if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
 185         {
 186           obstack_free (&dont_print_stat_array_obstack, NULL);
 187           obstack_begin (&dont_print_stat_array_obstack,
 188                          32 * sizeof (struct type *));
 189         }
 190     }
 191
 192   fprintf_filtered (stream, "{");
 193   len = TYPE_NFIELDS (type);
 194   n_baseclasses = TYPE_N_BASECLASSES (type);
 195
 196   /* First, print out baseclasses such that we don't print
 197      duplicates of virtual baseclasses.  */
 198
 199   if (n_baseclasses > 0)
 200     cp_print_value (type, real_type, valaddr,
 201                     offset, address, stream,
 202                     recurse + 1, val, options,
 203                     dont_print_vb);
 204
 205   /* Second, print out data fields */
 206
 207   /* If there are no data fields, skip this part */
 208   if (len == n_baseclasses || !len)
 209     fprintf_filtered (stream, "<No data fields>");
 210   else
 211     {
 212       int statmem_obstack_initial_size = 0;
 213       int stat_array_obstack_initial_size = 0;
 214
 215       if (dont_print_statmem == 0)
 216         {
 217           statmem_obstack_initial_size =
 218             obstack_object_size (&dont_print_statmem_obstack);
 219
 220           if (last_set_recurse != recurse)
 221             {
 222               stat_array_obstack_initial_size =
 223                 obstack_object_size (&dont_print_stat_array_obstack);
 224
 225               last_set_recurse = recurse;
 226             }
 227         }
 228
 229       for (i = n_baseclasses; i < len; i++)
 230         {
 231           /* If requested, skip printing of static fields.  */
 232           if (!options->static_field_print
 233               && field_is_static (&TYPE_FIELD (type, i)))
 234             continue;
 235
 236           if (fields_seen)
 237             fprintf_filtered (stream, ", ");
 238           else if (n_baseclasses > 0)
 239             {
 240               if (options->pretty)
 241                 {
 242                   fprintf_filtered (stream, "\n");
 243                   print_spaces_filtered (2 + 2 * recurse, stream);
 244                   fputs_filtered ("members of ", stream);
 245                   fputs_filtered (type_name_no_tag (type), stream);
 246                   fputs_filtered (": ", stream);
 247                 }
 248             }
 249           fields_seen = 1;
 250
 251           if (options->pretty)
 252             {
 253               fprintf_filtered (stream, "\n");
 254               print_spaces_filtered (2 + 2 * recurse, stream);
 255             }
 256           else
 257             {
 258               wrap_here (n_spaces (2 + 2 * recurse));
 259             }
 260           if (options->inspect_it)
 261             {
 262               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 263                 fputs_filtered ("\"( ptr \"", stream);
 264               else
 265                 fputs_filtered ("\"( nodef \"", stream);
 266               if (field_is_static (&TYPE_FIELD (type, i)))
 267                 fputs_filtered ("static ", stream);
 268               fprintf_symbol_filtered (stream,
 269                                        TYPE_FIELD_NAME (type, i),
 270                                        current_language->la_language,
 271                                        DMGL_PARAMS | DMGL_ANSI);
 272               fputs_filtered ("\" \"", stream);
 273               fprintf_symbol_filtered (stream,
 274                                        TYPE_FIELD_NAME (type, i),
 275                                        current_language->la_language,
 276                                        DMGL_PARAMS | DMGL_ANSI);
 277               fputs_filtered ("\") \"", stream);
 278             }
 279           else
 280             {
 281               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 282
 283               if (field_is_static (&TYPE_FIELD (type, i)))
 284                 fputs_filtered ("static ", stream);
 285               fprintf_symbol_filtered (stream,
 286                                        TYPE_FIELD_NAME (type, i),
 287                                        current_language->la_language,
 288                                        DMGL_PARAMS | DMGL_ANSI);
 289               annotate_field_name_end ();
 290               /* Do not print leading '=' in case of anonymous
 291                  unions.  */
 292               if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 293                 fputs_filtered (" = ", stream);
 294               annotate_field_value ();
 295             }
 296
 297           if (!field_is_static (&TYPE_FIELD (type, i))
 298               && TYPE_FIELD_PACKED (type, i))
 299             {
 300               struct value *v;
 301
 302               /* Bitfields require special handling, especially due to
 303                  byte order problems.  */
 304               if (TYPE_FIELD_IGNORE (type, i))
 305                 {
 306                   fputs_filtered ("<optimized out or zero length>", stream);
 307                 }
 308               else if (value_bits_synthetic_pointer (val,
 309                                                      TYPE_FIELD_BITPOS (type,
 310                                                                         i),
 311                                                      TYPE_FIELD_BITSIZE (type,
 312                                                                          i)))
 313                 {
 314                   fputs_filtered (_("<synthetic pointer>"), stream);
 315                 }
 316               else if (!value_bits_valid (val,
 317                                           TYPE_FIELD_BITPOS (type, i),
 318                                           TYPE_FIELD_BITSIZE (type, i)))
 319                 {
 320                   val_print_optimized_out (stream);
 321                 }
 322               else
 323                 {
 324                   struct value_print_options opts = *options;
 325
 326                   opts.deref_ref = 0;
 327
 328                   v = value_field_bitfield (type, i, valaddr, offset, val);
 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                     val_print_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 = 0;
 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 = NULL;
 491       const struct value *base_val = NULL;
 492       volatile struct gdb_exception ex;
 493
 494       if (BASETYPE_VIA_VIRTUAL (type, i))
 495         {
 496           struct type **first_dont_print
 497             = (struct type **) obstack_base (&dont_print_vb_obstack);
 498
 499           int j = (struct type **)
 500             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 501
 502           while (--j >= 0)
 503             if (baseclass == first_dont_print[j])
 504               goto flush_it;
 505
 506           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 507         }
 508
 509       thisoffset = offset;
 510       thistype = real_type;
 511
 512       TRY_CATCH (ex, RETURN_MASK_ERROR)
 513         {
 514           boffset = baseclass_offset (type, i, valaddr, offset, address, val);
 515         }
 516       if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
 517         skip = -1;
 518       else if (ex.reason < 0)
 519         skip = 1;
 520       else
 521         {
 522           skip = 0;
 523
 524           if (BASETYPE_VIA_VIRTUAL (type, i))
 525             {
 526               /* The virtual base class pointer might have been
 527                  clobbered by the user program. Make sure that it
 528                  still points to a valid memory location.  */
 529
 530               if ((boffset + offset) < 0
 531                   || (boffset + offset) >= TYPE_LENGTH (real_type))
 532                 {
 533                   /* FIXME (alloca): unsafe if baseclass is really
 534                      really large.  */
 535                   gdb_byte *buf = alloca (TYPE_LENGTH (baseclass));
 536
 537                   if (target_read_memory (address + boffset, buf,
 538                                           TYPE_LENGTH (baseclass)) != 0)
 539                     skip = 1;
 540                   base_val = value_from_contents_and_address (baseclass,
 541                                                               buf,
 542                                                               address + boffset);
 543                   thisoffset = 0;
 544                   boffset = 0;
 545                   thistype = baseclass;
 546                   base_valaddr = value_contents_for_printing_const (base_val);
 547                 }
 548               else
 549                 {
 550                   base_valaddr = valaddr;
 551                   base_val = val;
 552                 }
 553             }
 554           else
 555             {
 556               base_valaddr = valaddr;
 557               base_val = val;
 558             }
 559         }
 560
 561       /* Now do the printing.  */
 562       if (options->pretty)
 563         {
 564           fprintf_filtered (stream, "\n");
 565           print_spaces_filtered (2 * recurse, stream);
 566         }
 567       fputs_filtered ("<", stream);
 568       /* Not sure what the best notation is in the case where there is
 569          no baseclass name.  */
 570       fputs_filtered (basename ? basename : "", stream);
 571       fputs_filtered ("> = ", stream);
 572
 573       if (skip < 0)
 574         val_print_unavailable (stream);
 575       else if (skip > 0)
 576         val_print_invalid_address (stream);
 577       else
 578         {
 579           int result = 0;
 580
 581           /* Attempt to run the Python pretty-printers on the
 582              baseclass if possible.  */
 583           if (!options->raw)
 584             result = apply_val_pretty_printer (baseclass, base_valaddr,
 585                                                thisoffset + boffset,
 586                                                value_address (base_val),
 587                                                stream, recurse, base_val,
 588                                                options, current_language);
 589
 590
 591
 592           if (!result)
 593             cp_print_value_fields (baseclass, thistype, base_valaddr,
 594                                    thisoffset + boffset,
 595                                    value_address (base_val),
 596                                    stream, recurse, base_val, options,
 597                                    ((struct type **)
 598                                     obstack_base (&dont_print_vb_obstack)),
 599                                    0);
 600         }
 601       fputs_filtered (", ", stream);
 602
 603     flush_it:
 604       ;
 605     }
 606
 607   if (dont_print_vb == 0)
 608     {
 609       /* Free the space used to deal with the printing
 610          of this type from top level.  */
 611       obstack_free (&dont_print_vb_obstack, last_dont_print);
 612       /* Reset watermark so that we can continue protecting
 613          ourselves from whatever we were protecting ourselves.  */
 614       dont_print_vb_obstack = tmp_obstack;
 615     }
 616 }
 617
 618 /* Print value of a static member.  To avoid infinite recursion when
 619    printing a class that contains a static instance of the class, we
 620    keep the addresses of all printed static member classes in an
 621    obstack and refuse to print them more than once.
 622
 623    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 624    have the same meanings as in c_val_print.  */
 625
 626 static void
 627 cp_print_static_field (struct type *type,
 628                        struct value *val,
 629                        struct ui_file *stream,
 630                        int recurse,
 631                        const struct value_print_options *options)
 632 {
 633   struct value_print_options opts;
 634
 635   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 636     {
 637       CORE_ADDR *first_dont_print;
 638       CORE_ADDR addr;
 639       int i;
 640
 641       first_dont_print
 642         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 643       i = obstack_object_size (&dont_print_statmem_obstack)
 644         / sizeof (CORE_ADDR);
 645
 646       while (--i >= 0)
 647         {
 648           if (value_address (val) == first_dont_print[i])
 649             {
 650               fputs_filtered ("<same as static member of an already"
 651                               " seen type>",
 652                               stream);
 653               return;
 654             }
 655         }
 656
 657       addr = value_address (val);
 658       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 659                     sizeof (CORE_ADDR));
 660       CHECK_TYPEDEF (type);
 661       cp_print_value_fields (type, value_enclosing_type (val),
 662                              value_contents_for_printing (val),
 663                              value_embedded_offset (val), addr,
 664                              stream, recurse, val,
 665                              options, NULL, 1);
 666       return;
 667     }
 668
 669   if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 670     {
 671       struct type **first_dont_print;
 672       int i;
 673       struct type *target_type = TYPE_TARGET_TYPE (type);
 674
 675       first_dont_print
 676         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 677       i = obstack_object_size (&dont_print_stat_array_obstack)
 678         / sizeof (struct type *);
 679
 680       while (--i >= 0)
 681         {
 682           if (target_type == first_dont_print[i])
 683             {
 684               fputs_filtered ("<same as static member of an already"
 685                               " seen type>",
 686                               stream);
 687               return;
 688             }
 689         }
 690
 691       obstack_grow (&dont_print_stat_array_obstack,
 692                     (char *) &target_type,
 693                     sizeof (struct type *));
 694     }
 695
 696   opts = *options;
 697   opts.deref_ref = 0;
 698   val_print (type, value_contents_for_printing (val),
 699              value_embedded_offset (val),
 700              value_address (val),
 701              stream, recurse, val,
 702              &opts, current_language);
 703 }
 704
 705
 706 /* Find the field in *DOMAIN, or its non-virtual base classes, with
 707    bit offset OFFSET.  Set *DOMAIN to the containing type and *FIELDNO
 708    to the containing field number.  If OFFSET is not exactly at the
 709    start of some field, set *DOMAIN to NULL.  */
 710
 711 static void
 712 cp_find_class_member (struct type **domain_p, int *fieldno,
 713                       LONGEST offset)
 714 {
 715   struct type *domain;
 716   unsigned int i;
 717   unsigned len;
 718
 719   *domain_p = check_typedef (*domain_p);
 720   domain = *domain_p;
 721   len = TYPE_NFIELDS (domain);
 722
 723   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 724     {
 725       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 726
 727       QUIT;
 728       if (offset == bitpos)
 729         {
 730           *fieldno = i;
 731           return;
 732         }
 733     }
 734
 735   for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
 736     {
 737       LONGEST bitpos = TYPE_FIELD_BITPOS (domain, i);
 738       LONGEST bitsize = 8 * TYPE_LENGTH (TYPE_FIELD_TYPE (domain, i));
 739
 740       if (offset >= bitpos && offset < bitpos + bitsize)
 741         {
 742           *domain_p = TYPE_FIELD_TYPE (domain, i);
 743           cp_find_class_member (domain_p, fieldno, offset - bitpos);
 744           return;
 745         }
 746     }
 747
 748   *domain_p = NULL;
 749 }
 750
 751 void
 752 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 753                        struct ui_file *stream, char *prefix)
 754 {
 755   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 756
 757   /* VAL is a byte offset into the structure type DOMAIN.
 758      Find the name of the field for that offset and
 759      print it.  */
 760   struct type *domain = TYPE_DOMAIN_TYPE (type);
 761   LONGEST val;
 762   unsigned int fieldno;
 763
 764   val = extract_signed_integer (valaddr,
 765                                 TYPE_LENGTH (type),
 766                                 byte_order);
 767
 768   /* Pointers to data members are usually byte offsets into an object.
 769      Because a data member can have offset zero, and a NULL pointer to
 770      member must be distinct from any valid non-NULL pointer to
 771      member, either the value is biased or the NULL value has a
 772      special representation; both are permitted by ISO C++.  HP aCC
 773      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 774      and other compilers which use the Itanium ABI use -1 as the NULL
 775      value.  GDB only supports that last form; to add support for
 776      another form, make this into a cp-abi hook.  */
 777
 778   if (val == -1)
 779     {
 780       fprintf_filtered (stream, "NULL");
 781       return;
 782     }
 783
 784   cp_find_class_member (&domain, &fieldno, val << 3);
 785
 786   if (domain != NULL)
 787     {
 788       char *name;
 789
 790       fputs_filtered (prefix, stream);
 791       name = type_name_no_tag (domain);
 792       if (name)
 793         fputs_filtered (name, stream);
 794       else
 795         c_type_print_base (domain, stream, 0, 0);
 796       fprintf_filtered (stream, "::");
 797       fputs_filtered (TYPE_FIELD_NAME (domain, fieldno), stream);
 798     }
 799   else
 800     fprintf_filtered (stream, "%ld", (long) val);
 801 }
 802
 803
 804 void
 805 _initialize_cp_valprint (void)
 806 {
 807   add_setshow_boolean_cmd ("static-members", class_support,
 808                            &user_print_options.static_field_print, _("\
 809 Set printing of C++ static members."), _("\
 810 Show printing of C++ static members."), NULL,
 811                            NULL,
 812                            show_static_field_print,
 813                            &setprintlist, &showprintlist);
 814
 815   add_setshow_boolean_cmd ("vtbl", class_support,
 816                            &user_print_options.vtblprint, _("\
 817 Set printing of C++ virtual function tables."), _("\
 818 Show printing of C++ virtual function tables."), NULL,
 819                            NULL,
 820                            show_vtblprint,
 821                            &setprintlist, &showprintlist);
 822
 823   add_setshow_boolean_cmd ("object", class_support,
 824                            &user_print_options.objectprint, _("\
 825 Set printing of object's derived type based on vtable info."), _("\
 826 Show printing of object's derived type based on vtable info."), NULL,
 827                            NULL,
 828                            show_objectprint,
 829                            &setprintlist, &showprintlist);
 830
 831   obstack_begin (&dont_print_stat_array_obstack,
 832                  32 * sizeof (struct type *));
 833   obstack_begin (&dont_print_statmem_obstack,
 834                  32 * sizeof (CORE_ADDR));
 835   obstack_begin (&dont_print_vb_obstack,
 836                  32 * sizeof (struct type *));
 837 }