gdb/cp-valprint.c

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