gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 2000, 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdb_obstack.h"
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "expression.h"
  28 #include "value.h"
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "demangle.h"
  32 #include "annotate.h"
  33 #include "gdb_string.h"
  34 #include "c-lang.h"
  35 #include "target.h"
  36 #include "cp-abi.h"
  37 #include "valprint.h"
  38 #include "cp-support.h"
  39 #include "language.h"
  40
  41 int vtblprint;                  /* Controls printing of vtbl's */
  42 int objectprint;                /* Controls looking up an object's derived type
  43                                    using what we find in its vtables.  */
  44 int static_field_print;         /* Controls printing of static fields. */
  45
  46 static struct obstack dont_print_vb_obstack;
  47 static struct obstack dont_print_statmem_obstack;
  48
  49 extern void _initialize_cp_valprint (void);
  50
  51 static void cp_print_static_field (struct type *, struct value *,
  52                                    struct ui_file *, int, int,
  53                                    enum val_prettyprint);
  54
  55 static void cp_print_value (struct type *, struct type *, const bfd_byte *,
  56                             int, CORE_ADDR, struct ui_file *, int, int,
  57                             enum val_prettyprint, struct type **);
  58
  59 static void cp_print_hpacc_virtual_table_entries (struct type *, int *,
  60                                                   struct value *,
  61                                                   struct ui_file *, int,
  62                                                   int,
  63                                                   enum val_prettyprint);
  64
  65
  66 void
  67 cp_print_class_method (const bfd_byte *valaddr,
  68                        struct type *type,
  69                        struct ui_file *stream)
  70 {
  71   struct type *domain;
  72   struct fn_field *f = NULL;
  73   int j = 0;
  74   int len2;
  75   int offset;
  76   char *kind = "";
  77   CORE_ADDR addr;
  78   struct symbol *sym;
  79   unsigned len;
  80   unsigned int i;
  81   struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
  82
  83   domain = TYPE_DOMAIN_TYPE (target_type);
  84   if (domain == (struct type *) NULL)
  85     {
  86       fprintf_filtered (stream, "<unknown>");
  87       return;
  88     }
  89   addr = unpack_pointer (type, valaddr);
  90   if (METHOD_PTR_IS_VIRTUAL (addr))
  91     {
  92       offset = METHOD_PTR_TO_VOFFSET (addr);
  93       len = TYPE_NFN_FIELDS (domain);
  94       for (i = 0; i < len; i++)
  95         {
  96           f = TYPE_FN_FIELDLIST1 (domain, i);
  97           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
  98
  99           check_stub_method_group (domain, i);
 100           for (j = 0; j < len2; j++)
 101             {
 102               if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
 103                 {
 104                   kind = "virtual ";
 105                   goto common;
 106                 }
 107             }
 108         }
 109     }
 110   else
 111     {
 112       sym = find_pc_function (addr);
 113       if (sym == 0)
 114         {
 115           /* 1997-08-01 Currently unsupported with HP aCC */
 116           if (deprecated_hp_som_som_object_present)
 117             {
 118               fputs_filtered ("?? <not supported with HP aCC>", stream);
 119               return;
 120             }
 121           error (_("invalid pointer to member function"));
 122         }
 123       len = TYPE_NFN_FIELDS (domain);
 124       for (i = 0; i < len; i++)
 125         {
 126           f = TYPE_FN_FIELDLIST1 (domain, i);
 127           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
 128
 129           check_stub_method_group (domain, i);
 130           for (j = 0; j < len2; j++)
 131             {
 132               if (strcmp (DEPRECATED_SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j))
 133                   == 0)
 134                 goto common;
 135             }
 136         }
 137     }
 138  common:
 139   if (i < len)
 140     {
 141       char *demangled_name;
 142
 143       fprintf_filtered (stream, "&");
 144       fputs_filtered (kind, stream);
 145       demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
 146                                        DMGL_ANSI | DMGL_PARAMS);
 147       if (demangled_name == NULL)
 148         fprintf_filtered (stream, "<badly mangled name %s>",
 149                           TYPE_FN_FIELD_PHYSNAME (f, j));
 150       else
 151         {
 152           fputs_filtered (demangled_name, stream);
 153           xfree (demangled_name);
 154         }
 155     }
 156   else
 157     {
 158       fprintf_filtered (stream, "(");
 159       type_print (type, "", stream, -1);
 160       fprintf_filtered (stream, ") %d", (int) addr >> 3);
 161     }
 162 }
 163
 164 /* GCC versions after 2.4.5 use this.  */
 165 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
 166
 167 /* HP aCC uses different names.  */
 168 const char hpacc_vtbl_ptr_name[] = "__vfp";
 169 const char hpacc_vtbl_ptr_type_name[] = "__vftyp";
 170
 171 /* Return truth value for assertion that TYPE is of the type
 172    "pointer to virtual function".  */
 173
 174 int
 175 cp_is_vtbl_ptr_type (struct type *type)
 176 {
 177   char *typename = type_name_no_tag (type);
 178
 179   return (typename != NULL && !strcmp (typename, vtbl_ptr_name));
 180 }
 181
 182 /* Return truth value for the assertion that TYPE is of the type
 183    "pointer to virtual function table".  */
 184
 185 int
 186 cp_is_vtbl_member (struct type *type)
 187 {
 188   /* With older versions of g++, the vtbl field pointed to an array
 189      of structures.  Nowadays it points directly to the structure. */
 190   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 191     {
 192       type = TYPE_TARGET_TYPE (type);
 193       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 194         {
 195           type = TYPE_TARGET_TYPE (type);
 196           if (TYPE_CODE (type) == TYPE_CODE_STRUCT      /* if not using thunks */
 197               || TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
 198             {
 199               /* Virtual functions tables are full of pointers
 200                  to virtual functions. */
 201               return cp_is_vtbl_ptr_type (type);
 202             }
 203         }
 204       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)  /* if not using thunks */
 205         {
 206           return cp_is_vtbl_ptr_type (type);
 207         }
 208       else if (TYPE_CODE (type) == TYPE_CODE_PTR)     /* if using thunks */
 209         {
 210           /* The type name of the thunk pointer is NULL when using dwarf2.
 211              We could test for a pointer to a function, but there is
 212              no type info for the virtual table either, so it wont help.  */
 213           return cp_is_vtbl_ptr_type (type);
 214         }
 215     }
 216   return 0;
 217 }
 218
 219 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 220    print out a structure's fields: cp_print_value_fields and cp_print_value.
 221
 222    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
 223    same meanings as in cp_print_value and c_val_print.
 224
 225    2nd argument REAL_TYPE is used to carry over the type of the derived
 226    class across the recursion to base classes.
 227
 228    DONT_PRINT is an array of baseclass types that we
 229    should not print, or zero if called from top level.  */
 230
 231 void
 232 cp_print_value_fields (struct type *type, struct type *real_type,
 233                        const bfd_byte *valaddr, int offset, CORE_ADDR address,
 234                        struct ui_file *stream, int format, int recurse,
 235                        enum val_prettyprint pretty,
 236                        struct type **dont_print_vb,int dont_print_statmem)
 237 {
 238   int i, len, n_baseclasses;
 239   struct obstack tmp_obstack;
 240   char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
 241   int fields_seen = 0;
 242
 243   CHECK_TYPEDEF (type);
 244
 245   fprintf_filtered (stream, "{");
 246   len = TYPE_NFIELDS (type);
 247   n_baseclasses = TYPE_N_BASECLASSES (type);
 248
 249   /* First, print out baseclasses such that we don't print
 250      duplicates of virtual baseclasses.  */
 251
 252   if (n_baseclasses > 0)
 253     cp_print_value (type, real_type, valaddr, offset, address, stream,
 254                     format, recurse + 1, pretty, dont_print_vb);
 255
 256   /* Second, print out data fields */
 257
 258   /* If there are no data fields, or if the only field is the
 259    * vtbl pointer, skip this part */
 260   if ((len == n_baseclasses)
 261       || ((len - n_baseclasses == 1)
 262           && TYPE_HAS_VTABLE (type)
 263           && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
 264                       hpacc_vtbl_ptr_name, 5) == 0)
 265       || !len)
 266     fprintf_filtered (stream, "<No data fields>");
 267   else
 268     {
 269       if (dont_print_statmem == 0)
 270         {
 271           /* If we're at top level, carve out a completely fresh
 272              chunk of the obstack and use that until this particular
 273              invocation returns.  */
 274           tmp_obstack = dont_print_statmem_obstack;
 275           obstack_finish (&dont_print_statmem_obstack);
 276         }
 277
 278       for (i = n_baseclasses; i < len; i++)
 279         {
 280           /* If requested, skip printing of static fields.  */
 281           if (!static_field_print && TYPE_FIELD_STATIC (type, i))
 282             continue;
 283
 284           /* If a vtable pointer appears, we'll print it out later */
 285           if (TYPE_HAS_VTABLE (type)
 286               && strncmp (TYPE_FIELD_NAME (type, i), hpacc_vtbl_ptr_name,
 287                           5) == 0)
 288             continue;
 289
 290           if (fields_seen)
 291             fprintf_filtered (stream, ", ");
 292           else if (n_baseclasses > 0)
 293             {
 294               if (pretty)
 295                 {
 296                   fprintf_filtered (stream, "\n");
 297                   print_spaces_filtered (2 + 2 * recurse, stream);
 298                   fputs_filtered ("members of ", stream);
 299                   fputs_filtered (type_name_no_tag (type), stream);
 300                   fputs_filtered (": ", stream);
 301                 }
 302             }
 303           fields_seen = 1;
 304
 305           if (pretty)
 306             {
 307               fprintf_filtered (stream, "\n");
 308               print_spaces_filtered (2 + 2 * recurse, stream);
 309             }
 310           else
 311             {
 312               wrap_here (n_spaces (2 + 2 * recurse));
 313             }
 314           if (inspect_it)
 315             {
 316               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 317                 fputs_filtered ("\"( ptr \"", stream);
 318               else
 319                 fputs_filtered ("\"( nodef \"", stream);
 320               if (TYPE_FIELD_STATIC (type, i))
 321                 fputs_filtered ("static ", stream);
 322               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 323                                        current_language->la_language,
 324                                        DMGL_PARAMS | DMGL_ANSI);
 325               fputs_filtered ("\" \"", stream);
 326               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 327                                        current_language->la_language,
 328                                        DMGL_PARAMS | DMGL_ANSI);
 329               fputs_filtered ("\") \"", stream);
 330             }
 331           else
 332             {
 333               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 334
 335               if (TYPE_FIELD_STATIC (type, i))
 336                 fputs_filtered ("static ", stream);
 337               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 338                                        current_language->la_language,
 339                                        DMGL_PARAMS | DMGL_ANSI);
 340               annotate_field_name_end ();
 341               /* do not print leading '=' in case of anonymous unions */
 342               if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 343                 fputs_filtered (" = ", stream);
 344               annotate_field_value ();
 345             }
 346
 347           if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
 348             {
 349               struct value *v;
 350
 351               /* Bitfields require special handling, especially due to byte
 352                  order problems.  */
 353               if (TYPE_FIELD_IGNORE (type, i))
 354                 {
 355                   fputs_filtered ("<optimized out or zero length>", stream);
 356                 }
 357               else
 358                 {
 359                   v = value_from_longest
 360                     (TYPE_FIELD_TYPE (type, i),
 361                      unpack_field_as_long (type, valaddr + offset, i));
 362
 363                   val_print (TYPE_FIELD_TYPE (type, i), value_contents (v),
 364                              0, 0, stream, format, 0, recurse + 1, pretty);
 365                 }
 366             }
 367           else
 368             {
 369               if (TYPE_FIELD_IGNORE (type, i))
 370                 {
 371                   fputs_filtered ("<optimized out or zero length>", stream);
 372                 }
 373               else if (TYPE_FIELD_STATIC (type, i))
 374                 {
 375                   struct value *v = value_static_field (type, i);
 376                   if (v == NULL)
 377                     fputs_filtered ("<optimized out>", stream);
 378                   else
 379                     cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
 380                                            stream, format, recurse + 1,
 381                                            pretty);
 382                 }
 383               else
 384                 {
 385                   val_print (TYPE_FIELD_TYPE (type, i),
 386                              valaddr, offset + TYPE_FIELD_BITPOS (type, i) / 8,
 387                              address + TYPE_FIELD_BITPOS (type, i) / 8,
 388                              stream, format, 0, recurse + 1, pretty);
 389                 }
 390             }
 391           annotate_field_end ();
 392         }
 393
 394       if (dont_print_statmem == 0)
 395         {
 396           /* Free the space used to deal with the printing
 397              of the members from top level.  */
 398           obstack_free (&dont_print_statmem_obstack, last_dont_print);
 399           dont_print_statmem_obstack = tmp_obstack;
 400         }
 401
 402       if (pretty)
 403         {
 404           fprintf_filtered (stream, "\n");
 405           print_spaces_filtered (2 * recurse, stream);
 406         }
 407     }                           /* if there are data fields */
 408   /* Now print out the virtual table pointer if there is one */
 409   if (TYPE_HAS_VTABLE (type)
 410       && strncmp (TYPE_FIELD_NAME (type, n_baseclasses),
 411                   hpacc_vtbl_ptr_name, 5) == 0)
 412     {
 413       struct value *v;
 414       /* First get the virtual table pointer and print it out */
 415
 416 #if 0
 417       fputs_filtered ("__vfp = ", stream);
 418 #endif
 419
 420       fputs_filtered (", Virtual table at ", stream);
 421
 422       /* pai: FIXME 32x64 problem? */
 423       /* Not sure what the best notation is in the case where there is no
 424          baseclass name.  */
 425       v = value_from_pointer (lookup_pointer_type (builtin_type_unsigned_long),
 426                               *(unsigned long *) (valaddr + offset));
 427
 428       val_print (value_type (v), value_contents (v), 0, 0,
 429                  stream, format, 0, recurse + 1, pretty);
 430       fields_seen = 1;
 431
 432       if (vtblprint)
 433         {
 434           /* Print out function pointers in vtable. */
 435
 436           /* FIXME: then-clause is for non-RRBC layout of virtual
 437            * table.  The RRBC case in the else-clause is yet to be
 438            * implemented.  The if (1) below should be changed to a
 439            * test for whether the executable we have was compiled
 440            * with a version of HP aCC that doesn't have RRBC
 441            * support. */
 442
 443           if (1)
 444             {
 445               /* no RRBC support; function pointers embedded directly
 446                  in vtable */
 447
 448               int vfuncs = count_virtual_fns (real_type);
 449
 450               fputs_filtered (" {", stream);
 451
 452               /* FIXME : doesn't work at present */
 453 #if 0
 454               fprintf_filtered (stream, "%d entr%s: ", vfuncs,
 455                                 vfuncs == 1 ? "y" : "ies");
 456 #else
 457               fputs_filtered ("not implemented", stream);
 458
 459
 460 #endif
 461
 462               /* recursive function that prints all virtual function entries */
 463 #if 0
 464               cp_print_hpacc_virtual_table_entries (real_type, &vfuncs, v,
 465                                                     stream, format, recurse,
 466                                                     pretty);
 467 #endif
 468               fputs_filtered ("}", stream);
 469             }                   /* non-RRBC case */
 470           else
 471             {
 472               /* FIXME -- see comments above */
 473               /* RRBC support present; function pointers are found
 474                * by indirection through the class segment entries. */
 475
 476
 477             }                   /* RRBC case */
 478         }                       /* if vtblprint */
 479
 480       if (pretty)
 481         {
 482           fprintf_filtered (stream, "\n");
 483           print_spaces_filtered (2 * recurse, stream);
 484         }
 485
 486     }                           /* if vtable exists */
 487
 488   fprintf_filtered (stream, "}");
 489 }
 490
 491 /* Special val_print routine to avoid printing multiple copies of virtual
 492    baseclasses.  */
 493
 494 static void
 495 cp_print_value (struct type *type, struct type *real_type,
 496                 const bfd_byte *valaddr, int offset, CORE_ADDR address,
 497                 struct ui_file *stream, int format, int recurse,
 498                 enum val_prettyprint pretty, struct type **dont_print_vb)
 499 {
 500   struct obstack tmp_obstack;
 501   struct type **last_dont_print
 502     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 503   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 504   int thisoffset;
 505   struct type *thistype;
 506
 507   if (dont_print_vb == 0)
 508     {
 509       /* If we're at top level, carve out a completely fresh
 510          chunk of the obstack and use that until this particular
 511          invocation returns.  */
 512       tmp_obstack = dont_print_vb_obstack;
 513       /* Bump up the high-water mark.  Now alpha is omega.  */
 514       obstack_finish (&dont_print_vb_obstack);
 515     }
 516
 517   for (i = 0; i < n_baseclasses; i++)
 518     {
 519       int boffset;
 520       int skip;
 521       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 522       char *basename = TYPE_NAME (baseclass);
 523       const bfd_byte *base_valaddr;
 524
 525       if (BASETYPE_VIA_VIRTUAL (type, i))
 526         {
 527           struct type **first_dont_print
 528             = (struct type **) obstack_base (&dont_print_vb_obstack);
 529
 530           int j = (struct type **) obstack_next_free (&dont_print_vb_obstack)
 531             - first_dont_print;
 532
 533           while (--j >= 0)
 534             if (baseclass == first_dont_print[j])
 535               goto flush_it;
 536
 537           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 538         }
 539
 540       thisoffset = offset;
 541       thistype = real_type;
 542       if (TYPE_HAS_VTABLE (type) && BASETYPE_VIA_VIRTUAL (type, i))
 543         {
 544           /* Assume HP/Taligent runtime convention */
 545           find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
 546                                 valaddr, offset, &boffset, &skip);
 547           if (skip >= 0)
 548             error (_("Virtual base class offset not found from vtable while"
 549                    " printing"));
 550           base_valaddr = valaddr;
 551         }
 552       else
 553         {
 554           boffset = baseclass_offset (type, i,
 555                                       valaddr + offset,
 556                                       address);
 557           skip = ((boffset == -1) || (boffset + offset) < 0) ? 1 : -1;
 558
 559           if (BASETYPE_VIA_VIRTUAL (type, i))
 560             {
 561               /* The virtual base class pointer might have been
 562                  clobbered by the user program. Make sure that it
 563                  still points to a valid memory location.  */
 564
 565               if (boffset != -1
 566                   && ((boffset + offset) < 0
 567                       || (boffset + offset) >= TYPE_LENGTH (type)))
 568                 {
 569                   /* FIXME (alloca): unsafe if baseclass is really really large. */
 570                   bfd_byte *buf = alloca (TYPE_LENGTH (baseclass));
 571                   base_valaddr = buf;
 572                   if (target_read_memory (address + boffset, buf,
 573                                           TYPE_LENGTH (baseclass)) != 0)
 574                     skip = 1;
 575                   address = address + boffset;
 576                   thisoffset = 0;
 577                   boffset = 0;
 578                   thistype = baseclass;
 579                 }
 580               else
 581                 base_valaddr = valaddr;
 582             }
 583           else
 584             base_valaddr = valaddr;
 585         }
 586
 587       /* now do the printing */
 588       if (pretty)
 589         {
 590           fprintf_filtered (stream, "\n");
 591           print_spaces_filtered (2 * recurse, stream);
 592         }
 593       fputs_filtered ("<", stream);
 594       /* Not sure what the best notation is in the case where there is no
 595          baseclass name.  */
 596       fputs_filtered (basename ? basename : "", stream);
 597       fputs_filtered ("> = ", stream);
 598
 599
 600       if (skip >= 1)
 601         fprintf_filtered (stream, "<invalid address>");
 602       else
 603         cp_print_value_fields (baseclass, thistype, base_valaddr,
 604                                thisoffset + boffset, address + boffset,
 605                                stream, format,
 606                                recurse, pretty,
 607                                ((struct type **)
 608                                 obstack_base (&dont_print_vb_obstack)),
 609                                0);
 610       fputs_filtered (", ", stream);
 611
 612     flush_it:
 613       ;
 614     }
 615
 616   if (dont_print_vb == 0)
 617     {
 618       /* Free the space used to deal with the printing
 619          of this type from top level.  */
 620       obstack_free (&dont_print_vb_obstack, last_dont_print);
 621       /* Reset watermark so that we can continue protecting
 622          ourselves from whatever we were protecting ourselves.  */
 623       dont_print_vb_obstack = tmp_obstack;
 624     }
 625 }
 626
 627 /* Print value of a static member.
 628    To avoid infinite recursion when printing a class that contains
 629    a static instance of the class, we keep the addresses of all printed
 630    static member classes in an obstack and refuse to print them more
 631    than once.
 632
 633    VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
 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 format,
 641                        int recurse,
 642                        enum val_prettyprint pretty)
 643 {
 644   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 645     {
 646       CORE_ADDR *first_dont_print;
 647       int i;
 648
 649       first_dont_print
 650         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 651       i = (CORE_ADDR *) obstack_next_free (&dont_print_statmem_obstack)
 652         - first_dont_print;
 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       obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
 666                     sizeof (CORE_ADDR));
 667
 668       CHECK_TYPEDEF (type);
 669       cp_print_value_fields (type, type, value_contents_all (val),
 670                              value_embedded_offset (val), VALUE_ADDRESS (val),
 671                              stream, format, recurse, pretty, NULL, 1);
 672       return;
 673     }
 674   val_print (type, value_contents_all (val),
 675              value_embedded_offset (val), VALUE_ADDRESS (val),
 676              stream, format, 0, recurse, pretty);
 677 }
 678
 679 void
 680 cp_print_class_member (const bfd_byte *valaddr, struct type *domain,
 681                        struct ui_file *stream, char *prefix)
 682 {
 683
 684   /* VAL is a byte offset into the structure type DOMAIN.
 685      Find the name of the field for that offset and
 686      print it.  */
 687   int extra = 0;
 688   int bits = 0;
 689   unsigned int i;
 690   unsigned len = TYPE_NFIELDS (domain);
 691
 692   /* @@ Make VAL into bit offset */
 693
 694   /* Note: HP aCC generates offsets that are the real byte offsets added
 695      to a constant bias 0x20000000 (1 << 29).  This constant bias gets
 696      shifted out in the code below -- joyous happenstance! */
 697
 698   /* Note: HP cfront uses a constant bias of 1; if we support this
 699      compiler ever, we will have to adjust the computation below */
 700
 701   LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
 702   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 703     {
 704       int bitpos = TYPE_FIELD_BITPOS (domain, i);
 705       QUIT;
 706       if (val == bitpos)
 707         break;
 708       if (val < bitpos && i != 0)
 709         {
 710           /* Somehow pointing into a field.  */
 711           i -= 1;
 712           extra = (val - TYPE_FIELD_BITPOS (domain, i));
 713           if (extra & 0x7)
 714             bits = 1;
 715           else
 716             extra >>= 3;
 717           break;
 718         }
 719     }
 720   if (i < len)
 721     {
 722       char *name;
 723       fputs_filtered (prefix, stream);
 724       name = type_name_no_tag (domain);
 725       if (name)
 726         fputs_filtered (name, stream);
 727       else
 728         c_type_print_base (domain, stream, 0, 0);
 729       fprintf_filtered (stream, "::");
 730       fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
 731       if (extra)
 732         fprintf_filtered (stream, " + %d bytes", extra);
 733       if (bits)
 734         fprintf_filtered (stream, " (offset in bits)");
 735     }
 736   else
 737     fprintf_filtered (stream, "%ld", (long) (val >> 3));
 738 }
 739
 740
 741 /* This function prints out virtual table entries for a class; it
 742  * recurses on the base classes to find all virtual functions
 743  * available in a class.
 744  *
 745  * pai/1997-05-21 Note: As the name suggests, it's currently
 746  * implemented for HP aCC runtime only. g++ objects are handled
 747  * differently and I have made no attempt to fold that logic in
 748  * here. The runtime layout is different for the two cases.  Also,
 749  * this currently has only the code for non-RRBC layouts generated by
 750  * the HP aCC compiler; RRBC code is stubbed out and will have to be
 751  * added later. */
 752
 753
 754 static void
 755 cp_print_hpacc_virtual_table_entries (struct type *type, int *vfuncs,
 756                                       struct value *v, struct ui_file *stream,
 757                                       int format, int recurse,
 758                                       enum val_prettyprint pretty)
 759 {
 760   int fn, oi;
 761
 762   /* pai: FIXME this function doesn't work. It should handle a given
 763    * virtual function only once (latest redefinition in class hierarchy)
 764    */
 765
 766   /* Recursion on other classes that can share the same vtable */
 767   struct type *pbc = primary_base_class (type);
 768   if (pbc)
 769     cp_print_hpacc_virtual_table_entries (pbc, vfuncs, v, stream, format,
 770                                           recurse, pretty);
 771
 772   /* Now deal with vfuncs declared in this class */
 773   for (fn = 0; fn < TYPE_NFN_FIELDS (type); fn++)
 774     for (oi = 0; oi < TYPE_FN_FIELDLIST_LENGTH (type, fn); oi++)
 775       if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (type, fn), oi))
 776         {
 777           char *vf_name;
 778           const char *field_physname;
 779
 780           /* virtual function offset */
 781           int vx = (TYPE_FN_FIELD_VOFFSET (TYPE_FN_FIELDLIST1 (type, fn), oi)
 782                     - 1);
 783
 784           /* Get the address of the vfunction entry */
 785           struct value *vf = value_copy (v);
 786           if (value_lazy (vf))
 787             (void) value_fetch_lazy (vf);
 788           /* adjust by offset */
 789           /* NOTE: cagney/2005-01-02: THIS IS BOGUS.  */
 790           value_contents_writeable (vf)[0] += 4 * (HP_ACC_VFUNC_START + vx);
 791           vf = value_ind (vf);  /* get the entry */
 792           /* make it a pointer */
 793           deprecated_set_value_type (vf, value_type (v));
 794
 795           /* print out the entry */
 796           val_print (value_type (vf), value_contents (vf), 0, 0,
 797                      stream, format, 0, recurse + 1, pretty);
 798           field_physname
 799             = TYPE_FN_FIELD_PHYSNAME (TYPE_FN_FIELDLIST1 (type, fn), oi);
 800           /* pai: (temp) FIXME Maybe this should be DMGL_ANSI */
 801           vf_name = cplus_demangle (field_physname, DMGL_ARM);
 802           fprintf_filtered (stream, " %s", vf_name);
 803           if (--(*vfuncs) > 0)
 804             fputs_filtered (", ", stream);
 805         }
 806 }
 807
 808
 809
 810 void
 811 _initialize_cp_valprint (void)
 812 {
 813   deprecated_add_show_from_set
 814     (add_set_cmd ("static-members", class_support, var_boolean,
 815                   (char *) &static_field_print,
 816                   "Set printing of C++ static members.",
 817                   &setprintlist),
 818      &showprintlist);
 819   /* Turn on printing of static fields.  */
 820   static_field_print = 1;
 821
 822   deprecated_add_show_from_set
 823     (add_set_cmd ("vtbl", class_support, var_boolean, (char *) &vtblprint,
 824                   "Set printing of C++ virtual function tables.",
 825                   &setprintlist),
 826      &showprintlist);
 827
 828   deprecated_add_show_from_set
 829     (add_set_cmd ("object", class_support, var_boolean, (char *) &objectprint,
 830               "Set printing of object's derived type based on vtable info.",
 831                   &setprintlist),
 832      &showprintlist);
 833
 834   /* Give people the defaults which they are used to.  */
 835   objectprint = 0;
 836   vtblprint = 0;
 837   obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
 838   obstack_specify_allocation (&dont_print_statmem_obstack,
 839                               32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),
 840                               xmalloc, xfree);
 841 }