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