gdb/cp-valprint.c

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