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;
 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                 value_at
 385                 (TYPE_TARGET_TYPE (type),
 386                  unpack_pointer (type, valaddr + embedded_offset));
 387
 388               common_val_print (deref_val, stream, recurse, options,
 389                                 current_language);
 390             }
 391           else
 392             fputs_filtered ("???", stream);
 393         }
 394       break;
 395
 396     case TYPE_CODE_UNION:
 397       if (recurse && !options->unionprint)
 398         {
 399           fprintf_filtered (stream, "{...}");
 400           break;
 401         }
 402       /* Fall through.  */
 403     case TYPE_CODE_STRUCT:
 404       /*FIXME: Abstract this away.  */
 405       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 406         {
 407           /* Print the unmangled name if desired.  */
 408           /* Print vtable entry - we only get here if NOT using
 409              -fvtable_thunks.  (Otherwise, look under
 410              TYPE_CODE_PTR.)  */
 411           int offset = (embedded_offset
 412                         + TYPE_FIELD_BITPOS (type,
 413                                              VTBL_FNADDR_OFFSET) / 8);
 414           struct type *field_type = TYPE_FIELD_TYPE (type,
 415                                                      VTBL_FNADDR_OFFSET);
 416           CORE_ADDR addr
 417             = extract_typed_address (valaddr + offset, field_type);
 418
 419           print_function_pointer_address (gdbarch, addr, stream,
 420                                           options->addressprint);
 421         }
 422       else
 423         cp_print_value_fields_rtti (type, valaddr,
 424                                     embedded_offset, address,
 425                                     stream, recurse,
 426                                     original_value, options,
 427                                     NULL, 0);
 428       break;
 429
 430     case TYPE_CODE_ENUM:
 431       if (options->format)
 432         {
 433           val_print_scalar_formatted (type, valaddr, embedded_offset,
 434                                       original_value, options, 0, stream);
 435           break;
 436         }
 437       len = TYPE_NFIELDS (type);
 438       val = unpack_long (type, valaddr + embedded_offset);
 439       for (i = 0; i < len; i++)
 440         {
 441           QUIT;
 442           if (val == TYPE_FIELD_BITPOS (type, i))
 443             {
 444               break;
 445             }
 446         }
 447       if (i < len)
 448         {
 449           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 450         }
 451       else
 452         {
 453           print_longest (stream, 'd', 0, val);
 454         }
 455       break;
 456
 457     case TYPE_CODE_FLAGS:
 458       if (options->format)
 459         val_print_scalar_formatted (type, valaddr, embedded_offset,
 460                                     original_value, options, 0, stream);
 461       else
 462         val_print_type_code_flags (type, valaddr + embedded_offset,
 463                                    stream);
 464       break;
 465
 466     case TYPE_CODE_FUNC:
 467     case TYPE_CODE_METHOD:
 468       if (options->format)
 469         {
 470           val_print_scalar_formatted (type, valaddr, embedded_offset,
 471                                       original_value, options, 0, stream);
 472           break;
 473         }
 474       /* FIXME, we should consider, at least for ANSI C language,
 475          eliminating the distinction made between FUNCs and POINTERs
 476          to FUNCs.  */
 477       fprintf_filtered (stream, "{");
 478       type_print (type, "", stream, -1);
 479       fprintf_filtered (stream, "} ");
 480       /* Try to print what function it points to, and its address.  */
 481       print_address_demangle (gdbarch, address, stream, demangle);
 482       break;
 483
 484     case TYPE_CODE_BOOL:
 485       if (options->format || options->output_format)
 486         {
 487           struct value_print_options opts = *options;
 488           opts.format = (options->format ? options->format
 489                          : options->output_format);
 490           val_print_scalar_formatted (type, valaddr, embedded_offset,
 491                                       original_value, &opts, 0, stream);
 492         }
 493       else
 494         {
 495           val = unpack_long (type, valaddr + embedded_offset);
 496           if (val == 0)
 497             fputs_filtered ("false", stream);
 498           else if (val == 1)
 499             fputs_filtered ("true", stream);
 500           else
 501             print_longest (stream, 'd', 0, val);
 502         }
 503       break;
 504
 505     case TYPE_CODE_RANGE:
 506       /* FIXME: create_range_type does not set the unsigned bit in a
 507          range type (I think it probably should copy it from the
 508          target type), so we won't print values which are too large to
 509          fit in a signed integer correctly.  */
 510       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 511          print with the target type, though, because the size of our
 512          type and the target type might differ).  */
 513       /* FALLTHROUGH */
 514
 515     case TYPE_CODE_INT:
 516       if (options->format || options->output_format)
 517         {
 518           struct value_print_options opts = *options;
 519
 520           opts.format = (options->format ? options->format
 521                          : options->output_format);
 522           val_print_scalar_formatted (type, valaddr, embedded_offset,
 523                                       original_value, &opts, 0, stream);
 524         }
 525       else
 526         {
 527           val_print_type_code_int (type, valaddr + embedded_offset,
 528                                    stream);
 529           /* C and C++ has no single byte int type, char is used
 530              instead.  Since we don't know whether the value is really
 531              intended to be used as an integer or a character, print
 532              the character equivalent as well.  */
 533           if (c_textual_element_type (unresolved_type, options->format))
 534             {
 535               fputs_filtered (" ", stream);
 536               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 537                              unresolved_type, stream);
 538             }
 539         }
 540       break;
 541
 542     case TYPE_CODE_CHAR:
 543       if (options->format || options->output_format)
 544         {
 545           struct value_print_options opts = *options;
 546           opts.format = (options->format ? options->format
 547                          : options->output_format);
 548           val_print_scalar_formatted (type, valaddr, embedded_offset,
 549                                       original_value, &opts, 0, stream);
 550         }
 551       else
 552         {
 553           val = unpack_long (type, valaddr + embedded_offset);
 554           if (TYPE_UNSIGNED (type))
 555             fprintf_filtered (stream, "%u", (unsigned int) val);
 556           else
 557             fprintf_filtered (stream, "%d", (int) val);
 558           fputs_filtered (" ", stream);
 559           LA_PRINT_CHAR (val, unresolved_type, stream);
 560         }
 561       break;
 562
 563     case TYPE_CODE_FLT:
 564       if (options->format)
 565         {
 566           val_print_scalar_formatted (type, valaddr, embedded_offset,
 567                                       original_value, options, 0, stream);
 568         }
 569       else
 570         {
 571           print_floating (valaddr + embedded_offset, type, stream);
 572         }
 573       break;
 574
 575     case TYPE_CODE_DECFLOAT:
 576       if (options->format)
 577         val_print_scalar_formatted (type, valaddr, embedded_offset,
 578                                     original_value, options, 0, stream);
 579       else
 580         print_decimal_floating (valaddr + embedded_offset,
 581                                 type, stream);
 582       break;
 583
 584     case TYPE_CODE_VOID:
 585       fprintf_filtered (stream, "void");
 586       break;
 587
 588     case TYPE_CODE_ERROR:
 589       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 590       break;
 591
 592     case TYPE_CODE_UNDEF:
 593       /* This happens (without TYPE_FLAG_STUB set) on systems which
 594          don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
 595          "struct foo *bar" and no complete type for struct foo in that
 596          file.  */
 597       fprintf_filtered (stream, _("<incomplete type>"));
 598       break;
 599
 600     case TYPE_CODE_COMPLEX:
 601       if (options->format)
 602         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 603                                     valaddr, embedded_offset,
 604                                     original_value, options, 0, stream);
 605       else
 606         print_floating (valaddr + embedded_offset,
 607                         TYPE_TARGET_TYPE (type),
 608                         stream);
 609       fprintf_filtered (stream, " + ");
 610       if (options->format)
 611         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 612                                     valaddr,
 613                                     embedded_offset
 614                                     + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 615                                     original_value,
 616                                     options, 0, stream);
 617       else
 618         print_floating (valaddr + embedded_offset
 619                         + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 620                         TYPE_TARGET_TYPE (type),
 621                         stream);
 622       fprintf_filtered (stream, " * I");
 623       break;
 624
 625     default:
 626       error (_("Invalid C/C++ type code %d in symbol table."),
 627              TYPE_CODE (type));
 628     }
 629   gdb_flush (stream);
 630   return (0);
 631 }
 632 \f
 633 int
 634 c_value_print (struct value *val, struct ui_file *stream,
 635                const struct value_print_options *options)
 636 {
 637   struct type *type, *real_type, *val_type;
 638   int full, top, using_enc;
 639   struct value_print_options opts = *options;
 640
 641   opts.deref_ref = 1;
 642
 643   /* If it is a pointer, indicate what it points to.
 644
 645      Print type also if it is a reference.
 646
 647      C++: if it is a member pointer, we will take care
 648      of that when we print it.  */
 649
 650   /* Preserve the original type before stripping typedefs.  We prefer
 651      to pass down the original type when possible, but for local
 652      checks it is better to look past the typedefs.  */
 653   val_type = value_type (val);
 654   type = check_typedef (val_type);
 655
 656   if (TYPE_CODE (type) == TYPE_CODE_PTR
 657       || TYPE_CODE (type) == TYPE_CODE_REF)
 658     {
 659       /* Hack:  remove (char *) for char strings.  Their
 660          type is indicated by the quoted string anyway.
 661          (Don't use c_textual_element_type here; quoted strings
 662          are always exactly (char *), (wchar_t *), or the like.  */
 663       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 664           && TYPE_NAME (val_type) == NULL
 665           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 666           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 667                       "char") == 0
 668               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 669         {
 670           /* Print nothing.  */
 671         }
 672       else if (options->objectprint
 673                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 674         {
 675
 676           if (TYPE_CODE(type) == TYPE_CODE_REF)
 677             {
 678               /* Copy value, change to pointer, so we don't get an
 679                  error about a non-pointer type in
 680                  value_rtti_target_type.  */
 681               struct value *temparg;
 682               temparg=value_copy(val);
 683               deprecated_set_value_type
 684                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 685               val = temparg;
 686             }
 687           /* Pointer to class, check real type of object.  */
 688           fprintf_filtered (stream, "(");
 689           real_type = value_rtti_target_type (val, &full,
 690                                               &top, &using_enc);
 691           if (real_type)
 692             {
 693               /* RTTI entry found.  */
 694               if (TYPE_CODE (type) == TYPE_CODE_PTR)
 695                 {
 696                   /* Create a pointer type pointing to the real
 697                      type.  */
 698                   type = lookup_pointer_type (real_type);
 699                 }
 700               else
 701                 {
 702                   /* Create a reference type referencing the real
 703                      type.  */
 704                   type = lookup_reference_type (real_type);
 705                 }
 706               /* JYG: Need to adjust pointer value.  */
 707               val = value_from_pointer (type, value_as_address (val) - top);
 708
 709               /* Note: When we look up RTTI entries, we don't get any
 710                  information on const or volatile attributes.  */
 711             }
 712           type_print (type, "", stream, -1);
 713           fprintf_filtered (stream, ") ");
 714           val_type = type;
 715         }
 716       else
 717         {
 718           /* normal case */
 719           fprintf_filtered (stream, "(");
 720           type_print (value_type (val), "", stream, -1);
 721           fprintf_filtered (stream, ") ");
 722         }
 723     }
 724
 725   if (!value_initialized (val))
 726     fprintf_filtered (stream, " [uninitialized] ");
 727
 728   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 729     {
 730       /* Attempt to determine real type of object.  */
 731       real_type = value_rtti_type (val, &full, &top, &using_enc);
 732       if (real_type)
 733         {
 734           /* We have RTTI information, so use it.  */
 735           val = value_full_object (val, real_type,
 736                                    full, top, using_enc);
 737           fprintf_filtered (stream, "(%s%s) ",
 738                             TYPE_NAME (real_type),
 739                             full ? "" : _(" [incomplete object]"));
 740           /* Print out object: enclosing type is same as real_type if
 741              full.  */
 742           return val_print (value_enclosing_type (val),
 743                             value_contents_for_printing (val), 0,
 744                             value_address (val), stream, 0,
 745                             val, &opts, current_language);
 746           /* Note: When we look up RTTI entries, we don't get any
 747              information on const or volatile attributes.  */
 748         }
 749       else if (type != check_typedef (value_enclosing_type (val)))
 750         {
 751           /* No RTTI information, so let's do our best.  */
 752           fprintf_filtered (stream, "(%s ?) ",
 753                             TYPE_NAME (value_enclosing_type (val)));
 754           return val_print (value_enclosing_type (val),
 755                             value_contents_for_printing (val), 0,
 756                             value_address (val), stream, 0,
 757                             val, &opts, current_language);
 758         }
 759       /* Otherwise, we end up at the return outside this "if".  */
 760     }
 761
 762   return val_print (val_type, value_contents_for_printing (val),
 763                     value_embedded_offset (val),
 764                     value_address (val),
 765                     stream, 0,
 766                     val, &opts, current_language);
 767 }