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                                     NULL);
 347                       cp_print_static_field (TYPE_FIELD_TYPE (type, i), v,
 348                                              stream, format, recurse + 1,
 349                                              pretty);
 350                     }
 351                 }
 352               else
 353                 {
 354                    val_print (TYPE_FIELD_TYPE (type, i),
 355                               valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
 356                               address + TYPE_FIELD_BITPOS (type, i) / 8,
 357                               stream, format, 0, recurse + 1, pretty);
 358                 }
 359             }
 360           annotate_field_end ();
 361         }
 362
 363       if (dont_print_statmem == 0)
 364         {
 365           /* Free the space used to deal with the printing
 366              of the members from top level.  */
 367           obstack_free (&dont_print_statmem_obstack, last_dont_print);
 368           dont_print_statmem_obstack = tmp_obstack;
 369         }
 370
 371       if (pretty)
 372         {
 373           fprintf_filtered (stream, "\n");
 374           print_spaces_filtered (2 * recurse, stream);
 375         }
 376     }
 377   fprintf_filtered (stream, "}");
 378 }
 379
 380 /* Special val_print routine to avoid printing multiple copies of virtual
 381    baseclasses.  */
 382
 383 static void
 384 cp_print_value (type, valaddr, address, stream, format, recurse, pretty,
 385                 dont_print_vb)
 386      struct type *type;
 387      char *valaddr;
 388      CORE_ADDR address;
 389      GDB_FILE *stream;
 390      int format;
 391      int recurse;
 392      enum val_prettyprint pretty;
 393      struct type **dont_print_vb;
 394 {
 395   struct obstack tmp_obstack;
 396   struct type **last_dont_print
 397     = (struct type **)obstack_next_free (&dont_print_vb_obstack);
 398   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 399
 400   if (dont_print_vb == 0)
 401     {
 402       /* If we're at top level, carve out a completely fresh
 403          chunk of the obstack and use that until this particular
 404          invocation returns.  */
 405       tmp_obstack = dont_print_vb_obstack;
 406       /* Bump up the high-water mark.  Now alpha is omega.  */
 407       obstack_finish (&dont_print_vb_obstack);
 408     }
 409
 410   for (i = 0; i < n_baseclasses; i++)
 411     {
 412       int boffset;
 413       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 414       char *basename = TYPE_NAME (baseclass);
 415       char *base_valaddr;
 416
 417       if (BASETYPE_VIA_VIRTUAL (type, i))
 418         {
 419           struct type **first_dont_print
 420             = (struct type **)obstack_base (&dont_print_vb_obstack);
 421
 422           int j = (struct type **)obstack_next_free (&dont_print_vb_obstack)
 423             - first_dont_print;
 424
 425           while (--j >= 0)
 426             if (baseclass == first_dont_print[j])
 427               goto flush_it;
 428
 429           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 430         }
 431
 432       boffset = baseclass_offset (type, i , valaddr, address);
 433
 434       if (pretty)
 435         {
 436           fprintf_filtered (stream, "\n");
 437           print_spaces_filtered (2 * recurse, stream);
 438         }
 439       fputs_filtered ("<", stream);
 440       /* Not sure what the best notation is in the case where there is no
 441          baseclass name.  */
 442       fputs_filtered (basename ? basename : "", stream);
 443       fputs_filtered ("> = ", stream);
 444
 445       /* The virtual base class pointer might have been clobbered by the
 446          user program. Make sure that it still points to a valid memory
 447          location.  */
 448
 449       if (boffset != -1 && (boffset < 0 || boffset >= TYPE_LENGTH (type)))
 450         {
 451           base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
 452           if (target_read_memory (address + boffset, base_valaddr,
 453                                   TYPE_LENGTH (baseclass)) != 0)
 454             boffset = -1;
 455         }
 456       else
 457         base_valaddr = valaddr + boffset;
 458
 459       if (boffset == -1)
 460         fprintf_filtered (stream, "<invalid address>");
 461       else
 462         cp_print_value_fields (baseclass, base_valaddr, address + boffset,
 463                                stream, format, recurse, pretty,
 464                                (struct type **) obstack_base (&dont_print_vb_obstack),
 465                                0);
 466       fputs_filtered (", ", stream);
 467
 468     flush_it:
 469       ;
 470     }
 471
 472   if (dont_print_vb == 0)
 473     {
 474       /* Free the space used to deal with the printing
 475          of this type from top level.  */
 476       obstack_free (&dont_print_vb_obstack, last_dont_print);
 477       /* Reset watermark so that we can continue protecting
 478          ourselves from whatever we were protecting ourselves.  */
 479       dont_print_vb_obstack = tmp_obstack;
 480     }
 481 }
 482
 483 /* Print value of a static member.
 484    To avoid infinite recursion when printing a class that contains
 485    a static instance of the class, we keep the addresses of all printed
 486    static member classes in an obstack and refuse to print them more
 487    than once.
 488
 489    VAL contains the value to print, TYPE, STREAM, RECURSE, and PRETTY
 490    have the same meanings as in c_val_print.  */
 491
 492 static void
 493 cp_print_static_field (type, val, stream, format, recurse, pretty)
 494      struct type *type;
 495      value_ptr val;
 496      GDB_FILE *stream;
 497      int format;
 498      int recurse;
 499      enum val_prettyprint pretty;
 500 {
 501   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 502     {
 503       CORE_ADDR *first_dont_print;
 504       int i;
 505
 506       first_dont_print
 507         = (CORE_ADDR *)obstack_base (&dont_print_statmem_obstack);
 508       i = (CORE_ADDR *)obstack_next_free (&dont_print_statmem_obstack)
 509         - first_dont_print;
 510
 511       while (--i >= 0)
 512         {
 513           if (VALUE_ADDRESS (val) == first_dont_print[i])
 514             {
 515               fputs_filtered ("<same as static member of an already seen type>",
 516                               stream);
 517               return;
 518             }
 519         }
 520
 521       obstack_grow (&dont_print_statmem_obstack, (char *) &VALUE_ADDRESS (val),
 522                     sizeof (CORE_ADDR));
 523
 524       CHECK_TYPEDEF (type);
 525       cp_print_value_fields (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
 526                              stream, format, recurse, pretty, NULL, 1);
 527       return;
 528     }
 529   val_print (type, VALUE_CONTENTS (val), VALUE_ADDRESS (val),
 530              stream, format, 0, recurse, pretty);
 531 }
 532
 533 void
 534 cp_print_class_member (valaddr, domain, stream, prefix)
 535      char *valaddr;
 536      struct type *domain;
 537      GDB_FILE *stream;
 538      char *prefix;
 539 {
 540
 541   /* VAL is a byte offset into the structure type DOMAIN.
 542      Find the name of the field for that offset and
 543      print it.  */
 544   int extra = 0;
 545   int bits = 0;
 546   register unsigned int i;
 547   unsigned len = TYPE_NFIELDS (domain);
 548   /* @@ Make VAL into bit offset */
 549   LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
 550   for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
 551     {
 552       int bitpos = TYPE_FIELD_BITPOS (domain, i);
 553       QUIT;
 554       if (val == bitpos)
 555         break;
 556       if (val < bitpos && i != 0)
 557         {
 558           /* Somehow pointing into a field.  */
 559           i -= 1;
 560           extra = (val - TYPE_FIELD_BITPOS (domain, i));
 561           if (extra & 0x7)
 562             bits = 1;
 563           else
 564             extra >>= 3;
 565           break;
 566         }
 567     }
 568   if (i < len)
 569     {
 570       char *name;
 571       fprintf_filtered (stream, prefix);
 572       name = type_name_no_tag (domain);
 573       if (name)
 574         fputs_filtered (name, stream);
 575       else
 576         c_type_print_base (domain, stream, 0, 0);
 577       fprintf_filtered (stream, "::");
 578       fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
 579       if (extra)
 580         fprintf_filtered (stream, " + %d bytes", extra);
 581       if (bits)
 582         fprintf_filtered (stream, " (offset in bits)");
 583     }
 584   else
 585     fprintf_filtered (stream, "%d", val >> 3);
 586 }
 587
 588 void
 589 _initialize_cp_valprint ()
 590 {
 591   add_show_from_set
 592     (add_set_cmd ("static-members", class_support, var_boolean,
 593                   (char *)&static_field_print,
 594                   "Set printing of C++ static members.",
 595                   &setprintlist),
 596      &showprintlist);
 597   /* Turn on printing of static fields.  */
 598   static_field_print = 1;
 599
 600   add_show_from_set
 601     (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
 602                   "Set printing of C++ virtual function tables.",
 603                   &setprintlist),
 604      &showprintlist);
 605
 606   add_show_from_set
 607     (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
 608           "Set printing of object's derived type based on vtable info.",
 609                   &setprintlist),
 610      &showprintlist);
 611
 612   /* Give people the defaults which they are used to.  */
 613   objectprint = 0;
 614   vtblprint = 0;
 615   obstack_begin (&dont_print_vb_obstack, 32 * sizeof (struct type *));
 616   obstack_specify_allocation (&dont_print_statmem_obstack,
 617                               32 * sizeof (CORE_ADDR), sizeof (CORE_ADDR),
 618                               xmalloc, free);
 619 }