gdb/cp-valprint.c

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