gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2019 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
 201           if (want_space)
 202             fputs_filtered (" ", stream);
 203
 204           if (msymbol.minsym != NULL)
 205             {
 206               const char *search_name
 207                 = MSYMBOL_SEARCH_NAME (msymbol.minsym);
 208               wsym = lookup_symbol_search_name (search_name, NULL,
 209                                                 VAR_DOMAIN).symbol;
 210             }
 211
 212           if (wsym)
 213             {
 214               wtype = SYMBOL_TYPE (wsym);
 215             }
 216           else
 217             {
 218               wtype = unresolved_elttype;
 219             }
 220           vt_val = value_at (wtype, vt_address);
 221           common_val_print (vt_val, stream, recurse + 1, options,
 222                             current_language);
 223           if (options->prettyformat)
 224             {
 225               fprintf_filtered (stream, "\n");
 226               print_spaces_filtered (2 + 2 * recurse, stream);
 227             }
 228         }
 229     }
 230 }
 231
 232 /* c_val_print helper for TYPE_CODE_ARRAY.  */
 233
 234 static void
 235 c_val_print_array (struct type *type, const gdb_byte *valaddr,
 236                    int embedded_offset, CORE_ADDR address,
 237                    struct ui_file *stream, int recurse,
 238                    struct value *original_value,
 239                    const struct value_print_options *options)
 240 {
 241   struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 242   struct type *elttype = check_typedef (unresolved_elttype);
 243   struct gdbarch *arch = get_type_arch (type);
 244   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 245
 246   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 247     {
 248       LONGEST low_bound, high_bound;
 249       int eltlen, len;
 250       enum bfd_endian byte_order = type_byte_order (type);
 251       unsigned int i = 0;       /* Number of characters printed.  */
 252
 253       if (!get_array_bounds (type, &low_bound, &high_bound))
 254         error (_("Could not determine the array high bound"));
 255
 256       eltlen = TYPE_LENGTH (elttype);
 257       len = high_bound - low_bound + 1;
 258       if (options->prettyformat_arrays)
 259         {
 260           print_spaces_filtered (2 + 2 * recurse, stream);
 261         }
 262
 263       /* Print arrays of textual chars with a string syntax, as
 264          long as the entire array is valid.  */
 265       if (c_textual_element_type (unresolved_elttype,
 266                                   options->format)
 267           && value_bytes_available (original_value, embedded_offset,
 268                                     TYPE_LENGTH (type))
 269           && !value_bits_any_optimized_out (original_value,
 270                                             TARGET_CHAR_BIT * embedded_offset,
 271                                             TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 272         {
 273           int force_ellipses = 0;
 274
 275           /* If requested, look for the first null char and only
 276              print elements up to it.  */
 277           if (options->stop_print_at_null)
 278             {
 279               unsigned int temp_len;
 280
 281               for (temp_len = 0;
 282                    (temp_len < len
 283                     && temp_len < options->print_max
 284                     && extract_unsigned_integer (valaddr
 285                                                  + embedded_offset * unit_size
 286                                                  + temp_len * eltlen,
 287                                                  eltlen, byte_order) != 0);
 288                    ++temp_len)
 289                 ;
 290
 291               /* Force LA_PRINT_STRING to print ellipses if
 292                  we've printed the maximum characters and
 293                  the next character is not \000.  */
 294               if (temp_len == options->print_max && temp_len < len)
 295                 {
 296                   ULONGEST val
 297                     = extract_unsigned_integer (valaddr
 298                                                 + embedded_offset * unit_size
 299                                                 + temp_len * eltlen,
 300                                                 eltlen, byte_order);
 301                   if (val != 0)
 302                     force_ellipses = 1;
 303                 }
 304
 305               len = temp_len;
 306             }
 307
 308           LA_PRINT_STRING (stream, unresolved_elttype,
 309                            valaddr + embedded_offset * unit_size, len,
 310                            NULL, force_ellipses, options);
 311           i = len;
 312         }
 313       else
 314         {
 315           fprintf_filtered (stream, "{");
 316           /* If this is a virtual function table, print the 0th
 317              entry specially, and the rest of the members
 318              normally.  */
 319           if (cp_is_vtbl_ptr_type (elttype))
 320             {
 321               i = 1;
 322               fprintf_filtered (stream, _("%d vtable entries"),
 323                                 len - 1);
 324             }
 325           else
 326             {
 327               i = 0;
 328             }
 329           val_print_array_elements (type, embedded_offset,
 330                                     address, stream,
 331                                     recurse, original_value, options, i);
 332           fprintf_filtered (stream, "}");
 333         }
 334     }
 335   else
 336     {
 337       /* Array of unspecified length: treat like pointer to first elt.  */
 338       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 339                               embedded_offset, address + embedded_offset,
 340                               stream, recurse, options);
 341     }
 342 }
 343
 344 /* c_val_print helper for TYPE_CODE_PTR.  */
 345
 346 static void
 347 c_val_print_ptr (struct type *type, const gdb_byte *valaddr,
 348                  int embedded_offset, struct ui_file *stream, int recurse,
 349                  struct value *original_value,
 350                  const struct value_print_options *options)
 351 {
 352   struct gdbarch *arch = get_type_arch (type);
 353   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 354
 355   if (options->format && options->format != 's')
 356     {
 357       val_print_scalar_formatted (type, embedded_offset,
 358                                   original_value, options, 0, stream);
 359     }
 360   else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 361     {
 362       /* Print the unmangled name if desired.  */
 363       /* Print vtable entry - we only get here if we ARE using
 364          -fvtable_thunks.  (Otherwise, look under
 365          TYPE_CODE_STRUCT.)  */
 366       CORE_ADDR addr
 367         = extract_typed_address (valaddr + embedded_offset, type);
 368       struct gdbarch *gdbarch = get_type_arch (type);
 369
 370       print_function_pointer_address (options, gdbarch, addr, stream);
 371     }
 372   else
 373     {
 374       struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 375       struct type *elttype = check_typedef (unresolved_elttype);
 376       CORE_ADDR addr = unpack_pointer (type,
 377                                        valaddr + embedded_offset * unit_size);
 378
 379       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 380                               embedded_offset, addr, stream, recurse, options);
 381     }
 382 }
 383
 384 /* c_val_print helper for TYPE_CODE_STRUCT.  */
 385
 386 static void
 387 c_val_print_struct (struct type *type, const gdb_byte *valaddr,
 388                     int embedded_offset, CORE_ADDR address,
 389                     struct ui_file *stream, int recurse,
 390                     struct value *original_value,
 391                     const struct value_print_options *options)
 392 {
 393   if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 394     {
 395       /* Print the unmangled name if desired.  */
 396       /* Print vtable entry - we only get here if NOT using
 397          -fvtable_thunks.  (Otherwise, look under
 398          TYPE_CODE_PTR.)  */
 399       struct gdbarch *gdbarch = get_type_arch (type);
 400       int offset = (embedded_offset
 401                     + TYPE_FIELD_BITPOS (type,
 402                                          VTBL_FNADDR_OFFSET) / 8);
 403       struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
 404       CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
 405
 406       print_function_pointer_address (options, gdbarch, addr, stream);
 407     }
 408   else
 409     cp_print_value_fields_rtti (type, valaddr,
 410                                 embedded_offset, address,
 411                                 stream, recurse,
 412                                 original_value, options,
 413                                 NULL, 0);
 414 }
 415
 416 /* c_val_print helper for TYPE_CODE_UNION.  */
 417
 418 static void
 419 c_val_print_union (struct type *type, const gdb_byte *valaddr,
 420                    int embedded_offset, CORE_ADDR address,
 421                    struct ui_file *stream, int recurse,
 422                    struct value *original_value,
 423                    const struct value_print_options *options)
 424 {
 425   if (recurse && !options->unionprint)
 426     {
 427       fprintf_filtered (stream, "{...}");
 428      }
 429   else
 430     {
 431       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 432                           recurse, original_value, options);
 433     }
 434 }
 435
 436 /* c_val_print helper for TYPE_CODE_INT.  */
 437
 438 static void
 439 c_val_print_int (struct type *type, struct type *unresolved_type,
 440                  const gdb_byte *valaddr, int embedded_offset,
 441                  struct ui_file *stream, struct value *original_value,
 442                  const struct value_print_options *options)
 443 {
 444   struct gdbarch *arch = get_type_arch (type);
 445   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 446
 447   if (options->format || options->output_format)
 448     {
 449       struct value_print_options opts = *options;
 450
 451       opts.format = (options->format ? options->format
 452                      : options->output_format);
 453       val_print_scalar_formatted (type, embedded_offset,
 454                                   original_value, &opts, 0, stream);
 455     }
 456   else
 457     {
 458       val_print_scalar_formatted (type, embedded_offset,
 459                                   original_value, options, 0, stream);
 460       /* C and C++ has no single byte int type, char is used
 461          instead.  Since we don't know whether the value is really
 462          intended to be used as an integer or a character, print
 463          the character equivalent as well.  */
 464       if (c_textual_element_type (unresolved_type, options->format))
 465         {
 466           fputs_filtered (" ", stream);
 467           LA_PRINT_CHAR (unpack_long (type,
 468                                       valaddr + embedded_offset * unit_size),
 469                          unresolved_type, stream);
 470         }
 471     }
 472 }
 473
 474 /* c_val_print helper for TYPE_CODE_MEMBERPTR.  */
 475
 476 static void
 477 c_val_print_memberptr (struct type *type, const gdb_byte *valaddr,
 478                        int embedded_offset, CORE_ADDR address,
 479                        struct ui_file *stream, int recurse,
 480                        struct value *original_value,
 481                        const struct value_print_options *options)
 482 {
 483   if (!options->format)
 484     {
 485       cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 486     }
 487   else
 488     {
 489       generic_val_print (type, embedded_offset, address, stream,
 490                          recurse, original_value, options, &c_decorations);
 491     }
 492 }
 493
 494 /* See val_print for a description of the various parameters of this
 495    function; they are identical.  */
 496
 497 void
 498 c_val_print (struct type *type,
 499              int embedded_offset, CORE_ADDR address,
 500              struct ui_file *stream, int recurse,
 501              struct value *original_value,
 502              const struct value_print_options *options)
 503 {
 504   struct type *unresolved_type = type;
 505   const gdb_byte *valaddr = value_contents_for_printing (original_value);
 506
 507   type = check_typedef (type);
 508   switch (TYPE_CODE (type))
 509     {
 510     case TYPE_CODE_ARRAY:
 511       c_val_print_array (type, valaddr, embedded_offset, address, stream,
 512                          recurse, original_value, options);
 513       break;
 514
 515     case TYPE_CODE_METHODPTR:
 516       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 517       break;
 518
 519     case TYPE_CODE_PTR:
 520       c_val_print_ptr (type, valaddr, embedded_offset, stream, recurse,
 521                        original_value, options);
 522       break;
 523
 524     case TYPE_CODE_UNION:
 525       c_val_print_union (type, valaddr, embedded_offset, address, stream,
 526                          recurse, original_value, options);
 527       break;
 528
 529     case TYPE_CODE_STRUCT:
 530       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 531                           recurse, original_value, options);
 532       break;
 533
 534     case TYPE_CODE_INT:
 535       c_val_print_int (type, unresolved_type, valaddr, embedded_offset, stream,
 536                        original_value, options);
 537       break;
 538
 539     case TYPE_CODE_MEMBERPTR:
 540       c_val_print_memberptr (type, valaddr, embedded_offset, address, stream,
 541                              recurse, original_value, options);
 542       break;
 543
 544     case TYPE_CODE_REF:
 545     case TYPE_CODE_RVALUE_REF:
 546     case TYPE_CODE_ENUM:
 547     case TYPE_CODE_FLAGS:
 548     case TYPE_CODE_FUNC:
 549     case TYPE_CODE_METHOD:
 550     case TYPE_CODE_BOOL:
 551     case TYPE_CODE_RANGE:
 552     case TYPE_CODE_FLT:
 553     case TYPE_CODE_DECFLOAT:
 554     case TYPE_CODE_VOID:
 555     case TYPE_CODE_ERROR:
 556     case TYPE_CODE_UNDEF:
 557     case TYPE_CODE_COMPLEX:
 558     case TYPE_CODE_CHAR:
 559     default:
 560       generic_val_print (type, embedded_offset, address,
 561                          stream, recurse, original_value, options,
 562                          &c_decorations);
 563       break;
 564     }
 565 }
 566 \f
 567 void
 568 c_value_print (struct value *val, struct ui_file *stream,
 569                const struct value_print_options *options)
 570 {
 571   struct type *type, *real_type, *val_type;
 572   int full, using_enc;
 573   LONGEST top;
 574   struct value_print_options opts = *options;
 575
 576   opts.deref_ref = 1;
 577
 578   /* If it is a pointer, indicate what it points to.
 579
 580      Print type also if it is a reference.
 581
 582      C++: if it is a member pointer, we will take care
 583      of that when we print it.  */
 584
 585   /* Preserve the original type before stripping typedefs.  We prefer
 586      to pass down the original type when possible, but for local
 587      checks it is better to look past the typedefs.  */
 588   val_type = value_type (val);
 589   type = check_typedef (val_type);
 590
 591   if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type))
 592     {
 593       /* Hack:  remove (char *) for char strings.  Their
 594          type is indicated by the quoted string anyway.
 595          (Don't use c_textual_element_type here; quoted strings
 596          are always exactly (char *), (wchar_t *), or the like.  */
 597       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 598           && TYPE_NAME (val_type) == NULL
 599           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 600           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 601                       "char") == 0
 602               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 603         {
 604           /* Print nothing.  */
 605         }
 606       else if (options->objectprint
 607                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 608         {
 609           int is_ref = TYPE_IS_REFERENCE (type);
 610           enum type_code refcode = TYPE_CODE_UNDEF;
 611
 612           if (is_ref)
 613             {
 614               val = value_addr (val);
 615               refcode = TYPE_CODE (type);
 616             }
 617
 618           /* Pointer to class, check real type of object.  */
 619           fprintf_filtered (stream, "(");
 620
 621           if (value_entirely_available (val))
 622             {
 623               real_type = value_rtti_indirect_type (val, &full, &top,
 624                                                     &using_enc);
 625               if (real_type)
 626                 {
 627                   /* RTTI entry found.  */
 628                   type = real_type;
 629
 630                   /* Need to adjust pointer value.  */
 631                   val = value_from_pointer (real_type,
 632                                             value_as_address (val) - top);
 633
 634                   /* Note: When we look up RTTI entries, we don't get
 635                      any information on const or volatile
 636                      attributes.  */
 637                 }
 638             }
 639
 640           if (is_ref)
 641             {
 642               val = value_ref (value_ind (val), refcode);
 643               type = value_type (val);
 644             }
 645
 646           type_print (type, "", stream, -1);
 647           fprintf_filtered (stream, ") ");
 648           val_type = type;
 649         }
 650       else
 651         {
 652           /* normal case */
 653           fprintf_filtered (stream, "(");
 654           type_print (value_type (val), "", stream, -1);
 655           fprintf_filtered (stream, ") ");
 656         }
 657     }
 658
 659   if (!value_initialized (val))
 660     fprintf_filtered (stream, " [uninitialized] ");
 661
 662   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 663     {
 664       /* Attempt to determine real type of object.  */
 665       real_type = value_rtti_type (val, &full, &top, &using_enc);
 666       if (real_type)
 667         {
 668           /* We have RTTI information, so use it.  */
 669           val = value_full_object (val, real_type,
 670                                    full, top, using_enc);
 671           fprintf_filtered (stream, "(%s%s) ",
 672                             TYPE_NAME (real_type),
 673                             full ? "" : _(" [incomplete object]"));
 674           /* Print out object: enclosing type is same as real_type if
 675              full.  */
 676           val_print (value_enclosing_type (val),
 677                      0,
 678                      value_address (val), stream, 0,
 679                      val, &opts, current_language);
 680           return;
 681           /* Note: When we look up RTTI entries, we don't get any
 682              information on const or volatile attributes.  */
 683         }
 684       else if (type != check_typedef (value_enclosing_type (val)))
 685         {
 686           /* No RTTI information, so let's do our best.  */
 687           fprintf_filtered (stream, "(%s ?) ",
 688                             TYPE_NAME (value_enclosing_type (val)));
 689           val_print (value_enclosing_type (val),
 690                      0,
 691                      value_address (val), stream, 0,
 692                      val, &opts, current_language);
 693           return;
 694         }
 695       /* Otherwise, we end up at the return outside this "if".  */
 696     }
 697
 698   val_print (val_type,
 699              value_embedded_offset (val),
 700              value_address (val),
 701              stream, 0,
 702              val, &opts, current_language);
 703 }