gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 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.minsym->print_name (), 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 = msymbol.minsym->search_name ();
 207               wsym = lookup_symbol_search_name (search_name, NULL,
 208                                                 VAR_DOMAIN).symbol;
 209             }
 210
 211           if (wsym)
 212             {
 213               wtype = SYMBOL_TYPE (wsym);
 214             }
 215           else
 216             {
 217               wtype = unresolved_elttype;
 218             }
 219           vt_val = value_at (wtype, vt_address);
 220           common_val_print (vt_val, stream, recurse + 1, options,
 221                             current_language);
 222           if (options->prettyformat)
 223             {
 224               fprintf_filtered (stream, "\n");
 225               print_spaces_filtered (2 + 2 * recurse, stream);
 226             }
 227         }
 228     }
 229 }
 230
 231 /* c_val_print helper for TYPE_CODE_ARRAY.  */
 232
 233 static void
 234 c_val_print_array (struct type *type, const gdb_byte *valaddr,
 235                    int embedded_offset, CORE_ADDR address,
 236                    struct ui_file *stream, int recurse,
 237                    struct value *original_value,
 238                    const struct value_print_options *options)
 239 {
 240   struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 241   struct type *elttype = check_typedef (unresolved_elttype);
 242   struct gdbarch *arch = get_type_arch (type);
 243   int unit_size = gdbarch_addressable_memory_unit_size (arch);
 244
 245   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 246     {
 247       LONGEST low_bound, high_bound;
 248       int eltlen, len;
 249       enum bfd_endian byte_order = type_byte_order (type);
 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, 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                  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, 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                     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                    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, 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, embedded_offset,
 453                                   original_value, &opts, 0, stream);
 454     }
 455   else
 456     {
 457       val_print_scalar_formatted (type, embedded_offset,
 458                                   original_value, options, 0, 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                        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, 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,
 498              int embedded_offset, CORE_ADDR address,
 499              struct ui_file *stream, int recurse,
 500              struct value *original_value,
 501              const struct value_print_options *options)
 502 {
 503   struct type *unresolved_type = type;
 504   const gdb_byte *valaddr = value_contents_for_printing (original_value);
 505
 506   type = check_typedef (type);
 507   switch (TYPE_CODE (type))
 508     {
 509     case TYPE_CODE_ARRAY:
 510       c_val_print_array (type, valaddr, embedded_offset, address, stream,
 511                          recurse, original_value, options);
 512       break;
 513
 514     case TYPE_CODE_METHODPTR:
 515       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 516       break;
 517
 518     case TYPE_CODE_PTR:
 519       c_val_print_ptr (type, valaddr, embedded_offset, stream, recurse,
 520                        original_value, options);
 521       break;
 522
 523     case TYPE_CODE_UNION:
 524       c_val_print_union (type, valaddr, embedded_offset, address, stream,
 525                          recurse, original_value, options);
 526       break;
 527
 528     case TYPE_CODE_STRUCT:
 529       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 530                           recurse, original_value, options);
 531       break;
 532
 533     case TYPE_CODE_INT:
 534       c_val_print_int (type, unresolved_type, valaddr, embedded_offset, stream,
 535                        original_value, options);
 536       break;
 537
 538     case TYPE_CODE_MEMBERPTR:
 539       c_val_print_memberptr (type, valaddr, embedded_offset, address, stream,
 540                              recurse, original_value, options);
 541       break;
 542
 543     case TYPE_CODE_REF:
 544     case TYPE_CODE_RVALUE_REF:
 545     case TYPE_CODE_ENUM:
 546     case TYPE_CODE_FLAGS:
 547     case TYPE_CODE_FUNC:
 548     case TYPE_CODE_METHOD:
 549     case TYPE_CODE_BOOL:
 550     case TYPE_CODE_RANGE:
 551     case TYPE_CODE_FLT:
 552     case TYPE_CODE_DECFLOAT:
 553     case TYPE_CODE_VOID:
 554     case TYPE_CODE_ERROR:
 555     case TYPE_CODE_UNDEF:
 556     case TYPE_CODE_COMPLEX:
 557     case TYPE_CODE_CHAR:
 558     default:
 559       generic_val_print (type, embedded_offset, address,
 560                          stream, recurse, original_value, options,
 561                          &c_decorations);
 562       break;
 563     }
 564 }
 565 \f
 566 void
 567 c_value_print (struct value *val, struct ui_file *stream,
 568                const struct value_print_options *options)
 569 {
 570   struct type *type, *real_type, *val_type;
 571   int full, using_enc;
 572   LONGEST top;
 573   struct value_print_options opts = *options;
 574
 575   opts.deref_ref = 1;
 576
 577   /* If it is a pointer, indicate what it points to.
 578
 579      Print type also if it is a reference.
 580
 581      C++: if it is a member pointer, we will take care
 582      of that when we print it.  */
 583
 584   /* Preserve the original type before stripping typedefs.  We prefer
 585      to pass down the original type when possible, but for local
 586      checks it is better to look past the typedefs.  */
 587   val_type = value_type (val);
 588   type = check_typedef (val_type);
 589
 590   if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (type))
 591     {
 592       /* Hack:  remove (char *) for char strings.  Their
 593          type is indicated by the quoted string anyway.
 594          (Don't use c_textual_element_type here; quoted strings
 595          are always exactly (char *), (wchar_t *), or the like.  */
 596       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 597           && TYPE_NAME (val_type) == NULL
 598           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 599           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 600                       "char") == 0
 601               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 602         {
 603           /* Print nothing.  */
 604         }
 605       else if (options->objectprint
 606                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 607         {
 608           int is_ref = TYPE_IS_REFERENCE (type);
 609           enum type_code refcode = TYPE_CODE_UNDEF;
 610
 611           if (is_ref)
 612             {
 613               val = value_addr (val);
 614               refcode = TYPE_CODE (type);
 615             }
 616
 617           /* Pointer to class, check real type of object.  */
 618           fprintf_filtered (stream, "(");
 619
 620           if (value_entirely_available (val))
 621             {
 622               real_type = value_rtti_indirect_type (val, &full, &top,
 623                                                     &using_enc);
 624               if (real_type)
 625                 {
 626                   /* RTTI entry found.  */
 627                   type = real_type;
 628
 629                   /* Need to adjust pointer value.  */
 630                   val = value_from_pointer (real_type,
 631                                             value_as_address (val) - top);
 632
 633                   /* Note: When we look up RTTI entries, we don't get
 634                      any information on const or volatile
 635                      attributes.  */
 636                 }
 637             }
 638
 639           if (is_ref)
 640             {
 641               val = value_ref (value_ind (val), refcode);
 642               type = value_type (val);
 643             }
 644
 645           type_print (type, "", stream, -1);
 646           fprintf_filtered (stream, ") ");
 647           val_type = type;
 648         }
 649       else
 650         {
 651           /* normal case */
 652           fprintf_filtered (stream, "(");
 653           type_print (value_type (val), "", stream, -1);
 654           fprintf_filtered (stream, ") ");
 655         }
 656     }
 657
 658   if (!value_initialized (val))
 659     fprintf_filtered (stream, " [uninitialized] ");
 660
 661   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 662     {
 663       /* Attempt to determine real type of object.  */
 664       real_type = value_rtti_type (val, &full, &top, &using_enc);
 665       if (real_type)
 666         {
 667           /* We have RTTI information, so use it.  */
 668           val = value_full_object (val, real_type,
 669                                    full, top, using_enc);
 670           fprintf_filtered (stream, "(%s%s) ",
 671                             TYPE_NAME (real_type),
 672                             full ? "" : _(" [incomplete object]"));
 673           /* Print out object: enclosing type is same as real_type if
 674              full.  */
 675           val_print (value_enclosing_type (val),
 676                      0,
 677                      value_address (val), stream, 0,
 678                      val, &opts, current_language);
 679           return;
 680           /* Note: When we look up RTTI entries, we don't get any
 681              information on const or volatile attributes.  */
 682         }
 683       else if (type != check_typedef (value_enclosing_type (val)))
 684         {
 685           /* No RTTI information, so let's do our best.  */
 686           fprintf_filtered (stream, "(%s ?) ",
 687                             TYPE_NAME (value_enclosing_type (val)));
 688           val_print (value_enclosing_type (val),
 689                      0,
 690                      value_address (val), stream, 0,
 691                      val, &opts, current_language);
 692           return;
 693         }
 694       /* Otherwise, we end up at the return outside this "if".  */
 695     }
 696
 697   val_print (val_type,
 698              value_embedded_offset (val),
 699              value_address (val),
 700              stream, 0,
 701              val, &opts, current_language);
 702 }