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