gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2016 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "expression.h"
  24 #include "value.h"
  25 #include "valprint.h"
  26 #include "language.h"
  27 #include "c-lang.h"
  28 #include "cp-abi.h"
  29 #include "target.h"
  30 #include "objfiles.h"
  31 \f
  32
  33 /* A helper for c_textual_element_type.  This checks the name of the
  34    typedef.  This is bogus but it isn't apparent that the compiler
  35    provides us the help we may need.  */
  36
  37 static int
  38 textual_name (const char *name)
  39 {
  40   return (!strcmp (name, "wchar_t")
  41           || !strcmp (name, "char16_t")
  42           || !strcmp (name, "char32_t"));
  43 }
  44
  45 /* Apply a heuristic to decide whether an array of TYPE or a pointer
  46    to TYPE should be printed as a textual string.  Return non-zero if
  47    it should, or zero if it should be treated as an array of integers
  48    or pointer to integers.  FORMAT is the current format letter, or 0
  49    if none.
  50
  51    We guess that "char" is a character.  Explicitly signed and
  52    unsigned character types are also characters.  Integer data from
  53    vector types is not.  The user can override this by using the /s
  54    format letter.  */
  55
  56 int
  57 c_textual_element_type (struct type *type, char format)
  58 {
  59   struct type *true_type, *iter_type;
  60
  61   if (format != 0 && format != 's')
  62     return 0;
  63
  64   /* We also rely on this for its side effect of setting up all the
  65      typedef pointers.  */
  66   true_type = check_typedef (type);
  67
  68   /* TYPE_CODE_CHAR is always textual.  */
  69   if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
  70     return 1;
  71
  72   /* Any other character-like types must be integral.  */
  73   if (TYPE_CODE (true_type) != TYPE_CODE_INT)
  74     return 0;
  75
  76   /* We peel typedefs one by one, looking for a match.  */
  77   iter_type = type;
  78   while (iter_type)
  79     {
  80       /* Check the name of the type.  */
  81       if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
  82         return 1;
  83
  84       if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
  85         break;
  86
  87       /* Peel a single typedef.  If the typedef doesn't have a target
  88          type, we use check_typedef and hope the result is ok -- it
  89          might be for C++, where wchar_t is a built-in type.  */
  90       if (TYPE_TARGET_TYPE (iter_type))
  91         iter_type = TYPE_TARGET_TYPE (iter_type);
  92       else
  93         iter_type = check_typedef (iter_type);
  94     }
  95
  96   if (format == 's')
  97     {
  98       /* Print this as a string if we can manage it.  For now, no wide
  99          character support.  */
 100       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 101           && TYPE_LENGTH (true_type) == 1)
 102         return 1;
 103     }
 104   else
 105     {
 106       /* If a one-byte TYPE_CODE_INT is missing the not-a-character
 107          flag, then we treat it as text; otherwise, we assume it's
 108          being used as data.  */
 109       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 110           && TYPE_LENGTH (true_type) == 1
 111           && !TYPE_NOTTEXT (true_type))
 112         return 1;
 113     }
 114
 115   return 0;
 116 }
 117
 118 /* Decorations for C.  */
 119
 120 static const struct generic_val_print_decorations c_decorations =
 121 {
 122   "",
 123   " + ",
 124   " * I",
 125   "true",
 126   "false",
 127   "void",
 128   "{",
 129   "}"
 130 };
 131
 132 /* Print a pointer based on the type of its target.
 133
 134    Arguments to this functions are roughly the same as those in c_val_print.
 135    A difference is that ADDRESS is the address to print, with embedded_offset
 136    already added.  UNRESOLVED_ELTTYPE and ELTTYPE represent the pointed type,
 137    respectively before and after check_typedef.  */
 138
 139 static void
 140 print_unpacked_pointer (struct type *type, struct type *elttype,
 141                         struct type *unresolved_elttype,
 142                         const gdb_byte *valaddr, int embedded_offset,
 143                         CORE_ADDR address, struct ui_file *stream, int recurse,
 144                         const struct value_print_options *options)
 145 {
 146   int want_space = 0;
 147   struct gdbarch *gdbarch = get_type_arch (type);
 148
 149   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 150     {
 151       /* Try to print what function it points to.  */
 152       print_function_pointer_address (options, gdbarch, address, stream);
 153       return;
 154     }
 155
 156   if (options->symbol_print)
 157     want_space = print_address_demangle (options, gdbarch, address, stream,
 158                                          demangle);
 159   else if (options->addressprint)
 160     {
 161       fputs_filtered (paddress (gdbarch, address), stream);
 162       want_space = 1;
 163     }
 164
 165   /* For a pointer to a textual type, also print the string
 166      pointed to, unless pointer is null.  */
 167
 168   if (c_textual_element_type (unresolved_elttype, options->format)
 169       && address != 0)
 170     {
 171       if (want_space)
 172         fputs_filtered (" ", stream);
 173       val_print_string (unresolved_elttype, NULL, address, -1, stream, options);
 174     }
 175   else if (cp_is_vtbl_member (type))
 176     {
 177       /* Print vtbl's nicely.  */
 178       CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
 179       struct bound_minimal_symbol msymbol =
 180         lookup_minimal_symbol_by_pc (vt_address);
 181
 182       /* If 'symbol_print' is set, we did the work above.  */
 183       if (!options->symbol_print
 184           && (msymbol.minsym != NULL)
 185           && (vt_address == BMSYMBOL_VALUE_ADDRESS (msymbol)))
 186         {
 187           if (want_space)
 188             fputs_filtered (" ", stream);
 189           fputs_filtered (" <", stream);
 190           fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
 191           fputs_filtered (">", stream);
 192           want_space = 1;
 193         }
 194
 195       if (vt_address && options->vtblprint)
 196         {
 197           struct value *vt_val;
 198           struct symbol *wsym = NULL;
 199           struct type *wtype;
 200           struct block *block = NULL;
 201           struct field_of_this_result is_this_fld;
 202
 203           if (want_space)
 204             fputs_filtered (" ", stream);
 205
 206           if (msymbol.minsym != NULL)
 207             wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME(msymbol.minsym), block,
 208                                   VAR_DOMAIN, &is_this_fld).symbol;
 209
 210           if (wsym)
 211             {
 212               wtype = SYMBOL_TYPE (wsym);
 213             }
 214           else
 215             {
 216               wtype = unresolved_elttype;
 217             }
 218           vt_val = value_at (wtype, vt_address);
 219           common_val_print (vt_val, stream, recurse + 1, options,
 220                             current_language);
 221           if (options->prettyformat)
 222             {
 223               fprintf_filtered (stream, "\n");
 224               print_spaces_filtered (2 + 2 * recurse, stream);
 225             }
 226         }
 227     }
 228 }
 229
 230 /* c_val_print helper for TYPE_CODE_ARRAY.  */
 231
 232 static void
 233 c_val_print_array (struct type *type, const gdb_byte *valaddr,
 234                    int embedded_offset, CORE_ADDR address,
 235                    struct ui_file *stream, int recurse,
 236                    const struct value *original_value,
 237                    const struct value_print_options *options)
 238 {
 239   struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 240   struct type *elttype = check_typedef (unresolved_elttype);
 241   struct gdbarch *arch = get_type_arch (type);
 242   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 243
 244   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 245     {
 246       LONGEST low_bound, high_bound;
 247       int eltlen, len;
 248       struct gdbarch *gdbarch = get_type_arch (type);
 249       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 250       unsigned int i = 0;       /* Number of characters printed.  */
 251
 252       if (!get_array_bounds (type, &low_bound, &high_bound))
 253         error (_("Could not determine the array high bound"));
 254
 255       eltlen = TYPE_LENGTH (elttype);
 256       len = high_bound - low_bound + 1;
 257       if (options->prettyformat_arrays)
 258         {
 259           print_spaces_filtered (2 + 2 * recurse, stream);
 260         }
 261
 262       /* Print arrays of textual chars with a string syntax, as
 263          long as the entire array is valid.  */
 264       if (c_textual_element_type (unresolved_elttype,
 265                                   options->format)
 266           && value_bytes_available (original_value, embedded_offset,
 267                                     TYPE_LENGTH (type))
 268           && !value_bits_any_optimized_out (original_value,
 269                                             TARGET_CHAR_BIT * embedded_offset,
 270                                             TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 271         {
 272           int force_ellipses = 0;
 273
 274           /* If requested, look for the first null char and only
 275              print elements up to it.  */
 276           if (options->stop_print_at_null)
 277             {
 278               unsigned int temp_len;
 279
 280               for (temp_len = 0;
 281                    (temp_len < len
 282                     && temp_len < options->print_max
 283                     && extract_unsigned_integer (valaddr
 284                                                  + embedded_offset * unit_size
 285                                                  + temp_len * eltlen,
 286                                                  eltlen, byte_order) != 0);
 287                    ++temp_len)
 288                 ;
 289
 290               /* Force LA_PRINT_STRING to print ellipses if
 291                  we've printed the maximum characters and
 292                  the next character is not \000.  */
 293               if (temp_len == options->print_max && temp_len < len)
 294                 {
 295                   ULONGEST val
 296                     = extract_unsigned_integer (valaddr
 297                                                 + embedded_offset * unit_size
 298                                                 + temp_len * eltlen,
 299                                                 eltlen, byte_order);
 300                   if (val != 0)
 301                     force_ellipses = 1;
 302                 }
 303
 304               len = temp_len;
 305             }
 306
 307           LA_PRINT_STRING (stream, unresolved_elttype,
 308                            valaddr + embedded_offset * unit_size, len,
 309                            NULL, force_ellipses, options);
 310           i = len;
 311         }
 312       else
 313         {
 314           fprintf_filtered (stream, "{");
 315           /* If this is a virtual function table, print the 0th
 316              entry specially, and the rest of the members
 317              normally.  */
 318           if (cp_is_vtbl_ptr_type (elttype))
 319             {
 320               i = 1;
 321               fprintf_filtered (stream, _("%d vtable entries"),
 322                                 len - 1);
 323             }
 324           else
 325             {
 326               i = 0;
 327             }
 328           val_print_array_elements (type, valaddr, embedded_offset,
 329                                     address, stream,
 330                                     recurse, original_value, options, i);
 331           fprintf_filtered (stream, "}");
 332         }
 333     }
 334   else
 335     {
 336       /* Array of unspecified length: treat like pointer to first elt.  */
 337       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 338                               embedded_offset, address + embedded_offset,
 339                               stream, recurse, options);
 340     }
 341 }
 342
 343 /* c_val_print helper for TYPE_CODE_PTR.  */
 344
 345 static void
 346 c_val_print_ptr (struct type *type, const gdb_byte *valaddr,
 347                  int embedded_offset, struct ui_file *stream, int recurse,
 348                  const struct value *original_value,
 349                  const struct value_print_options *options)
 350 {
 351   struct gdbarch *arch = get_type_arch (type);
 352   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 353
 354   if (options->format && options->format != 's')
 355     {
 356       val_print_scalar_formatted (type, valaddr, embedded_offset,
 357                                   original_value, options, 0, stream);
 358     }
 359   else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 360     {
 361       /* Print the unmangled name if desired.  */
 362       /* Print vtable entry - we only get here if we ARE using
 363          -fvtable_thunks.  (Otherwise, look under
 364          TYPE_CODE_STRUCT.)  */
 365       CORE_ADDR addr
 366         = extract_typed_address (valaddr + embedded_offset, type);
 367       struct gdbarch *gdbarch = get_type_arch (type);
 368
 369       print_function_pointer_address (options, gdbarch, addr, stream);
 370     }
 371   else
 372     {
 373       struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 374       struct type *elttype = check_typedef (unresolved_elttype);
 375       CORE_ADDR addr = unpack_pointer (type,
 376                                        valaddr + embedded_offset * unit_size);
 377
 378       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 379                               embedded_offset, addr, stream, recurse, options);
 380     }
 381 }
 382
 383 /* c_val_print helper for TYPE_CODE_STRUCT.  */
 384
 385 static void
 386 c_val_print_struct (struct type *type, const gdb_byte *valaddr,
 387                     int embedded_offset, CORE_ADDR address,
 388                     struct ui_file *stream, int recurse,
 389                     const struct value *original_value,
 390                     const struct value_print_options *options)
 391 {
 392   if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 393     {
 394       /* Print the unmangled name if desired.  */
 395       /* Print vtable entry - we only get here if NOT using
 396          -fvtable_thunks.  (Otherwise, look under
 397          TYPE_CODE_PTR.)  */
 398       struct gdbarch *gdbarch = get_type_arch (type);
 399       int offset = (embedded_offset
 400                     + TYPE_FIELD_BITPOS (type,
 401                                          VTBL_FNADDR_OFFSET) / 8);
 402       struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
 403       CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
 404
 405       print_function_pointer_address (options, gdbarch, addr, stream);
 406     }
 407   else
 408     cp_print_value_fields_rtti (type, valaddr,
 409                                 embedded_offset, address,
 410                                 stream, recurse,
 411                                 original_value, options,
 412                                 NULL, 0);
 413 }
 414
 415 /* c_val_print helper for TYPE_CODE_UNION.  */
 416
 417 static void
 418 c_val_print_union (struct type *type, const gdb_byte *valaddr,
 419                    int embedded_offset, CORE_ADDR address,
 420                    struct ui_file *stream, int recurse,
 421                    const struct value *original_value,
 422                    const struct value_print_options *options)
 423 {
 424   if (recurse && !options->unionprint)
 425     {
 426       fprintf_filtered (stream, "{...}");
 427      }
 428   else
 429     {
 430       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 431                           recurse, original_value, options);
 432     }
 433 }
 434
 435 /* c_val_print helper for TYPE_CODE_INT.  */
 436
 437 static void
 438 c_val_print_int (struct type *type, struct type *unresolved_type,
 439                  const gdb_byte *valaddr, int embedded_offset,
 440                  struct ui_file *stream, const struct value *original_value,
 441                  const struct value_print_options *options)
 442 {
 443   struct gdbarch *arch = get_type_arch (type);
 444   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 445
 446   if (options->format || options->output_format)
 447     {
 448       struct value_print_options opts = *options;
 449
 450       opts.format = (options->format ? options->format
 451                      : options->output_format);
 452       val_print_scalar_formatted (type, valaddr, embedded_offset,
 453                                   original_value, &opts, 0, stream);
 454     }
 455   else
 456     {
 457       val_print_type_code_int (type, valaddr + embedded_offset * unit_size,
 458                                stream);
 459       /* C and C++ has no single byte int type, char is used
 460          instead.  Since we don't know whether the value is really
 461          intended to be used as an integer or a character, print
 462          the character equivalent as well.  */
 463       if (c_textual_element_type (unresolved_type, options->format))
 464         {
 465           fputs_filtered (" ", stream);
 466           LA_PRINT_CHAR (unpack_long (type,
 467                                       valaddr + embedded_offset * unit_size),
 468                          unresolved_type, stream);
 469         }
 470     }
 471 }
 472
 473 /* c_val_print helper for TYPE_CODE_MEMBERPTR.  */
 474
 475 static void
 476 c_val_print_memberptr (struct type *type, const gdb_byte *valaddr,
 477                        int embedded_offset, CORE_ADDR address,
 478                        struct ui_file *stream, int recurse,
 479                        const struct value *original_value,
 480                        const struct value_print_options *options)
 481 {
 482   if (!options->format)
 483     {
 484       cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 485     }
 486   else
 487     {
 488       generic_val_print (type, valaddr, embedded_offset, address, stream,
 489                          recurse, original_value, options, &c_decorations);
 490     }
 491 }
 492
 493 /* See val_print for a description of the various parameters of this
 494    function; they are identical.  */
 495
 496 void
 497 c_val_print (struct type *type, const gdb_byte *valaddr,
 498              int embedded_offset, CORE_ADDR address,
 499              struct ui_file *stream, int recurse,
 500              const struct value *original_value,
 501              const struct value_print_options *options)
 502 {
 503   struct type *unresolved_type = type;
 504
 505   type = check_typedef (type);
 506   switch (TYPE_CODE (type))
 507     {
 508     case TYPE_CODE_ARRAY:
 509       c_val_print_array (type, valaddr, embedded_offset, address, stream,
 510                          recurse, original_value, options);
 511       break;
 512
 513     case TYPE_CODE_METHODPTR:
 514       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 515       break;
 516
 517     case TYPE_CODE_PTR:
 518       c_val_print_ptr (type, valaddr, embedded_offset, stream, recurse,
 519                        original_value, options);
 520       break;
 521
 522     case TYPE_CODE_UNION:
 523       c_val_print_union (type, valaddr, embedded_offset, address, stream,
 524                          recurse, original_value, options);
 525       break;
 526
 527     case TYPE_CODE_STRUCT:
 528       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 529                           recurse, original_value, options);
 530       break;
 531
 532     case TYPE_CODE_INT:
 533       c_val_print_int (type, unresolved_type, valaddr, embedded_offset, stream,
 534                        original_value, options);
 535       break;
 536
 537     case TYPE_CODE_MEMBERPTR:
 538       c_val_print_memberptr (type, valaddr, embedded_offset, address, stream,
 539                              recurse, original_value, options);
 540       break;
 541
 542     case TYPE_CODE_REF:
 543     case TYPE_CODE_ENUM:
 544     case TYPE_CODE_FLAGS:
 545     case TYPE_CODE_FUNC:
 546     case TYPE_CODE_METHOD:
 547     case TYPE_CODE_BOOL:
 548     case TYPE_CODE_RANGE:
 549     case TYPE_CODE_FLT:
 550     case TYPE_CODE_DECFLOAT:
 551     case TYPE_CODE_VOID:
 552     case TYPE_CODE_ERROR:
 553     case TYPE_CODE_UNDEF:
 554     case TYPE_CODE_COMPLEX:
 555     case TYPE_CODE_CHAR:
 556     default:
 557       generic_val_print (type, valaddr, embedded_offset, address,
 558                          stream, recurse, original_value, options,
 559                          &c_decorations);
 560       break;
 561     }
 562   gdb_flush (stream);
 563 }
 564 \f
 565 void
 566 c_value_print (struct value *val, struct ui_file *stream,
 567                const struct value_print_options *options)
 568 {
 569   struct type *type, *real_type, *val_type;
 570   int full, top, using_enc;
 571   struct value_print_options opts = *options;
 572
 573   opts.deref_ref = 1;
 574
 575   /* If it is a pointer, indicate what it points to.
 576
 577      Print type also if it is a reference.
 578
 579      C++: if it is a member pointer, we will take care
 580      of that when we print it.  */
 581
 582   /* Preserve the original type before stripping typedefs.  We prefer
 583      to pass down the original type when possible, but for local
 584      checks it is better to look past the typedefs.  */
 585   val_type = value_type (val);
 586   type = check_typedef (val_type);
 587
 588   if (TYPE_CODE (type) == TYPE_CODE_PTR
 589       || TYPE_CODE (type) == TYPE_CODE_REF)
 590     {
 591       /* Hack:  remove (char *) for char strings.  Their
 592          type is indicated by the quoted string anyway.
 593          (Don't use c_textual_element_type here; quoted strings
 594          are always exactly (char *), (wchar_t *), or the like.  */
 595       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 596           && TYPE_NAME (val_type) == NULL
 597           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 598           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 599                       "char") == 0
 600               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 601         {
 602           /* Print nothing.  */
 603         }
 604       else if (options->objectprint
 605                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 606         {
 607           int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
 608
 609           if (is_ref)
 610             val = value_addr (val);
 611
 612           /* Pointer to class, check real type of object.  */
 613           fprintf_filtered (stream, "(");
 614
 615           if (value_entirely_available (val))
 616             {
 617               real_type = value_rtti_indirect_type (val, &full, &top,
 618                                                     &using_enc);
 619               if (real_type)
 620                 {
 621                   /* RTTI entry found.  */
 622                   type = real_type;
 623
 624                   /* Need to adjust pointer value.  */
 625                   val = value_from_pointer (real_type,
 626                                             value_as_address (val) - top);
 627
 628                   /* Note: When we look up RTTI entries, we don't get
 629                      any information on const or volatile
 630                      attributes.  */
 631                 }
 632             }
 633
 634           if (is_ref)
 635             {
 636               val = value_ref (value_ind (val));
 637               type = value_type (val);
 638             }
 639
 640           type_print (type, "", stream, -1);
 641           fprintf_filtered (stream, ") ");
 642           val_type = type;
 643         }
 644       else
 645         {
 646           /* normal case */
 647           fprintf_filtered (stream, "(");
 648           type_print (value_type (val), "", stream, -1);
 649           fprintf_filtered (stream, ") ");
 650         }
 651     }
 652
 653   if (!value_initialized (val))
 654     fprintf_filtered (stream, " [uninitialized] ");
 655
 656   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 657     {
 658       /* Attempt to determine real type of object.  */
 659       real_type = value_rtti_type (val, &full, &top, &using_enc);
 660       if (real_type)
 661         {
 662           /* We have RTTI information, so use it.  */
 663           val = value_full_object (val, real_type,
 664                                    full, top, using_enc);
 665           fprintf_filtered (stream, "(%s%s) ",
 666                             TYPE_NAME (real_type),
 667                             full ? "" : _(" [incomplete object]"));
 668           /* Print out object: enclosing type is same as real_type if
 669              full.  */
 670           val_print (value_enclosing_type (val),
 671                      value_contents_for_printing (val), 0,
 672                      value_address (val), stream, 0,
 673                      val, &opts, current_language);
 674           return;
 675           /* Note: When we look up RTTI entries, we don't get any
 676              information on const or volatile attributes.  */
 677         }
 678       else if (type != check_typedef (value_enclosing_type (val)))
 679         {
 680           /* No RTTI information, so let's do our best.  */
 681           fprintf_filtered (stream, "(%s ?) ",
 682                             TYPE_NAME (value_enclosing_type (val)));
 683           val_print (value_enclosing_type (val),
 684                      value_contents_for_printing (val), 0,
 685                      value_address (val), stream, 0,
 686                      val, &opts, current_language);
 687           return;
 688         }
 689       /* Otherwise, we end up at the return outside this "if".  */
 690     }
 691
 692   val_print (val_type, value_contents_for_printing (val),
 693              value_embedded_offset (val),
 694              value_address (val),
 695              stream, 0,
 696              val, &opts, current_language);
 697 }