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