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