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