gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988-1989, 1991-2001, 2003, 2005-2012 Free
   4    Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "valprint.h"
  28 #include "language.h"
  29 #include "c-lang.h"
  30 #include "cp-abi.h"
  31 #include "target.h"
  32 \f
  33
  34 /* Print function pointer with inferior address ADDRESS onto stdio
  35    stream STREAM.  */
  36
  37 static void
  38 print_function_pointer_address (struct gdbarch *gdbarch,
  39                                 CORE_ADDR address,
  40                                 struct ui_file *stream,
  41                                 int addressprint)
  42 {
  43   CORE_ADDR func_addr
  44     = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
  45                                           &current_target);
  46
  47   /* If the function pointer is represented by a description, print
  48      the address of the description.  */
  49   if (addressprint && func_addr != address)
  50     {
  51       fputs_filtered ("@", stream);
  52       fputs_filtered (paddress (gdbarch, address), stream);
  53       fputs_filtered (": ", stream);
  54     }
  55   print_address_demangle (gdbarch, func_addr, stream, demangle);
  56 }
  57
  58
  59 /* A helper for c_textual_element_type.  This checks the name of the
  60    typedef.  This is bogus but it isn't apparent that the compiler
  61    provides us the help we may need.  */
  62
  63 static int
  64 textual_name (const char *name)
  65 {
  66   return (!strcmp (name, "wchar_t")
  67           || !strcmp (name, "char16_t")
  68           || !strcmp (name, "char32_t"));
  69 }
  70
  71 /* Apply a heuristic to decide whether an array of TYPE or a pointer
  72    to TYPE should be printed as a textual string.  Return non-zero if
  73    it should, or zero if it should be treated as an array of integers
  74    or pointer to integers.  FORMAT is the current format letter, or 0
  75    if none.
  76
  77    We guess that "char" is a character.  Explicitly signed and
  78    unsigned character types are also characters.  Integer data from
  79    vector types is not.  The user can override this by using the /s
  80    format letter.  */
  81
  82 int
  83 c_textual_element_type (struct type *type, char format)
  84 {
  85   struct type *true_type, *iter_type;
  86
  87   if (format != 0 && format != 's')
  88     return 0;
  89
  90   /* We also rely on this for its side effect of setting up all the
  91      typedef pointers.  */
  92   true_type = check_typedef (type);
  93
  94   /* TYPE_CODE_CHAR is always textual.  */
  95   if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
  96     return 1;
  97
  98   /* Any other character-like types must be integral.  */
  99   if (TYPE_CODE (true_type) != TYPE_CODE_INT)
 100     return 0;
 101
 102   /* We peel typedefs one by one, looking for a match.  */
 103   iter_type = type;
 104   while (iter_type)
 105     {
 106       /* Check the name of the type.  */
 107       if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
 108         return 1;
 109
 110       if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
 111         break;
 112
 113       /* Peel a single typedef.  If the typedef doesn't have a target
 114          type, we use check_typedef and hope the result is ok -- it
 115          might be for C++, where wchar_t is a built-in type.  */
 116       if (TYPE_TARGET_TYPE (iter_type))
 117         iter_type = TYPE_TARGET_TYPE (iter_type);
 118       else
 119         iter_type = check_typedef (iter_type);
 120     }
 121
 122   if (format == 's')
 123     {
 124       /* Print this as a string if we can manage it.  For now, no wide
 125          character support.  */
 126       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 127           && TYPE_LENGTH (true_type) == 1)
 128         return 1;
 129     }
 130   else
 131     {
 132       /* If a one-byte TYPE_CODE_INT is missing the not-a-character
 133          flag, then we treat it as text; otherwise, we assume it's
 134          being used as data.  */
 135       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 136           && TYPE_LENGTH (true_type) == 1
 137           && !TYPE_NOTTEXT (true_type))
 138         return 1;
 139     }
 140
 141   return 0;
 142 }
 143
 144 /* See val_print for a description of the various parameters of this
 145    function; they are identical.  The semantics of the return value is
 146    also identical to val_print.  */
 147
 148 int
 149 c_val_print (struct type *type, const gdb_byte *valaddr,
 150              int embedded_offset, CORE_ADDR address,
 151              struct ui_file *stream, int recurse,
 152              const struct value *original_value,
 153              const struct value_print_options *options)
 154 {
 155   struct gdbarch *gdbarch = get_type_arch (type);
 156   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 157   unsigned int i = 0;   /* Number of characters printed.  */
 158   unsigned len;
 159   struct type *elttype, *unresolved_elttype;
 160   struct type *unresolved_type = type;
 161   unsigned eltlen;
 162   LONGEST val;
 163   CORE_ADDR addr;
 164
 165   CHECK_TYPEDEF (type);
 166   switch (TYPE_CODE (type))
 167     {
 168     case TYPE_CODE_ARRAY:
 169       unresolved_elttype = TYPE_TARGET_TYPE (type);
 170       elttype = check_typedef (unresolved_elttype);
 171       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 172         {
 173           LONGEST low_bound, high_bound;
 174
 175           if (!get_array_bounds (type, &low_bound, &high_bound))
 176             error (_("Could not determine the array high bound"));
 177
 178           eltlen = TYPE_LENGTH (elttype);
 179           len = high_bound - low_bound + 1;
 180           if (options->prettyprint_arrays)
 181             {
 182               print_spaces_filtered (2 + 2 * recurse, stream);
 183             }
 184
 185           /* Print arrays of textual chars with a string syntax, as
 186              long as the entire array is valid.  */
 187           if (c_textual_element_type (unresolved_elttype,
 188                                       options->format)
 189               && value_bytes_available (original_value, embedded_offset,
 190                                         TYPE_LENGTH (type))
 191               && value_bits_valid (original_value,
 192                                    TARGET_CHAR_BIT * embedded_offset,
 193                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 194             {
 195               /* If requested, look for the first null char and only
 196                  print elements up to it.  */
 197               if (options->stop_print_at_null)
 198                 {
 199                   unsigned int temp_len;
 200
 201                   for (temp_len = 0;
 202                        (temp_len < len
 203                         && temp_len < options->print_max
 204                         && extract_unsigned_integer (valaddr + embedded_offset
 205                                                      + temp_len * eltlen,
 206                                                      eltlen, byte_order) != 0);
 207                        ++temp_len)
 208                     ;
 209                   len = temp_len;
 210                 }
 211
 212               LA_PRINT_STRING (stream, unresolved_elttype,
 213                                valaddr + embedded_offset, len,
 214                                NULL, 0, options);
 215               i = len;
 216             }
 217           else
 218             {
 219               fprintf_filtered (stream, "{");
 220               /* If this is a virtual function table, print the 0th
 221                  entry specially, and the rest of the members
 222                  normally.  */
 223               if (cp_is_vtbl_ptr_type (elttype))
 224                 {
 225                   i = 1;
 226                   fprintf_filtered (stream, _("%d vtable entries"),
 227                                     len - 1);
 228                 }
 229               else
 230                 {
 231                   i = 0;
 232                 }
 233               val_print_array_elements (type, valaddr, embedded_offset,
 234                                         address, stream,
 235                                         recurse, original_value, options, i);
 236               fprintf_filtered (stream, "}");
 237             }
 238           break;
 239         }
 240       /* Array of unspecified length: treat like pointer to first
 241          elt.  */
 242       addr = address + embedded_offset;
 243       goto print_unpacked_pointer;
 244
 245     case TYPE_CODE_MEMBERPTR:
 246       if (options->format)
 247         {
 248           val_print_scalar_formatted (type, valaddr, embedded_offset,
 249                                       original_value, options, 0, stream);
 250           break;
 251         }
 252       cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 253       break;
 254
 255     case TYPE_CODE_METHODPTR:
 256       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 257       break;
 258
 259     case TYPE_CODE_PTR:
 260       if (options->format && options->format != 's')
 261         {
 262           val_print_scalar_formatted (type, valaddr, embedded_offset,
 263                                       original_value, options, 0, stream);
 264           break;
 265         }
 266       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 267         {
 268           /* Print the unmangled name if desired.  */
 269           /* Print vtable entry - we only get here if we ARE using
 270              -fvtable_thunks.  (Otherwise, look under
 271              TYPE_CODE_STRUCT.)  */
 272           CORE_ADDR addr
 273             = extract_typed_address (valaddr + embedded_offset, type);
 274
 275           print_function_pointer_address (gdbarch, addr, stream,
 276                                           options->addressprint);
 277           break;
 278         }
 279       unresolved_elttype = TYPE_TARGET_TYPE (type);
 280       elttype = check_typedef (unresolved_elttype);
 281         {
 282           addr = unpack_pointer (type, valaddr + embedded_offset);
 283         print_unpacked_pointer:
 284
 285           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 286             {
 287               /* Try to print what function it points to.  */
 288               print_function_pointer_address (gdbarch, addr, stream,
 289                                               options->addressprint);
 290               /* Return value is irrelevant except for string
 291                  pointers.  */
 292               return (0);
 293             }
 294
 295           if (options->addressprint)
 296             fputs_filtered (paddress (gdbarch, addr), stream);
 297
 298           /* For a pointer to a textual type, also print the string
 299              pointed to, unless pointer is null.  */
 300
 301           if (c_textual_element_type (unresolved_elttype,
 302                                       options->format)
 303               && addr != 0)
 304             {
 305               i = val_print_string (unresolved_elttype, NULL,
 306                                     addr, -1,
 307                                     stream, options);
 308             }
 309           else if (cp_is_vtbl_member (type))
 310             {
 311               /* Print vtbl's nicely.  */
 312               CORE_ADDR vt_address = unpack_pointer (type,
 313                                                      valaddr
 314                                                      + embedded_offset);
 315
 316               struct minimal_symbol *msymbol =
 317               lookup_minimal_symbol_by_pc (vt_address);
 318               if ((msymbol != NULL)
 319                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 320                 {
 321                   fputs_filtered (" <", stream);
 322                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 323                   fputs_filtered (">", stream);
 324                 }
 325               if (vt_address && options->vtblprint)
 326                 {
 327                   struct value *vt_val;
 328                   struct symbol *wsym = (struct symbol *) NULL;
 329                   struct type *wtype;
 330                   struct block *block = (struct block *) NULL;
 331                   int is_this_fld;
 332
 333                   if (msymbol != NULL)
 334                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 335                                           block, VAR_DOMAIN,
 336                                           &is_this_fld);
 337
 338                   if (wsym)
 339                     {
 340                       wtype = SYMBOL_TYPE (wsym);
 341                     }
 342                   else
 343                     {
 344                       wtype = unresolved_elttype;
 345                     }
 346                   vt_val = value_at (wtype, vt_address);
 347                   common_val_print (vt_val, stream, recurse + 1,
 348                                     options, current_language);
 349                   if (options->pretty)
 350                     {
 351                       fprintf_filtered (stream, "\n");
 352                       print_spaces_filtered (2 + 2 * recurse, stream);
 353                     }
 354                 }
 355             }
 356
 357           /* Return number of characters printed, including the
 358              terminating '\0' if we reached the end.  val_print_string
 359              takes care including the terminating '\0' if
 360              necessary.  */
 361           return i;
 362         }
 363       break;
 364
 365     case TYPE_CODE_REF:
 366       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 367       if (options->addressprint)
 368         {
 369           CORE_ADDR addr
 370             = extract_typed_address (valaddr + embedded_offset, type);
 371
 372           fprintf_filtered (stream, "@");
 373           fputs_filtered (paddress (gdbarch, addr), stream);
 374           if (options->deref_ref)
 375             fputs_filtered (": ", stream);
 376         }
 377       /* De-reference the reference.  */
 378       if (options->deref_ref)
 379         {
 380           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 381             {
 382               struct value *deref_val;
 383
 384               deref_val = coerce_ref_if_computed (original_value);
 385               if (deref_val != NULL)
 386                 {
 387                   /* More complicated computed references are not supported.  */
 388                   gdb_assert (embedded_offset == 0);
 389                 }
 390               else
 391                 deref_val = value_at (TYPE_TARGET_TYPE (type),
 392                                       unpack_pointer (type,
 393                                                       (valaddr
 394                                                        + embedded_offset)));
 395
 396               common_val_print (deref_val, stream, recurse, options,
 397                                 current_language);
 398             }
 399           else
 400             fputs_filtered ("???", stream);
 401         }
 402       break;
 403
 404     case TYPE_CODE_UNION:
 405       if (recurse && !options->unionprint)
 406         {
 407           fprintf_filtered (stream, "{...}");
 408           break;
 409         }
 410       /* Fall through.  */
 411     case TYPE_CODE_STRUCT:
 412       /*FIXME: Abstract this away.  */
 413       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 414         {
 415           /* Print the unmangled name if desired.  */
 416           /* Print vtable entry - we only get here if NOT using
 417              -fvtable_thunks.  (Otherwise, look under
 418              TYPE_CODE_PTR.)  */
 419           int offset = (embedded_offset
 420                         + TYPE_FIELD_BITPOS (type,
 421                                              VTBL_FNADDR_OFFSET) / 8);
 422           struct type *field_type = TYPE_FIELD_TYPE (type,
 423                                                      VTBL_FNADDR_OFFSET);
 424           CORE_ADDR addr
 425             = extract_typed_address (valaddr + offset, field_type);
 426
 427           print_function_pointer_address (gdbarch, addr, stream,
 428                                           options->addressprint);
 429         }
 430       else
 431         cp_print_value_fields_rtti (type, valaddr,
 432                                     embedded_offset, address,
 433                                     stream, recurse,
 434                                     original_value, options,
 435                                     NULL, 0);
 436       break;
 437
 438     case TYPE_CODE_ENUM:
 439       if (options->format)
 440         {
 441           val_print_scalar_formatted (type, valaddr, embedded_offset,
 442                                       original_value, options, 0, stream);
 443           break;
 444         }
 445       len = TYPE_NFIELDS (type);
 446       val = unpack_long (type, valaddr + embedded_offset);
 447       for (i = 0; i < len; i++)
 448         {
 449           QUIT;
 450           if (val == TYPE_FIELD_BITPOS (type, i))
 451             {
 452               break;
 453             }
 454         }
 455       if (i < len)
 456         {
 457           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 458         }
 459       else if (TYPE_FLAG_ENUM (type))
 460         {
 461           int first = 1;
 462
 463           /* We have a "flag" enum, so we try to decompose it into
 464              pieces as appropriate.  A flag enum has disjoint
 465              constants by definition.  */
 466           fputs_filtered ("(", stream);
 467           for (i = 0; i < len; ++i)
 468             {
 469               QUIT;
 470
 471               if ((val & TYPE_FIELD_BITPOS (type, i)) != 0)
 472                 {
 473                   if (!first)
 474                     fputs_filtered (" | ", stream);
 475                   first = 0;
 476
 477                   val &= ~TYPE_FIELD_BITPOS (type, i);
 478                   fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 479                 }
 480             }
 481
 482           if (first || val != 0)
 483             {
 484               if (!first)
 485                 fputs_filtered (" | ", stream);
 486               fputs_filtered ("unknown: ", stream);
 487               print_longest (stream, 'd', 0, val);
 488             }
 489
 490           fputs_filtered (")", stream);
 491         }
 492       else
 493         print_longest (stream, 'd', 0, val);
 494       break;
 495
 496     case TYPE_CODE_FLAGS:
 497       if (options->format)
 498         val_print_scalar_formatted (type, valaddr, embedded_offset,
 499                                     original_value, options, 0, stream);
 500       else
 501         val_print_type_code_flags (type, valaddr + embedded_offset,
 502                                    stream);
 503       break;
 504
 505     case TYPE_CODE_FUNC:
 506     case TYPE_CODE_METHOD:
 507       if (options->format)
 508         {
 509           val_print_scalar_formatted (type, valaddr, embedded_offset,
 510                                       original_value, options, 0, stream);
 511           break;
 512         }
 513       /* FIXME, we should consider, at least for ANSI C language,
 514          eliminating the distinction made between FUNCs and POINTERs
 515          to FUNCs.  */
 516       fprintf_filtered (stream, "{");
 517       type_print (type, "", stream, -1);
 518       fprintf_filtered (stream, "} ");
 519       /* Try to print what function it points to, and its address.  */
 520       print_address_demangle (gdbarch, address, stream, demangle);
 521       break;
 522
 523     case TYPE_CODE_BOOL:
 524       if (options->format || options->output_format)
 525         {
 526           struct value_print_options opts = *options;
 527           opts.format = (options->format ? options->format
 528                          : options->output_format);
 529           val_print_scalar_formatted (type, valaddr, embedded_offset,
 530                                       original_value, &opts, 0, stream);
 531         }
 532       else
 533         {
 534           val = unpack_long (type, valaddr + embedded_offset);
 535           if (val == 0)
 536             fputs_filtered ("false", stream);
 537           else if (val == 1)
 538             fputs_filtered ("true", stream);
 539           else
 540             print_longest (stream, 'd', 0, val);
 541         }
 542       break;
 543
 544     case TYPE_CODE_RANGE:
 545       /* FIXME: create_range_type does not set the unsigned bit in a
 546          range type (I think it probably should copy it from the
 547          target type), so we won't print values which are too large to
 548          fit in a signed integer correctly.  */
 549       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 550          print with the target type, though, because the size of our
 551          type and the target type might differ).  */
 552       /* FALLTHROUGH */
 553
 554     case TYPE_CODE_INT:
 555       if (options->format || options->output_format)
 556         {
 557           struct value_print_options opts = *options;
 558
 559           opts.format = (options->format ? options->format
 560                          : options->output_format);
 561           val_print_scalar_formatted (type, valaddr, embedded_offset,
 562                                       original_value, &opts, 0, stream);
 563         }
 564       else
 565         {
 566           val_print_type_code_int (type, valaddr + embedded_offset,
 567                                    stream);
 568           /* C and C++ has no single byte int type, char is used
 569              instead.  Since we don't know whether the value is really
 570              intended to be used as an integer or a character, print
 571              the character equivalent as well.  */
 572           if (c_textual_element_type (unresolved_type, options->format))
 573             {
 574               fputs_filtered (" ", stream);
 575               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 576                              unresolved_type, stream);
 577             }
 578         }
 579       break;
 580
 581     case TYPE_CODE_CHAR:
 582       if (options->format || options->output_format)
 583         {
 584           struct value_print_options opts = *options;
 585           opts.format = (options->format ? options->format
 586                          : options->output_format);
 587           val_print_scalar_formatted (type, valaddr, embedded_offset,
 588                                       original_value, &opts, 0, stream);
 589         }
 590       else
 591         {
 592           val = unpack_long (type, valaddr + embedded_offset);
 593           if (TYPE_UNSIGNED (type))
 594             fprintf_filtered (stream, "%u", (unsigned int) val);
 595           else
 596             fprintf_filtered (stream, "%d", (int) val);
 597           fputs_filtered (" ", stream);
 598           LA_PRINT_CHAR (val, unresolved_type, stream);
 599         }
 600       break;
 601
 602     case TYPE_CODE_FLT:
 603       if (options->format)
 604         {
 605           val_print_scalar_formatted (type, valaddr, embedded_offset,
 606                                       original_value, options, 0, stream);
 607         }
 608       else
 609         {
 610           print_floating (valaddr + embedded_offset, type, stream);
 611         }
 612       break;
 613
 614     case TYPE_CODE_DECFLOAT:
 615       if (options->format)
 616         val_print_scalar_formatted (type, valaddr, embedded_offset,
 617                                     original_value, options, 0, stream);
 618       else
 619         print_decimal_floating (valaddr + embedded_offset,
 620                                 type, stream);
 621       break;
 622
 623     case TYPE_CODE_VOID:
 624       fprintf_filtered (stream, "void");
 625       break;
 626
 627     case TYPE_CODE_ERROR:
 628       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 629       break;
 630
 631     case TYPE_CODE_UNDEF:
 632       /* This happens (without TYPE_FLAG_STUB set) on systems which
 633          don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
 634          "struct foo *bar" and no complete type for struct foo in that
 635          file.  */
 636       fprintf_filtered (stream, _("<incomplete type>"));
 637       break;
 638
 639     case TYPE_CODE_COMPLEX:
 640       if (options->format)
 641         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 642                                     valaddr, embedded_offset,
 643                                     original_value, options, 0, stream);
 644       else
 645         print_floating (valaddr + embedded_offset,
 646                         TYPE_TARGET_TYPE (type),
 647                         stream);
 648       fprintf_filtered (stream, " + ");
 649       if (options->format)
 650         val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
 651                                     valaddr,
 652                                     embedded_offset
 653                                     + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 654                                     original_value,
 655                                     options, 0, stream);
 656       else
 657         print_floating (valaddr + embedded_offset
 658                         + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 659                         TYPE_TARGET_TYPE (type),
 660                         stream);
 661       fprintf_filtered (stream, " * I");
 662       break;
 663
 664     default:
 665       error (_("Invalid C/C++ type code %d in symbol table."),
 666              TYPE_CODE (type));
 667     }
 668   gdb_flush (stream);
 669   return (0);
 670 }
 671 \f
 672 int
 673 c_value_print (struct value *val, struct ui_file *stream,
 674                const struct value_print_options *options)
 675 {
 676   struct type *type, *real_type, *val_type;
 677   int full, top, using_enc;
 678   struct value_print_options opts = *options;
 679
 680   opts.deref_ref = 1;
 681
 682   /* If it is a pointer, indicate what it points to.
 683
 684      Print type also if it is a reference.
 685
 686      C++: if it is a member pointer, we will take care
 687      of that when we print it.  */
 688
 689   /* Preserve the original type before stripping typedefs.  We prefer
 690      to pass down the original type when possible, but for local
 691      checks it is better to look past the typedefs.  */
 692   val_type = value_type (val);
 693   type = check_typedef (val_type);
 694
 695   if (TYPE_CODE (type) == TYPE_CODE_PTR
 696       || TYPE_CODE (type) == TYPE_CODE_REF)
 697     {
 698       /* Hack:  remove (char *) for char strings.  Their
 699          type is indicated by the quoted string anyway.
 700          (Don't use c_textual_element_type here; quoted strings
 701          are always exactly (char *), (wchar_t *), or the like.  */
 702       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 703           && TYPE_NAME (val_type) == NULL
 704           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 705           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 706                       "char") == 0
 707               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 708         {
 709           /* Print nothing.  */
 710         }
 711       else if (options->objectprint
 712                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 713         {
 714
 715           if (TYPE_CODE(type) == TYPE_CODE_REF)
 716             {
 717               /* Copy value, change to pointer, so we don't get an
 718                  error about a non-pointer type in
 719                  value_rtti_target_type.  */
 720               struct value *temparg;
 721               temparg=value_copy(val);
 722               deprecated_set_value_type
 723                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 724               val = temparg;
 725             }
 726           /* Pointer to class, check real type of object.  */
 727           fprintf_filtered (stream, "(");
 728
 729           if (value_entirely_available (val))
 730             {
 731               real_type = value_rtti_target_type (val, &full, &top, &using_enc);
 732               if (real_type)
 733                 {
 734                   /* RTTI entry found.  */
 735                   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 736                     {
 737                       /* Create a pointer type pointing to the real
 738                          type.  */
 739                       type = lookup_pointer_type (real_type);
 740                     }
 741                   else
 742                     {
 743                       /* Create a reference type referencing the real
 744                          type.  */
 745                       type = lookup_reference_type (real_type);
 746                     }
 747                   /* Need to adjust pointer value.  */
 748                   val = value_from_pointer (type, value_as_address (val) - top);
 749
 750                   /* Note: When we look up RTTI entries, we don't get
 751                      any information on const or volatile
 752                      attributes.  */
 753                 }
 754             }
 755           type_print (type, "", stream, -1);
 756           fprintf_filtered (stream, ") ");
 757           val_type = type;
 758         }
 759       else
 760         {
 761           /* normal case */
 762           fprintf_filtered (stream, "(");
 763           type_print (value_type (val), "", stream, -1);
 764           fprintf_filtered (stream, ") ");
 765         }
 766     }
 767
 768   if (!value_initialized (val))
 769     fprintf_filtered (stream, " [uninitialized] ");
 770
 771   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 772     {
 773       /* Attempt to determine real type of object.  */
 774       real_type = value_rtti_type (val, &full, &top, &using_enc);
 775       if (real_type)
 776         {
 777           /* We have RTTI information, so use it.  */
 778           val = value_full_object (val, real_type,
 779                                    full, top, using_enc);
 780           fprintf_filtered (stream, "(%s%s) ",
 781                             TYPE_NAME (real_type),
 782                             full ? "" : _(" [incomplete object]"));
 783           /* Print out object: enclosing type is same as real_type if
 784              full.  */
 785           return val_print (value_enclosing_type (val),
 786                             value_contents_for_printing (val), 0,
 787                             value_address (val), stream, 0,
 788                             val, &opts, current_language);
 789           /* Note: When we look up RTTI entries, we don't get any
 790              information on const or volatile attributes.  */
 791         }
 792       else if (type != check_typedef (value_enclosing_type (val)))
 793         {
 794           /* No RTTI information, so let's do our best.  */
 795           fprintf_filtered (stream, "(%s ?) ",
 796                             TYPE_NAME (value_enclosing_type (val)));
 797           return val_print (value_enclosing_type (val),
 798                             value_contents_for_printing (val), 0,
 799                             value_address (val), stream, 0,
 800                             val, &opts, current_language);
 801         }
 802       /* Otherwise, we end up at the return outside this "if".  */
 803     }
 804
 805   return val_print (val_type, value_contents_for_printing (val),
 806                     value_embedded_offset (val),
 807                     value_address (val),
 808                     stream, 0,
 809                     val, &opts, current_language);
 810 }