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
 146 /* Print data of type TYPE located at VALADDR (within GDB), which came
 147    from the inferior at address ADDRESS, onto stdio stream STREAM
 148    according to OPTIONS.  The data at VALADDR is in target byte order.
 149
 150    If the data are a string pointer, returns the number of string
 151    characters printed.  */
 152
 153 int
 154 c_val_print (struct type *type, const gdb_byte *valaddr,
 155              int embedded_offset, CORE_ADDR address,
 156              struct ui_file *stream, int recurse,
 157              const struct value *original_value,
 158              const struct value_print_options *options)
 159 {
 160   struct gdbarch *gdbarch = get_type_arch (type);
 161   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 162   unsigned int i = 0;   /* Number of characters printed.  */
 163   unsigned len;
 164   struct type *elttype, *unresolved_elttype;
 165   struct type *unresolved_type = type;
 166   unsigned eltlen;
 167   LONGEST val;
 168   CORE_ADDR addr;
 169
 170   CHECK_TYPEDEF (type);
 171   switch (TYPE_CODE (type))
 172     {
 173     case TYPE_CODE_ARRAY:
 174       unresolved_elttype = TYPE_TARGET_TYPE (type);
 175       elttype = check_typedef (unresolved_elttype);
 176       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 177         {
 178           LONGEST low_bound, high_bound;
 179
 180           if (!get_array_bounds (type, &low_bound, &high_bound))
 181             error (_("Could not determine the array high bound"));
 182
 183           eltlen = TYPE_LENGTH (elttype);
 184           len = high_bound - low_bound + 1;
 185           if (options->prettyprint_arrays)
 186             {
 187               print_spaces_filtered (2 + 2 * recurse, stream);
 188             }
 189
 190           /* Print arrays of textual chars with a string syntax, as
 191              long as the entire array is valid.  */
 192           if (c_textual_element_type (unresolved_elttype,
 193                                       options->format)
 194               && value_bits_valid (original_value,
 195                                    TARGET_CHAR_BIT * embedded_offset,
 196                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 197             {
 198               /* If requested, look for the first null char and only
 199                  print elements up to it.  */
 200               if (options->stop_print_at_null)
 201                 {
 202                   unsigned int temp_len;
 203
 204                   for (temp_len = 0;
 205                        (temp_len < len
 206                         && temp_len < options->print_max
 207                         && extract_unsigned_integer (valaddr + embedded_offset
 208                                                      + temp_len * eltlen,
 209                                                      eltlen, byte_order) != 0);
 210                        ++temp_len)
 211                     ;
 212                   len = temp_len;
 213                 }
 214
 215               LA_PRINT_STRING (stream, unresolved_elttype,
 216                                valaddr + embedded_offset, len,
 217                                NULL, 0, options);
 218               i = len;
 219             }
 220           else
 221             {
 222               fprintf_filtered (stream, "{");
 223               /* If this is a virtual function table, print the 0th
 224                  entry specially, and the rest of the members
 225                  normally.  */
 226               if (cp_is_vtbl_ptr_type (elttype))
 227                 {
 228                   i = 1;
 229                   fprintf_filtered (stream, _("%d vtable entries"),
 230                                     len - 1);
 231                 }
 232               else
 233                 {
 234                   i = 0;
 235                 }
 236               val_print_array_elements (type, valaddr + embedded_offset,
 237                                         address + embedded_offset,
 238                                         stream, recurse,
 239                                         original_value, options, i);
 240               fprintf_filtered (stream, "}");
 241             }
 242           break;
 243         }
 244       /* Array of unspecified length: treat like pointer to first
 245          elt.  */
 246       addr = address;
 247       goto print_unpacked_pointer;
 248
 249     case TYPE_CODE_MEMBERPTR:
 250       if (options->format)
 251         {
 252           print_scalar_formatted (valaddr + embedded_offset, type,
 253                                   options, 0, stream);
 254           break;
 255         }
 256       cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 257       break;
 258
 259     case TYPE_CODE_METHODPTR:
 260       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 261       break;
 262
 263     case TYPE_CODE_PTR:
 264       if (options->format && options->format != 's')
 265         {
 266           print_scalar_formatted (valaddr + embedded_offset, type,
 267                                   options, 0, stream);
 268           break;
 269         }
 270       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 271         {
 272           /* Print the unmangled name if desired.  */
 273           /* Print vtable entry - we only get here if we ARE using
 274              -fvtable_thunks.  (Otherwise, look under
 275              TYPE_CODE_STRUCT.)  */
 276           CORE_ADDR addr
 277             = extract_typed_address (valaddr + embedded_offset, type);
 278
 279           print_function_pointer_address (gdbarch, addr, stream,
 280                                           options->addressprint);
 281           break;
 282         }
 283       unresolved_elttype = TYPE_TARGET_TYPE (type);
 284       elttype = check_typedef (unresolved_elttype);
 285         {
 286           addr = unpack_pointer (type, valaddr + embedded_offset);
 287         print_unpacked_pointer:
 288
 289           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 290             {
 291               /* Try to print what function it points to.  */
 292               print_function_pointer_address (gdbarch, addr, stream,
 293                                               options->addressprint);
 294               /* Return value is irrelevant except for string
 295                  pointers.  */
 296               return (0);
 297             }
 298
 299           if (options->addressprint)
 300             fputs_filtered (paddress (gdbarch, addr), stream);
 301
 302           /* For a pointer to a textual type, also print the string
 303              pointed to, unless pointer is null.  */
 304
 305           if (c_textual_element_type (unresolved_elttype,
 306                                       options->format)
 307               && addr != 0)
 308             {
 309               i = val_print_string (unresolved_elttype, NULL,
 310                                     addr, -1,
 311                                     stream, options);
 312             }
 313           else if (cp_is_vtbl_member (type))
 314             {
 315               /* Print vtbl's nicely.  */
 316               CORE_ADDR vt_address = unpack_pointer (type,
 317                                                      valaddr
 318                                                      + embedded_offset);
 319
 320               struct minimal_symbol *msymbol =
 321               lookup_minimal_symbol_by_pc (vt_address);
 322               if ((msymbol != NULL)
 323                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 324                 {
 325                   fputs_filtered (" <", stream);
 326                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 327                   fputs_filtered (">", stream);
 328                 }
 329               if (vt_address && options->vtblprint)
 330                 {
 331                   struct value *vt_val;
 332                   struct symbol *wsym = (struct symbol *) NULL;
 333                   struct type *wtype;
 334                   struct block *block = (struct block *) NULL;
 335                   int is_this_fld;
 336
 337                   if (msymbol != NULL)
 338                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 339                                           block, VAR_DOMAIN,
 340                                           &is_this_fld);
 341
 342                   if (wsym)
 343                     {
 344                       wtype = SYMBOL_TYPE (wsym);
 345                     }
 346                   else
 347                     {
 348                       wtype = unresolved_elttype;
 349                     }
 350                   vt_val = value_at (wtype, vt_address);
 351                   common_val_print (vt_val, stream, recurse + 1,
 352                                     options, current_language);
 353                   if (options->pretty)
 354                     {
 355                       fprintf_filtered (stream, "\n");
 356                       print_spaces_filtered (2 + 2 * recurse, stream);
 357                     }
 358                 }
 359             }
 360
 361           /* Return number of characters printed, including the
 362              terminating '\0' if we reached the end.  val_print_string
 363              takes care including the terminating '\0' if
 364              necessary.  */
 365           return i;
 366         }
 367       break;
 368
 369     case TYPE_CODE_REF:
 370       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 371       if (options->addressprint)
 372         {
 373           CORE_ADDR addr
 374             = extract_typed_address (valaddr + embedded_offset, type);
 375
 376           fprintf_filtered (stream, "@");
 377           fputs_filtered (paddress (gdbarch, addr), stream);
 378           if (options->deref_ref)
 379             fputs_filtered (": ", stream);
 380         }
 381       /* De-reference the reference.  */
 382       if (options->deref_ref)
 383         {
 384           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 385             {
 386               struct value *deref_val =
 387                 value_at
 388                 (TYPE_TARGET_TYPE (type),
 389                  unpack_pointer (type, valaddr + embedded_offset));
 390
 391               common_val_print (deref_val, stream, recurse, options,
 392                                 current_language);
 393             }
 394           else
 395             fputs_filtered ("???", stream);
 396         }
 397       break;
 398
 399     case TYPE_CODE_UNION:
 400       if (recurse && !options->unionprint)
 401         {
 402           fprintf_filtered (stream, "{...}");
 403           break;
 404         }
 405       /* Fall through.  */
 406     case TYPE_CODE_STRUCT:
 407       /*FIXME: Abstract this away */
 408       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 409         {
 410           /* Print the unmangled name if desired.  */
 411           /* Print vtable entry - we only get here if NOT using
 412              -fvtable_thunks.  (Otherwise, look under
 413              TYPE_CODE_PTR.)  */
 414           int offset = (embedded_offset
 415                         + TYPE_FIELD_BITPOS (type,
 416                                              VTBL_FNADDR_OFFSET) / 8);
 417           struct type *field_type = TYPE_FIELD_TYPE (type,
 418                                                      VTBL_FNADDR_OFFSET);
 419           CORE_ADDR addr
 420             = extract_typed_address (valaddr + offset, field_type);
 421
 422           print_function_pointer_address (gdbarch, addr, stream,
 423                                           options->addressprint);
 424         }
 425       else
 426         cp_print_value_fields_rtti (type, valaddr,
 427                                     embedded_offset, address,
 428                                     stream, recurse,
 429                                     original_value, options,
 430                                     NULL, 0);
 431       break;
 432
 433     case TYPE_CODE_ENUM:
 434       if (options->format)
 435         {
 436           print_scalar_formatted (valaddr + embedded_offset, type,
 437                                   options, 0, stream);
 438           break;
 439         }
 440       len = TYPE_NFIELDS (type);
 441       val = unpack_long (type, valaddr + embedded_offset);
 442       for (i = 0; i < len; i++)
 443         {
 444           QUIT;
 445           if (val == TYPE_FIELD_BITPOS (type, i))
 446             {
 447               break;
 448             }
 449         }
 450       if (i < len)
 451         {
 452           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 453         }
 454       else
 455         {
 456           print_longest (stream, 'd', 0, val);
 457         }
 458       break;
 459
 460     case TYPE_CODE_FLAGS:
 461       if (options->format)
 462           print_scalar_formatted (valaddr + embedded_offset, type,
 463                                   options, 0, stream);
 464       else
 465         val_print_type_code_flags (type, valaddr + embedded_offset,
 466                                    stream);
 467       break;
 468
 469     case TYPE_CODE_FUNC:
 470     case TYPE_CODE_METHOD:
 471       if (options->format)
 472         {
 473           print_scalar_formatted (valaddr + embedded_offset, type,
 474                                   options, 0, stream);
 475           break;
 476         }
 477       /* FIXME, we should consider, at least for ANSI C language,
 478          eliminating the distinction made between FUNCs and POINTERs
 479          to FUNCs.  */
 480       fprintf_filtered (stream, "{");
 481       type_print (type, "", stream, -1);
 482       fprintf_filtered (stream, "} ");
 483       /* Try to print what function it points to, and its address.  */
 484       print_address_demangle (gdbarch, address, stream, demangle);
 485       break;
 486
 487     case TYPE_CODE_BOOL:
 488       if (options->format || options->output_format)
 489         {
 490           struct value_print_options opts = *options;
 491           opts.format = (options->format ? options->format
 492                          : options->output_format);
 493           print_scalar_formatted (valaddr + embedded_offset, type,
 494                                   &opts, 0, stream);
 495         }
 496       else
 497         {
 498           val = unpack_long (type, valaddr + embedded_offset);
 499           if (val == 0)
 500             fputs_filtered ("false", stream);
 501           else if (val == 1)
 502             fputs_filtered ("true", stream);
 503           else
 504             print_longest (stream, 'd', 0, val);
 505         }
 506       break;
 507
 508     case TYPE_CODE_RANGE:
 509       /* FIXME: create_range_type does not set the unsigned bit in a
 510          range type (I think it probably should copy it from the
 511          target type), so we won't print values which are too large to
 512          fit in a signed integer correctly.  */
 513       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 514          print with the target type, though, because the size of our
 515          type and the target type might differ).  */
 516       /* FALLTHROUGH */
 517
 518     case TYPE_CODE_INT:
 519       if (options->format || options->output_format)
 520         {
 521           struct value_print_options opts = *options;
 522
 523           opts.format = (options->format ? options->format
 524                          : options->output_format);
 525           print_scalar_formatted (valaddr + embedded_offset, type,
 526                                   &opts, 0, stream);
 527         }
 528       else
 529         {
 530           val_print_type_code_int (type, valaddr + embedded_offset,
 531                                    stream);
 532           /* C and C++ has no single byte int type, char is used
 533              instead.  Since we don't know whether the value is really
 534              intended to be used as an integer or a character, print
 535              the character equivalent as well.  */
 536           if (c_textual_element_type (unresolved_type, options->format))
 537             {
 538               fputs_filtered (" ", stream);
 539               LA_PRINT_CHAR ((unsigned char) unpack_long (type,
 540                                                           valaddr
 541                                                           + embedded_offset),
 542                              unresolved_type, stream);
 543             }
 544         }
 545       break;
 546
 547     case TYPE_CODE_CHAR:
 548       if (options->format || options->output_format)
 549         {
 550           struct value_print_options opts = *options;
 551           opts.format = (options->format ? options->format
 552                          : options->output_format);
 553           print_scalar_formatted (valaddr + embedded_offset, type,
 554                                   &opts, 0, stream);
 555         }
 556       else
 557         {
 558           val = unpack_long (type, valaddr + embedded_offset);
 559           if (TYPE_UNSIGNED (type))
 560             fprintf_filtered (stream, "%u", (unsigned int) val);
 561           else
 562             fprintf_filtered (stream, "%d", (int) val);
 563           fputs_filtered (" ", stream);
 564           LA_PRINT_CHAR ((unsigned char) val, unresolved_type, stream);
 565         }
 566       break;
 567
 568     case TYPE_CODE_FLT:
 569       if (options->format)
 570         {
 571           print_scalar_formatted (valaddr + embedded_offset, type,
 572                                   options, 0, stream);
 573         }
 574       else
 575         {
 576           print_floating (valaddr + embedded_offset, type, stream);
 577         }
 578       break;
 579
 580     case TYPE_CODE_DECFLOAT:
 581       if (options->format)
 582         print_scalar_formatted (valaddr + embedded_offset, type,
 583                                 options, 0, stream);
 584       else
 585         print_decimal_floating (valaddr + embedded_offset,
 586                                 type, stream);
 587       break;
 588
 589     case TYPE_CODE_VOID:
 590       fprintf_filtered (stream, "void");
 591       break;
 592
 593     case TYPE_CODE_ERROR:
 594       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 595       break;
 596
 597     case TYPE_CODE_UNDEF:
 598       /* This happens (without TYPE_FLAG_STUB set) on systems which
 599          don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
 600          "struct foo *bar" and no complete type for struct foo in that
 601          file.  */
 602       fprintf_filtered (stream, _("<incomplete type>"));
 603       break;
 604
 605     case TYPE_CODE_COMPLEX:
 606       if (options->format)
 607         print_scalar_formatted (valaddr + embedded_offset,
 608                                 TYPE_TARGET_TYPE (type),
 609                                 options, 0, stream);
 610       else
 611         print_floating (valaddr + embedded_offset,
 612                         TYPE_TARGET_TYPE (type),
 613                         stream);
 614       fprintf_filtered (stream, " + ");
 615       if (options->format)
 616         print_scalar_formatted (valaddr + embedded_offset
 617                                 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 618                                 TYPE_TARGET_TYPE (type),
 619                                 options, 0, stream);
 620       else
 621         print_floating (valaddr + embedded_offset
 622                         + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 623                         TYPE_TARGET_TYPE (type),
 624                         stream);
 625       fprintf_filtered (stream, " * I");
 626       break;
 627
 628     default:
 629       error (_("Invalid C/C++ type code %d in symbol table."),
 630              TYPE_CODE (type));
 631     }
 632   gdb_flush (stream);
 633   return (0);
 634 }
 635 \f
 636 int
 637 c_value_print (struct value *val, struct ui_file *stream,
 638                const struct value_print_options *options)
 639 {
 640   struct type *type, *real_type, *val_type;
 641   int full, top, using_enc;
 642   struct value_print_options opts = *options;
 643
 644   opts.deref_ref = 1;
 645
 646   /* If it is a pointer, indicate what it points to.
 647
 648      Print type also if it is a reference.
 649
 650      C++: if it is a member pointer, we will take care
 651      of that when we print it.  */
 652
 653   /* Preserve the original type before stripping typedefs.  We prefer
 654      to pass down the original type when possible, but for local
 655      checks it is better to look past the typedefs.  */
 656   val_type = value_type (val);
 657   type = check_typedef (val_type);
 658
 659   if (TYPE_CODE (type) == TYPE_CODE_PTR
 660       || TYPE_CODE (type) == TYPE_CODE_REF)
 661     {
 662       /* Hack:  remove (char *) for char strings.  Their
 663          type is indicated by the quoted string anyway.
 664          (Don't use c_textual_element_type here; quoted strings
 665          are always exactly (char *), (wchar_t *), or the like.  */
 666       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 667           && TYPE_NAME (val_type) == NULL
 668           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 669           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 670                       "char") == 0
 671               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 672         {
 673           /* Print nothing.  */
 674         }
 675       else if (options->objectprint
 676                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 677         {
 678
 679           if (TYPE_CODE(type) == TYPE_CODE_REF)
 680             {
 681               /* Copy value, change to pointer, so we don't get an
 682                  error about a non-pointer type in
 683                  value_rtti_target_type.  */
 684               struct value *temparg;
 685               temparg=value_copy(val);
 686               deprecated_set_value_type
 687                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 688               val = temparg;
 689             }
 690           /* Pointer to class, check real type of object.  */
 691           fprintf_filtered (stream, "(");
 692           real_type = value_rtti_target_type (val, &full,
 693                                               &top, &using_enc);
 694           if (real_type)
 695             {
 696               /* RTTI entry found.  */
 697               if (TYPE_CODE (type) == TYPE_CODE_PTR)
 698                 {
 699                   /* Create a pointer type pointing to the real
 700                      type.  */
 701                   type = lookup_pointer_type (real_type);
 702                 }
 703               else
 704                 {
 705                   /* Create a reference type referencing the real
 706                      type.  */
 707                   type = lookup_reference_type (real_type);
 708                 }
 709               /* JYG: Need to adjust pointer value.  */
 710               /* NOTE: cagney/2005-01-02: THIS IS BOGUS.  */
 711               value_contents_writeable (val)[0] -= top;
 712
 713               /* Note: When we look up RTTI entries, we don't get any
 714                  information on const or volatile attributes.  */
 715             }
 716           type_print (type, "", stream, -1);
 717           fprintf_filtered (stream, ") ");
 718           val_type = type;
 719         }
 720       else
 721         {
 722           /* normal case */
 723           fprintf_filtered (stream, "(");
 724           type_print (value_type (val), "", stream, -1);
 725           fprintf_filtered (stream, ") ");
 726         }
 727     }
 728
 729   if (!value_initialized (val))
 730     fprintf_filtered (stream, " [uninitialized] ");
 731
 732   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 733     {
 734       /* Attempt to determine real type of object.  */
 735       real_type = value_rtti_type (val, &full, &top, &using_enc);
 736       if (real_type)
 737         {
 738           /* We have RTTI information, so use it.  */
 739           val = value_full_object (val, real_type,
 740                                    full, top, using_enc);
 741           fprintf_filtered (stream, "(%s%s) ",
 742                             TYPE_NAME (real_type),
 743                             full ? "" : _(" [incomplete object]"));
 744           /* Print out object: enclosing type is same as real_type if
 745              full.  */
 746           return val_print (value_enclosing_type (val),
 747                             value_contents_for_printing (val), 0,
 748                             value_address (val), stream, 0,
 749                             val, &opts, current_language);
 750           /* Note: When we look up RTTI entries, we don't get any
 751              information on const or volatile attributes.  */
 752         }
 753       else if (type != check_typedef (value_enclosing_type (val)))
 754         {
 755           /* No RTTI information, so let's do our best.  */
 756           fprintf_filtered (stream, "(%s ?) ",
 757                             TYPE_NAME (value_enclosing_type (val)));
 758           return val_print (value_enclosing_type (val),
 759                             value_contents_for_printing (val), 0,
 760                             value_address (val), stream, 0,
 761                             val, &opts, current_language);
 762         }
 763       /* Otherwise, we end up at the return outside this "if".  */
 764     }
 765
 766   return val_print (val_type, value_contents_for_printing (val),
 767                     value_embedded_offset (val),
 768                     value_address (val),
 769                     stream, 0,
 770                     val, &opts, current_language);
 771 }