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