gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "valprint.h"
  29 #include "language.h"
  30 #include "c-lang.h"
  31 #include "cp-abi.h"
  32 #include "target.h"
  33 \f
  34
  35 /* Print function pointer with inferior address ADDRESS onto stdio
  36    stream STREAM.  */
  37
  38 static void
  39 print_function_pointer_address (struct gdbarch *gdbarch,
  40                                 CORE_ADDR address,
  41                                 struct ui_file *stream,
  42                                 int addressprint)
  43 {
  44   CORE_ADDR func_addr
  45     = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
  46                                           &current_target);
  47
  48   /* If the function pointer is represented by a description, print
  49      the address of the description.  */
  50   if (addressprint && func_addr != address)
  51     {
  52       fputs_filtered ("@", stream);
  53       fputs_filtered (paddress (gdbarch, address), stream);
  54       fputs_filtered (": ", stream);
  55     }
  56   print_address_demangle (gdbarch, func_addr, stream, demangle);
  57 }
  58
  59
  60 /* A helper for c_textual_element_type.  This checks the name of the
  61    typedef.  This is bogus but it isn't apparent that the compiler
  62    provides us the help we may need.  */
  63
  64 static int
  65 textual_name (const char *name)
  66 {
  67   return (!strcmp (name, "wchar_t")
  68           || !strcmp (name, "char16_t")
  69           || !strcmp (name, "char32_t"));
  70 }
  71
  72 /* Apply a heuristic to decide whether an array of TYPE or a pointer
  73    to TYPE should be printed as a textual string.  Return non-zero if
  74    it should, or zero if it should be treated as an array of integers
  75    or pointer to integers.  FORMAT is the current format letter, or 0
  76    if none.
  77
  78    We guess that "char" is a character.  Explicitly signed and
  79    unsigned character types are also characters.  Integer data from
  80    vector types is not.  The user can override this by using the /s
  81    format letter.  */
  82
  83 int
  84 c_textual_element_type (struct type *type, char format)
  85 {
  86   struct type *true_type, *iter_type;
  87
  88   if (format != 0 && format != 's')
  89     return 0;
  90
  91   /* We also rely on this for its side effect of setting up all the
  92      typedef pointers.  */
  93   true_type = check_typedef (type);
  94
  95   /* TYPE_CODE_CHAR is always textual.  */
  96   if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
  97     return 1;
  98
  99   /* Any other character-like types must be integral.  */
 100   if (TYPE_CODE (true_type) != TYPE_CODE_INT)
 101     return 0;
 102
 103   /* We peel typedefs one by one, looking for a match.  */
 104   iter_type = type;
 105   while (iter_type)
 106     {
 107       /* Check the name of the type.  */
 108       if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
 109         return 1;
 110
 111       if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
 112         break;
 113
 114       /* Peel a single typedef.  If the typedef doesn't have a target
 115          type, we use check_typedef and hope the result is ok -- it
 116          might be for C++, where wchar_t is a built-in type.  */
 117       if (TYPE_TARGET_TYPE (iter_type))
 118         iter_type = TYPE_TARGET_TYPE (iter_type);
 119       else
 120         iter_type = check_typedef (iter_type);
 121     }
 122
 123   if (format == 's')
 124     {
 125       /* Print this as a string if we can manage it.  For now, no wide
 126          character support.  */
 127       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 128           && TYPE_LENGTH (true_type) == 1)
 129         return 1;
 130     }
 131   else
 132     {
 133       /* If a one-byte TYPE_CODE_INT is missing the not-a-character
 134          flag, then we treat it as text; otherwise, we assume it's
 135          being used as data.  */
 136       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 137           && TYPE_LENGTH (true_type) == 1
 138           && !TYPE_NOTTEXT (true_type))
 139         return 1;
 140     }
 141
 142   return 0;
 143 }
 144
 145 /* See val_print for a description of the various parameters of this
 146    function; they are identical.  The semantics of the return value is
 147    also identical to val_print.  */
 148
 149 int
 150 c_val_print (struct type *type, const gdb_byte *valaddr,
 151              int embedded_offset, CORE_ADDR address,
 152              struct ui_file *stream, int recurse,
 153              const struct value *original_value,
 154              const struct value_print_options *options)
 155 {
 156   struct gdbarch *gdbarch = get_type_arch (type);
 157   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 158   unsigned int i = 0;   /* Number of characters printed.  */
 159   unsigned len;
 160   struct type *elttype, *unresolved_elttype;
 161   struct type *unresolved_type = type;
 162   unsigned eltlen;
 163   LONGEST val;
 164   CORE_ADDR addr;
 165
 166   CHECK_TYPEDEF (type);
 167   switch (TYPE_CODE (type))
 168     {
 169     case TYPE_CODE_ARRAY:
 170       unresolved_elttype = TYPE_TARGET_TYPE (type);
 171       elttype = check_typedef (unresolved_elttype);
 172       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 173         {
 174           LONGEST low_bound, high_bound;
 175
 176           if (!get_array_bounds (type, &low_bound, &high_bound))
 177             error (_("Could not determine the array high bound"));
 178
 179           eltlen = TYPE_LENGTH (elttype);
 180           len = high_bound - low_bound + 1;
 181           if (options->prettyprint_arrays)
 182             {
 183               print_spaces_filtered (2 + 2 * recurse, stream);
 184             }
 185
 186           /* Print arrays of textual chars with a string syntax, as
 187              long as the entire array is valid.  */
 188           if (c_textual_element_type (unresolved_elttype,
 189                                       options->format)
 190               && value_bytes_available (original_value, embedded_offset,
 191                                         TYPE_LENGTH (type))
 192               && value_bits_valid (original_value,
 193                                    TARGET_CHAR_BIT * embedded_offset,
 194                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 195             {
 196               /* If requested, look for the first null char and only
 197                  print elements up to it.  */
 198               if (options->stop_print_at_null)
 199                 {
 200                   unsigned int temp_len;
 201
 202                   for (temp_len = 0;
 203                        (temp_len < len
 204                         && temp_len < options->print_max
 205                         && extract_unsigned_integer (valaddr + embedded_offset
 206                                                      + temp_len * eltlen,
 207                                                      eltlen, byte_order) != 0);
 208                        ++temp_len)
 209                     ;
 210                   len = temp_len;
 211                 }
 212
 213               LA_PRINT_STRING (stream, unresolved_elttype,
 214                                valaddr + embedded_offset, len,
 215                                NULL, 0, options);
 216               i = len;
 217             }
 218           else
 219             {
 220               fprintf_filtered (stream, "{");
 221               /* If this is a virtual function table, print the 0th
 222                  entry specially, and the rest of the members
 223                  normally.  */
 224               if (cp_is_vtbl_ptr_type (elttype))
 225                 {
 226                   i = 1;
 227                   fprintf_filtered (stream, _("%d vtable entries"),
 228                                     len - 1);
 229                 }
 230               else
 231                 {
 232                   i = 0;
 233                 }
 234               val_print_array_elements (type, valaddr, embedded_offset,
 235                                         address, stream,
 236                                         recurse, original_value, options, i);
 237               fprintf_filtered (stream, "}");
 238             }
 239           break;
 240         }
 241       /* Array of unspecified length: treat like pointer to first
 242          elt.  */
 243       addr = address + embedded_offset;
 244       goto print_unpacked_pointer;
 245
 246     case TYPE_CODE_MEMBERPTR:
 247       if (options->format)
 248         {
 249           val_print_scalar_formatted (type, valaddr, embedded_offset,
 250                                       original_value, options, 0, stream);
 251           break;
 252         }
 253       cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 254       break;
 255
 256     case TYPE_CODE_METHODPTR:
 257       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 258       break;
 259
 260     case TYPE_CODE_PTR:
 261       if (options->format && options->format != 's')
 262         {
 263           val_print_scalar_formatted (type, valaddr, embedded_offset,
 264                                       original_value, options, 0, stream);
 265           break;
 266         }
 267       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 268         {
 269           /* Print the unmangled name if desired.  */
 270           /* Print vtable entry - we only get here if we ARE using
 271              -fvtable_thunks.  (Otherwise, look under
 272              TYPE_CODE_STRUCT.)  */
 273           CORE_ADDR addr
 274             = extract_typed_address (valaddr + embedded_offset, type);
 275
 276           print_function_pointer_address (gdbarch, addr, stream,
 277                                           options->addressprint);
 278           break;
 279         }
 280       unresolved_elttype = TYPE_TARGET_TYPE (type);
 281       elttype = check_typedef (unresolved_elttype);
 282         {
 283           addr = unpack_pointer (type, valaddr + embedded_offset);
 284         print_unpacked_pointer:
 285
 286           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 287             {
 288               /* Try to print what function it points to.  */
 289               print_function_pointer_address (gdbarch, addr, stream,
 290                                               options->addressprint);
 291               /* Return value is irrelevant except for string
 292                  pointers.  */
 293               return (0);
 294             }
 295
 296           if (options->addressprint)
 297             fputs_filtered (paddress (gdbarch, addr), stream);
 298
 299           /* For a pointer to a textual type, also print the string
 300              pointed to, unless pointer is null.  */
 301
 302           if (c_textual_element_type (unresolved_elttype,
 303                                       options->format)
 304               && addr != 0)
 305             {
 306               i = val_print_string (unresolved_elttype, NULL,
 307                                     addr, -1,
 308                                     stream, options);
 309             }
 310           else if (cp_is_vtbl_member (type))
 311             {
 312               /* Print vtbl's nicely.  */
 313               CORE_ADDR vt_address = unpack_pointer (type,
 314                                                      valaddr
 315                                                      + embedded_offset);
 316
 317               struct minimal_symbol *msymbol =
 318               lookup_minimal_symbol_by_pc (vt_address);
 319               if ((msymbol != NULL)
 320                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 321                 {
 322                   fputs_filtered (" <", stream);
 323                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 324                   fputs_filtered (">", stream);
 325                 }
 326               if (vt_address && options->vtblprint)
 327                 {
 328                   struct value *vt_val;
 329                   struct symbol *wsym = (struct symbol *) NULL;
 330                   struct type *wtype;
 331                   struct block *block = (struct block *) NULL;
 332                   int is_this_fld;
 333
 334                   if (msymbol != NULL)
 335                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 336                                           block, VAR_DOMAIN,
 337                                           &is_this_fld);
 338
 339                   if (wsym)
 340                     {
 341                       wtype = SYMBOL_TYPE (wsym);
 342                     }
 343                   else
 344                     {
 345                       wtype = unresolved_elttype;
 346                     }
 347                   vt_val = value_at (wtype, vt_address);
 348                   common_val_print (vt_val, stream, recurse + 1,
 349                                     options, current_language);
 350                   if (options->pretty)
 351                     {
 352                       fprintf_filtered (stream, "\n");
 353                       print_spaces_filtered (2 + 2 * recurse, stream);
 354                     }
 355                 }
 356             }
 357
 358           /* Return number of characters printed, including the
 359              terminating '\0' if we reached the end.  val_print_string
 360              takes care including the terminating '\0' if
 361              necessary.  */
 362           return i;
 363         }
 364       break;
 365
 366     case TYPE_CODE_REF:
 367       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 368       if (options->addressprint)
 369         {
 370           CORE_ADDR addr
 371             = extract_typed_address (valaddr + embedded_offset, type);
 372
 373           fprintf_filtered (stream, "@");
 374           fputs_filtered (paddress (gdbarch, addr), stream);
 375           if (options->deref_ref)
 376             fputs_filtered (": ", stream);
 377         }
 378       /* De-reference the reference.  */
 379       if (options->deref_ref)
 380         {
 381           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 382             {
 383               struct value *deref_val;
 384
 385               deref_val = coerce_ref_if_computed (original_value);
 386               if (deref_val != NULL)
 387                 {
 388                   /* More complicated computed references are not supported.  */
 389                   gdb_assert (embedded_offset == 0);
 390                 }
 391               else
 392                 deref_val = value_at (TYPE_TARGET_TYPE (type),
 393                                       unpack_pointer (type,
 394                                                       (valaddr
 395                                                        + embedded_offset)));
 396
 397               common_val_print (deref_val, stream, recurse, options,
 398                                 current_language);
 399             }
 400           else
 401             fputs_filtered ("???", stream);
 402         }
 403       break;
 404
 405     case TYPE_CODE_UNION:
 406       if (recurse && !options->unionprint)
 407         {
 408           fprintf_filtered (stream, "{...}");
 409           break;
 410         }
 411       /* Fall through.  */
 412     case TYPE_CODE_STRUCT:
 413       /*FIXME: Abstract this away.  */
 414       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 415         {
 416           /* Print the unmangled name if desired.  */
 417           /* Print vtable entry - we only get here if NOT using
 418              -fvtable_thunks.  (Otherwise, look under
 419              TYPE_CODE_PTR.)  */
 420           int offset = (embedded_offset
 421                         + TYPE_FIELD_BITPOS (type,
 422                                              VTBL_FNADDR_OFFSET) / 8);
 423           struct type *field_type = TYPE_FIELD_TYPE (type,
 424                                                      VTBL_FNADDR_OFFSET);
 425           CORE_ADDR addr
 426             = extract_typed_address (valaddr + offset, field_type);
 427
 428           print_function_pointer_address (gdbarch, addr, stream,
 429                                           options->addressprint);
 430         }
 431       else
 432         cp_print_value_fields_rtti (type, valaddr,
 433                                     embedded_offset, address,
 434                                     stream, recurse,
 435                                     original_value, options,
 436                                     NULL, 0);
 437       break;
 438
 439     case TYPE_CODE_ENUM:
 440       if (options->format)
 441         {
 442           val_print_scalar_formatted (type, valaddr, embedded_offset,
 443                                       original_value, options, 0, stream);
 444           break;
 445         }
 446       len = TYPE_NFIELDS (type);
 447       val = unpack_long (type, valaddr + embedded_offset);
 448       for (i = 0; i < len; i++)
 449         {
 450           QUIT;
 451           if (val == TYPE_FIELD_BITPOS (type, i))
 452             {
 453               break;
 454             }
 455         }
 456       if (i < len)
 457         {
 458           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 459         }
 460       else
 461         {
 462           print_longest (stream, 'd', 0, val);
 463         }
 464       break;
 465
 466     case TYPE_CODE_FLAGS:
 467       if (options->format)
 468         val_print_scalar_formatted (type, valaddr, embedded_offset,
 469                                     original_value, options, 0, stream);
 470       else
 471         val_print_type_code_flags (type, valaddr + embedded_offset,
 472                                    stream);
 473       break;
 474
 475     case TYPE_CODE_FUNC:
 476     case TYPE_CODE_METHOD:
 477       if (options->format)
 478         {
 479           val_print_scalar_formatted (type, valaddr, embedded_offset,
 480                                       original_value, options, 0, stream);
 481           break;
 482         }
 483       /* FIXME, we should consider, at least for ANSI C language,
 484          eliminating the distinction made between FUNCs and POINTERs
 485          to FUNCs.  */
 486       fprintf_filtered (stream, "{");
 487       type_print (type, "", stream, -1);
 488       fprintf_filtered (stream, "} ");
 489       /* Try to print what function it points to, and its address.  */
 490       print_address_demangle (gdbarch, address, stream, demangle);
 491       break;
 492
 493     case TYPE_CODE_BOOL:
 494       if (options->format || options->output_format)
 495         {
 496           struct value_print_options opts = *options;
 497           opts.format = (options->format ? options->format
 498                          : options->output_format);
 499           val_print_scalar_formatted (type, valaddr, embedded_offset,
 500                                       original_value, &opts, 0, stream);
 501         }
 502       else
 503         {
 504           val = unpack_long (type, valaddr + embedded_offset);
 505           if (val == 0)
 506             fputs_filtered ("false", stream);
 507           else if (val == 1)
 508             fputs_filtered ("true", stream);
 509           else
 510             print_longest (stream, 'd', 0, val);
 511         }
 512       break;
 513
 514     case TYPE_CODE_RANGE:
 515       /* FIXME: create_range_type does not set the unsigned bit in a
 516          range type (I think it probably should copy it from the
 517          target type), so we won't print values which are too large to
 518          fit in a signed integer correctly.  */
 519       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 520          print with the target type, though, because the size of our
 521          type and the target type might differ).  */
 522       /* FALLTHROUGH */
 523
 524     case TYPE_CODE_INT:
 525       if (options->format || options->output_format)
 526         {
 527           struct value_print_options opts = *options;
 528
 529           opts.format = (options->format ? options->format
 530                          : options->output_format);
 531           val_print_scalar_formatted (type, valaddr, embedded_offset,
 532                                       original_value, &opts, 0, stream);
 533         }
 534       else
 535         {
 536           val_print_type_code_int (type, valaddr + embedded_offset,
 537                                    stream);
 538           /* C and C++ has no single byte int type, char is used
 539              instead.  Since we don't know whether the value is really
 540              intended to be used as an integer or a character, print
 541              the character equivalent as well.  */
 542           if (c_textual_element_type (unresolved_type, options->format))
 543             {
 544               fputs_filtered (" ", stream);
 545               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 546                              unresolved_type, stream);
 547             }
 548         }
 549       break;
 550
 551     case TYPE_CODE_CHAR:
 552       if (options->format || options->output_format)
 553         {
 554           struct value_print_options opts = *options;
 555           opts.format = (options->format ? options->format
 556                          : options->output_format);
 557           val_print_scalar_formatted (type, valaddr, embedded_offset,
 558                                       original_value, &opts, 0, stream);
 559         }
 560       else
 561         {
 562           val = unpack_long (type, valaddr + embedded_offset);
 563           if (TYPE_UNSIGNED (type))
 564             fprintf_filtered (stream, "%u", (unsigned int) val);
 565           else
 566             fprintf_filtered (stream, "%d", (int) val);
 567           fputs_filtered (" ", stream);
 568           LA_PRINT_CHAR (val, unresolved_type, stream);
 569         }
 570       break;
 571
 572     case TYPE_CODE_FLT:
 573       if (options->format)
 574         {
 575           val_print_scalar_formatted (type, valaddr, embedded_offset,
 576                                       original_value, options, 0, stream);
 577         }
 578       else
 579         {
 580           print_floating (valaddr + embedded_offset, type, stream);
 581         }
 582       break;
 583
 584     case TYPE_CODE_DECFLOAT:
 585       if (options->format)
 586         val_print_scalar_formatted (type, valaddr, embedded_offset,
 587                                     original_value, options, 0, stream);
 588       else
 589         print_decimal_floating (valaddr + embedded_offset,
 590                                 type, stream);
 591       break;
 592
 593     case TYPE_CODE_VOID:
 594       fprintf_filtered (stream, "void");
 595       break;
 596
 597     case TYPE_CODE_ERROR:
 598       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 599       break;
 600
 601     case TYPE_CODE_UNDEF:
 602       /* This happens (without TYPE_FLAG_STUB set) on systems which
 603          don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
 604          "struct foo *bar" and no complete type for struct foo in that
 605          file.  */
 606       fprintf_filtered (stream, _("<incomplete type>"));
 607       break;
 608
 609     case TYPE_CODE_COMPLEX:
 610       if (options->format)
 611         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 612                                     valaddr, embedded_offset,
 613                                     original_value, options, 0, stream);
 614       else
 615         print_floating (valaddr + embedded_offset,
 616                         TYPE_TARGET_TYPE (type),
 617                         stream);
 618       fprintf_filtered (stream, " + ");
 619       if (options->format)
 620         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 621                                     valaddr,
 622                                     embedded_offset
 623                                     + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 624                                     original_value,
 625                                     options, 0, stream);
 626       else
 627         print_floating (valaddr + embedded_offset
 628                         + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 629                         TYPE_TARGET_TYPE (type),
 630                         stream);
 631       fprintf_filtered (stream, " * I");
 632       break;
 633
 634     default:
 635       error (_("Invalid C/C++ type code %d in symbol table."),
 636              TYPE_CODE (type));
 637     }
 638   gdb_flush (stream);
 639   return (0);
 640 }
 641 \f
 642 int
 643 c_value_print (struct value *val, struct ui_file *stream,
 644                const struct value_print_options *options)
 645 {
 646   struct type *type, *real_type, *val_type;
 647   int full, top, using_enc;
 648   struct value_print_options opts = *options;
 649
 650   opts.deref_ref = 1;
 651
 652   /* If it is a pointer, indicate what it points to.
 653
 654      Print type also if it is a reference.
 655
 656      C++: if it is a member pointer, we will take care
 657      of that when we print it.  */
 658
 659   /* Preserve the original type before stripping typedefs.  We prefer
 660      to pass down the original type when possible, but for local
 661      checks it is better to look past the typedefs.  */
 662   val_type = value_type (val);
 663   type = check_typedef (val_type);
 664
 665   if (TYPE_CODE (type) == TYPE_CODE_PTR
 666       || TYPE_CODE (type) == TYPE_CODE_REF)
 667     {
 668       /* Hack:  remove (char *) for char strings.  Their
 669          type is indicated by the quoted string anyway.
 670          (Don't use c_textual_element_type here; quoted strings
 671          are always exactly (char *), (wchar_t *), or the like.  */
 672       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 673           && TYPE_NAME (val_type) == NULL
 674           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 675           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 676                       "char") == 0
 677               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 678         {
 679           /* Print nothing.  */
 680         }
 681       else if (options->objectprint
 682                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 683         {
 684
 685           if (TYPE_CODE(type) == TYPE_CODE_REF)
 686             {
 687               /* Copy value, change to pointer, so we don't get an
 688                  error about a non-pointer type in
 689                  value_rtti_target_type.  */
 690               struct value *temparg;
 691               temparg=value_copy(val);
 692               deprecated_set_value_type
 693                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 694               val = temparg;
 695             }
 696           /* Pointer to class, check real type of object.  */
 697           fprintf_filtered (stream, "(");
 698
 699           if (value_entirely_available (val))
 700             {
 701               real_type = value_rtti_target_type (val, &full, &top, &using_enc);
 702               if (real_type)
 703                 {
 704                   /* RTTI entry found.  */
 705                   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 706                     {
 707                       /* Create a pointer type pointing to the real
 708                          type.  */
 709                       type = lookup_pointer_type (real_type);
 710                     }
 711                   else
 712                     {
 713                       /* Create a reference type referencing the real
 714                          type.  */
 715                       type = lookup_reference_type (real_type);
 716                     }
 717                   /* Need to adjust pointer value.  */
 718                   val = value_from_pointer (type, value_as_address (val) - top);
 719
 720                   /* Note: When we look up RTTI entries, we don't get
 721                      any information on const or volatile
 722                      attributes.  */
 723                 }
 724             }
 725           type_print (type, "", stream, -1);
 726           fprintf_filtered (stream, ") ");
 727           val_type = type;
 728         }
 729       else
 730         {
 731           /* normal case */
 732           fprintf_filtered (stream, "(");
 733           type_print (value_type (val), "", stream, -1);
 734           fprintf_filtered (stream, ") ");
 735         }
 736     }
 737
 738   if (!value_initialized (val))
 739     fprintf_filtered (stream, " [uninitialized] ");
 740
 741   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 742     {
 743       /* Attempt to determine real type of object.  */
 744       real_type = value_rtti_type (val, &full, &top, &using_enc);
 745       if (real_type)
 746         {
 747           /* We have RTTI information, so use it.  */
 748           val = value_full_object (val, real_type,
 749                                    full, top, using_enc);
 750           fprintf_filtered (stream, "(%s%s) ",
 751                             TYPE_NAME (real_type),
 752                             full ? "" : _(" [incomplete object]"));
 753           /* Print out object: enclosing type is same as real_type if
 754              full.  */
 755           return val_print (value_enclosing_type (val),
 756                             value_contents_for_printing (val), 0,
 757                             value_address (val), stream, 0,
 758                             val, &opts, current_language);
 759           /* Note: When we look up RTTI entries, we don't get any
 760              information on const or volatile attributes.  */
 761         }
 762       else if (type != check_typedef (value_enclosing_type (val)))
 763         {
 764           /* No RTTI information, so let's do our best.  */
 765           fprintf_filtered (stream, "(%s ?) ",
 766                             TYPE_NAME (value_enclosing_type (val)));
 767           return val_print (value_enclosing_type (val),
 768                             value_contents_for_printing (val), 0,
 769                             value_address (val), stream, 0,
 770                             val, &opts, current_language);
 771         }
 772       /* Otherwise, we end up at the return outside this "if".  */
 773     }
 774
 775   return val_print (val_type, value_contents_for_printing (val),
 776                     value_embedded_offset (val),
 777                     value_address (val),
 778                     stream, 0,
 779                     val, &opts, current_language);
 780 }