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