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