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