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