gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1994, 1995, 1996
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "obstack.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "demangle.h"
  30 #include "annotate.h"
  31 #include "gdb_string.h"
  32 #include "c-lang.h"
  33 #include "target.h"
  34
  35 int vtblprint;                  /* Controls printing of vtbl's */
  36 int objectprint;                /* Controls looking up an object's derived type
  37                                    using what we find in its vtables.  */
  38 static int static_field_print;  /* Controls printing of static fields. */
  39
  40 static struct obstack dont_print_vb_obstack;
  41 static struct obstack dont_print_statmem_obstack;
  42
  43 static void
  44 cp_print_static_field PARAMS ((struct type *, value_ptr, GDB_FILE *, int, int,
  45                                enum val_prettyprint));
  46
  47 static void
  48 cp_print_value PARAMS ((struct type *, char *, CORE_ADDR, GDB_FILE *,
  49                         int, int, enum val_prettyprint, struct type **));
  50
  51 void
  52 cp_print_class_method (valaddr, type, stream)
  53      char *valaddr;
  54      struct type *type;
  55      GDB_FILE *stream;
  56 {
  57   struct type *domain;
  58   struct fn_field *f = NULL;
  59   int j = 0;
  60   int len2;
  61   int offset;
  62   char *kind = "";
  63   CORE_ADDR addr;
  64   struct symbol *sym;
  65   unsigned len;
  66   unsigned int i;
  67   struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
  68
  69   domain = TYPE_DOMAIN_TYPE (target_type);
  70   if (domain == (struct type *)NULL)
  71     {
  72       fprintf_filtered (stream, "<unknown>");
  73       return;
  74     }
  75   addr = unpack_pointer (lookup_pointer_type (builtin_type_void), valaddr);
  76   if (METHOD_PTR_IS_VIRTUAL (addr))
  77     {
  78       offset = METHOD_PTR_TO_VOFFSET (addr);
  79       len = TYPE_NFN_FIELDS (domain);
  80       for (i = 0; i < len; i++)
  81         {
  82           f = TYPE_FN_FIELDLIST1 (domain, i);
  83           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
  84
  85           for (j = 0; j < len2; j++)
  86             {
  87               QUIT;
  88               if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
  89                 {
  90                   if (TYPE_FN_FIELD_STUB (f, j))
  91                     check_stub_method (domain, i, j);
  92                   kind = "virtual ";
  93                   goto common;
  94                 }
  95             }
  96         }
  97     }
  98   else
  99     {
 100       sym = find_pc_function (addr);
 101       if (sym == 0)
 102         {
 103           error ("invalid pointer to member function");
 104         }
 105       len = TYPE_NFN_FIELDS (domain);
 106       for (i = 0; i < len; i++)
 107         {
 108           f = TYPE_FN_FIELDLIST1 (domain, i);
 109           len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
 110
 111           for (j = 0; j < len2; j++)
 112             {
 113               QUIT;
 114               if (TYPE_FN_FIELD_STUB (f, j))
 115                 check_stub_method (domain, i, j);
 116               if (STREQ (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
 117                 {
 118                   goto common;
 119                 }
 120             }
 121         }
 122     }
 123   common:
 124   if (i < len)
 125     {
 126       char *demangled_name;
 127
 128       fprintf_filtered (stream, "&");
 129       fprintf_filtered (stream, kind);
 130       demangled_name = cplus_demangle (TYPE_FN_FIELD_PHYSNAME (f, j),
 131                                        DMGL_ANSI | DMGL_PARAMS);
 132       if (demangled_name == NULL)
 133         fprintf_filtered (stream, "<badly mangled name %s>",
 134                           TYPE_FN_FIELD_PHYSNAME (f, j));
 135       else
 136         {
 137           fputs_filtered (demangled_name, stream);
 138           free (demangled_name);
 139         }
 140     }
 141   else
 142     {
 143       fprintf_filtered (stream, "(");
 144       type_print (type, "", stream, -1);
 145       fprintf_filtered (stream, ") %d", (int) addr >> 3);
 146     }
 147 }
 148
 149 /* This was what it was for gcc 2.4.5 and earlier.  */
 150 static const char vtbl_ptr_name_old[] =
 151   { CPLUS_MARKER,'v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
 152 /* It was changed to this after 2.4.5.  */
 153 const char vtbl_ptr_name[] =
 154   { '_','_','v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
 155
 156 /* Return truth value for assertion that TYPE is of the type
 157    "pointer to virtual function".  */
 158
 159 int
 160 cp_is_vtbl_ptr_type(type)
 161      struct type *type;
 162 {
 163   char *typename = type_name_no_tag (type);
 164
 165   return (typename != NULL
 166           && (STREQ (typename, vtbl_ptr_name)
 167               || STREQ (typename, vtbl_ptr_name_old)));
 168 }
 169
 170 /* Return truth value for the assertion that TYPE is of the type
 171    "pointer to virtual function table".  */
 172
 173 int
 174 cp_is_vtbl_member(type)
 175      struct type *type;
 176 {
 177   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 178     {
 179       type = TYPE_TARGET_TYPE (type);
 180       if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 181         {
 182           type = TYPE_TARGET_TYPE (type);
 183           if (TYPE_CODE (type) == TYPE_CODE_STRUCT /* if not using thunks */
 184               || TYPE_CODE (type) == TYPE_CODE_PTR) /* if using thunks */
 185             {
 186               /* Virtual functions tables are full of pointers
 187                  to virtual functions. */
 188               return cp_is_vtbl_ptr_type (type);
 189             }
 190         }
 191     }
 192   return 0;
 193 }
 194
 195 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 196    print out a structure's fields: cp_print_value_fields and cp_print_value.
 197
 198    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and PRETTY have the
 199    same meanings as in cp_print_value and c_val_print.
 200
 201    DONT_PRINT is an array of baseclass types that we
 202    should not print, or zero if called from top level.  */
 203
 204 void
 205 cp_print_value_fields (type, valaddr, address, stream, format, recurse, pretty,
 206                        dont_print_vb, dont_print_statmem)
 207      struct type *type;
 208      char *valaddr;
 209      CORE_ADDR address;
 210      GDB_FILE *stream;
 211      int format;
 212      int recurse;
 213      enum val_prettyprint pretty;
 214      struct type **dont_print_vb;
 215      int dont_print_statmem;
 216 {
 217   int i, len, n_baseclasses;
 218   struct obstack tmp_obstack;
 219   char *last_dont_print = obstack_next_free (&dont_print_statmem_obstack);
 220
 221   CHECK_TYPEDEF (type);
 222
 223   fprintf_filtered (stream, "{");
 224   len = TYPE_NFIELDS (type);
 225   n_baseclasses = TYPE_N_BASECLASSES (type);
 226
 227   /* Print out baseclasses such that we don't print
 228      duplicates of virtual baseclasses.  */
 229   if (n_baseclasses > 0)
 230     cp_print_value (type, valaddr, address, stream,
 231                     format, recurse+1, pretty, dont_print_vb);
 232
 233   if (!len && n_baseclasses == 1)
 234     fprintf_filtered (stream, "<No data fields>");
 235   else
 236     {
 237       extern int inspect_it;
 238       int fields_seen = 0;
 239
 240       if (dont_print_statmem == 0)
 241         {
 242           /* If we're at top level, carve out a completely fresh
 243              chunk of the obstack and use that until this particular
 244              invocation returns.  */
 245           tmp_obstack = dont_print_statmem_obstack;
 246           obstack_finish (&dont_print_statmem_obstack);
 247         }
 248
 249       for (i = n_baseclasses; i < len; i++)
 250         {
 251           /* If requested, skip printing of static fields.  */
 252           if (!static_field_print && TYPE_FIELD_STATIC (type, i))
 253             continue;
 254           if (fields_seen)
 255             fprintf_filtered (stream, ", ");
 256           else if (n_baseclasses > 0)
 257             {
 258               if (pretty)
 259                 {
 260                   fprintf_filtered (stream, "\n");
 261                   print_spaces_filtered (2 + 2 * recurse, stream);
 262                   fputs_filtered ("members of ", stream);
 263                   fputs_filtered (type_name_no_tag (type), stream);
 264                   fputs_filtered (": ", stream);
 265                 }
 266             }
 267           fields_seen = 1;
 268
 269           if (pretty)
 270             {
 271               fprintf_filtered (stream, "\n");
 272               print_spaces_filtered (2 + 2 * recurse, stream);
 273             }
 274           else
 275             {
 276               wrap_here (n_spaces (2 + 2 * recurse));
 277             }
 278           if (inspect_it)
 279             {
 280               if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 281                 fputs_filtered ("\"( ptr \"", stream);
 282               else
 283                 fputs_filtered ("\"( nodef \"", stream);
 284               if (TYPE_FIELD_STATIC (type, i))
 285                 fputs_filtered ("static ", stream);
 286               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 287                                        language_cplus,
 288                                        DMGL_PARAMS | DMGL_ANSI);
 289               fputs_filtered ("\" \"", stream);
 290               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 291                                        language_cplus,
 292                                        DMGL_PARAMS | DMGL_ANSI);
 293               fputs_filtered ("\") \"", stream);
 294             }
 295           else
 296             {
 297               annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 298
 299               if (TYPE_FIELD_STATIC (type, i))
 300                 fputs_filtered ("static ", stream);
 301               fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 302                                        language_cplus,
 303                                        DMGL_PARAMS | DMGL_ANSI);
 304               annotate_field_name_end ();
 305               fputs_filtered (" = ", stream);
 306               annotate_field_value ();
 307             }
 308
 309           if (!TYPE_FIELD_STATIC (type, i) && TYPE_FIELD_PACKED (type, i))
 310             {
 311               value_ptr v;
 312
 313               /* Bitfields require special handling, especially due to byte
 314                  order problems.  */
 315               if (TYPE_FIELD_IGNORE (type, i))
 316                 {
 317                    fputs_filtered ("<optimized out or zero length>", stream);
 318                 }
 319               else
 320                 {
 321                    v = value_from_longest (TYPE_FIELD_TYPE (type, i),
 322                                    unpack_field_as_long (type, valaddr, i));
 323
 324                    val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0,
 325                               stream, format, 0, recurse + 1, pretty);
 326                 }
 327             }
 328           else
 329             {
 330               if (TYPE_FIELD_IGNORE (type, i))
 331                 {
 332                    fputs_filtered ("<optimized out or zero length>", stream);
 333                 }
 334               else if (TYPE_FIELD_STATIC (type, i))
 335                 {
 336                   value_ptr v;
 337                   char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, i);
 338                   struct symbol *sym =
 339                       lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
 340                   if (sym == NULL)
 341                     fputs_filtered ("<optimized out>", stream);
 342                   else
 343                     {
 344                       v = value_at (TYPE_FIELD_TYPE (type, i),
 345                                     SYMBOL_VALUE_ADDRESS (sym));
 346                       cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
 347                                              stream, format, recurse + 1,
 348                                              pretty);
 349                     }
 350                 }
 351               else
 352                 {
 353                    val_print (TYPE_FIELD_TYPE (type, i),
 354                               valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
 355                               address + TYPE_FIELD_BITPOS (type, i) / 8,
 356                               stream, format, 0, recurse + 1, pretty);
 357                 }
 358             }
 359           annotate_field_end ();
 360         }
 361
 362       if (dont_print_statmem == 0)
 363         {
 364           /* Free the space used to deal with the printing
 365              of the members from top level.  */
 366           obstack_free (&dont_print_statmem_obstack, last_dont_print);
 367           dont_print_statmem_obstack = tmp_obstack;
 368         }
 369
 370       if (pretty)
 371         {
 372           fprintf_filtered (stream, "\n");
 373           print_spaces_filtered (2 * recurse, stream);
 374         }
 375     }
 376   fprintf_filtered (stream, "}");
 377 }
 378
 379 /* Special val_print routine to avoid printing multiple copies of virtual
 380    baseclasses.  */
 381
 382 static void
 383 cp_print_value (type, valaddr, address, stream, format, recurse, pretty,
 384                 dont_print_vb)
 385      struct type *type;
 386      char *valaddr;
 387      CORE_ADDR address;
 388      GDB_FILE *stream;
 389      int format;
 390      int recurse;
 391      enum val_prettyprint pretty;
 392      struct type **dont_print_vb;
 393 {
 394   struct obstack tmp_obstack;
 395   struct type **last_dont_print
 396     = (struct type **)obstack_next_free (&dont_print_vb_obstack);
 397   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 398
 399   if (dont_print_vb == 0)
 400     {
 401       /* If we're at top level, carve out a completely fresh
 402          chunk of the obstack and use that until this particular
 403          invocation returns.  */
 404       tmp_obstack = dont_print_vb_obstack;
 405       /* Bump up the high-water mark.  Now alpha is omega.  */
 406       obstack_finish (&dont_print_vb_obstack);
 407     }
 408
 409   for (i = 0; i < n_baseclasses; i++)
 410     {
 411       int boffset;
 412       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 413       char *basename = TYPE_NAME (baseclass);
 414       char *base_valaddr;
 415
 416       if (BASETYPE_VIA_VIRTUAL (type, i))
 417         {
 418           struct type **first_dont_print
 419             = (struct type **)obstack_base (&dont_print_vb_obstack);
 420
 421           int j = (struct type **)obstack_next_free (&dont_print_vb_obstack)
 422             - first_dont_print;
 423
 424           while (--j >= 0)
 425             if (baseclass == first_dont_print[j])
 426               goto flush_it;
 427
 428           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 429         }
 430
 431       boffset = baseclass_offset (type, i , valaddr, address);
 432
 433       if (pretty)
 434         {
 435           fprintf_filtered (stream, "\n");
 436           print_spaces_filtered (2 * recurse, stream);
 437         }
 438       fputs_filtered ("<", stream);
 439       /* Not sure what the best notation is in the case where there is no
 440          baseclass name.  */
 441       fputs_filtered (basename ? basename : "", stream);
 442       fputs_filtered ("> = ", stream);
 443
 444       /* The virtual base class pointer might have been clobbered by the
 445          user program. Make sure that it still points to a valid memory
 446          location.  */
 447
 448       if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type)))
 449         {
 450           base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
 451           if (target_read_memory (address + boffset, base_valaddr,
 452                                   TYPE_LENGTH (baseclass)) != 0)
 453             boffset = -1;
 454         }
 455       else
 456         base_valaddr = valaddr + boffset;
 457
 458       if (boffset == -1)
 459         fprintf_filtered (stream, "<invalid address>");
 460       else
 461         cp_print_value_fields (baseclass, base_valaddr, address + boffset,
 462                                stream, format, recurse, pretty,
 463                                (struct type **) obstack_base (&dont_print_vb_obstack),
 464                                0);
 465       fputs_filtered (", ", stream);
 466
 467     flush_it:
 468       ;
 469     }
 470
 471   if (dont_print_vb == 0)
 472     {
 473       /* Free the space used to deal with the printing
 474          of this type from top level.  */
 475       obstack_free (&dont_print_vb_obstack, last_dont_print);
 476       /* Reset watermark so that we can continue protecting
 477          ourselves from whatever we were protecting ourselves.  */
 478       dont_print_vb_obstack = tmp_obstack;
 479     }
 480 }
 481
 482 /* Print value of a static member.
 483    To avoid infinite recursion when printing a class that contains
 484    a static instance of the class, we keep the addresses of all printed
 485    static member classes in an obstack and refuse to print them more
 486    than once.
 487
 488    VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
 489    have the same meanings as in c_val_print.  */
 490
 491 static void
 492 cp_print_static_field (type, val, stream, format, recurse, pretty)
 493      struct type *type;
 494      value_ptr val;
 495      GDB_FILE *stream;
 496      int format;
 497      int recurse;
 498      enum val_prettyprint pretty;
 499 {
 500   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 501     {
 502       CORE_ADDR *first_dont_print;
 503       int i;
 504
 505       first_dont_print
 506         = (CORE_ADDR *)obstack_base (&dont_print_statmem_obstack);
 507       i = (CORE_ADDR *)obstack_next_free (&dont_print_statmem_obstack)
 508         - first_dont_print;
 509
 510       while (--i >= 0)
 511         {
 512           if (VALUE_ADDRESS (val) == first_dont_print[i])
 513             {
 514               fputs_filtered ("<same as static member of an already seen type>",
 515                               stream);
 516               return;
 517             }
 518         }
 519
 520       obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
 521                     sizeof (CORE_ADDR));
 522
 523       CHECK_TYPEDEF (type);
 524       cp_print_value_fields (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
 525                              stream, format, recurse, pretty, NULL, 1);
 526       return;
 527     }
 528   val_print (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
 529              stream, format, 0, recurse, pretty);
 530 }
 531
 532 void
 533 cp_print_class_member (valaddr, domain, stream, prefix)
 534      char *valaddr;
 535      struct type *domain;
 536      GDB_FILE *stream;
 537      char *prefix;
 538 {
 539
 540   /* VAL is a byte offset into the structure type DOMAIN.
 541      Find the name of the field for that offset and
 542      print it.  */
 543   int extra = 0;
 544   int bits = 0;
 545   register unsigned int i;
 546   unsigned len = TYPE_NFIELDS (domain);
 547   /* @@ Make VAL into bit offset */
 548   LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
 549   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 550     {
 551       int bitpos = TYPE_FIELD_BITPOS (domain, i);
 552       QUIT;
 553       if (val == bitpos)
 554         break;
 555       if (val < bitpos && i != 0)
 556         {
 557           /* Somehow pointing into a field.  */
 558           i -= 1;
 559           extra = (val - TYPE_FIELD_BITPOS (domain, i));
 560           if (extra & 0x7)
 561             bits = 1;
 562           else
 563             extra >>= 3;
 564           break;
 565         }
 566     }
 567   if (i < len)
 568     {
 569       char *name;
 570       fprintf_filtered (stream, prefix);
 571       name = type_name_no_tag (domain);
 572       if (name)
 573         fputs_filtered (name, stream);
 574       else
 575         c_type_print_base (domain, stream, 0, 0);
 576       fprintf_filtered (stream, "::");
 577       fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
 578       if (extra)
 579         fprintf_filtered (stream, " + %d bytes", extra);
 580       if (bits)
 581         fprintf_filtered (stream, " (offset in bits)");
 582     }
 583   else
 584     fprintf_filtered (stream, "%d", val >> 3);
 585 }
 586
 587 void
 588 _initialize_cp_valprint ()
 589 {
 590   add_show_from_set
 591     (add_set_cmd ("static-members", class_support, var_boolean,
 592                   (char *)&static_field_print,
 593                   "Set printing of C++ static members.",
 594                   &setprintlist),
 595      &showprintlist);
 596   /* Turn on printing of static fields.  */
 597   static_field_print = 1;
 598
 599   add_show_from_set
 600     (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
 601                   "Set printing of C++ virtual function tables.",
 602                   &setprintlist),
 603      &showprintlist);
 604
 605   add_show_from_set
 606     (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
 607           "Set printing of object's derived type based on vtable info.",
 608                   &setprintlist),
 609      &showprintlist);
 610
 611   /* Give people the defaults which they are used to.  */
 612   objectprint = 0;
 613   vtblprint = 0;
 614   obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
 615   obstack_specify_allocation (&dont_print_statmem_obstack,
 616                               32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),
 617                               xmalloc, free);
 618 }