gdb/cp-valprint.c

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