gdb/c-valprint.c

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