gdb/cp-valprint.c

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