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 /* A helper for c_textual_element_type.  This checks the name of the
  35    typedef.  This is bogus but it isn't apparent that the compiler
  36    provides us the help we may need.  */
  37
  38 static int
  39 textual_name (const char *name)
  40 {
  41   return (!strcmp (name, "wchar_t")
  42           || !strcmp (name, "char16_t")
  43           || !strcmp (name, "char32_t"));
  44 }
  45
  46 /* Apply a heuristic to decide whether an array of TYPE or a pointer
  47    to TYPE should be printed as a textual string.  Return non-zero if
  48    it should, or zero if it should be treated as an array of integers
  49    or pointer to integers.  FORMAT is the current format letter, or 0
  50    if none.
  51
  52    We guess that "char" is a character.  Explicitly signed and
  53    unsigned character types are also characters.  Integer data from
  54    vector types is not.  The user can override this by using the /s
  55    format letter.  */
  56
  57 int
  58 c_textual_element_type (struct type *type, char format)
  59 {
  60   struct type *true_type, *iter_type;
  61
  62   if (format != 0 && format != 's')
  63     return 0;
  64
  65   /* We also rely on this for its side effect of setting up all the
  66      typedef pointers.  */
  67   true_type = check_typedef (type);
  68
  69   /* TYPE_CODE_CHAR is always textual.  */
  70   if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
  71     return 1;
  72
  73   /* Any other character-like types must be integral.  */
  74   if (TYPE_CODE (true_type) != TYPE_CODE_INT)
  75     return 0;
  76
  77   /* We peel typedefs one by one, looking for a match.  */
  78   iter_type = type;
  79   while (iter_type)
  80     {
  81       /* Check the name of the type.  */
  82       if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
  83         return 1;
  84
  85       if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
  86         break;
  87
  88       /* Peel a single typedef.  If the typedef doesn't have a target
  89          type, we use check_typedef and hope the result is ok -- it
  90          might be for C++, where wchar_t is a built-in type.  */
  91       if (TYPE_TARGET_TYPE (iter_type))
  92         iter_type = TYPE_TARGET_TYPE (iter_type);
  93       else
  94         iter_type = check_typedef (iter_type);
  95     }
  96
  97   if (format == 's')
  98     {
  99       /* Print this as a string if we can manage it.  For now, no wide
 100          character support.  */
 101       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 102           && TYPE_LENGTH (true_type) == 1)
 103         return 1;
 104     }
 105   else
 106     {
 107       /* If a one-byte TYPE_CODE_INT is missing the not-a-character
 108          flag, then we treat it as text; otherwise, we assume it's
 109          being used as data.  */
 110       if (TYPE_CODE (true_type) == TYPE_CODE_INT
 111           && TYPE_LENGTH (true_type) == 1
 112           && !TYPE_NOTTEXT (true_type))
 113         return 1;
 114     }
 115
 116   return 0;
 117 }
 118
 119 /* Decorations for C.  */
 120
 121 static const struct generic_val_print_decorations c_decorations =
 122 {
 123   "",
 124   " + ",
 125   " * I",
 126   "true",
 127   "false",
 128   "void"
 129 };
 130
 131 /* See val_print for a description of the various parameters of this
 132    function; they are identical.  */
 133
 134 void
 135 c_val_print (struct type *type, const gdb_byte *valaddr,
 136              int embedded_offset, CORE_ADDR address,
 137              struct ui_file *stream, int recurse,
 138              const struct value *original_value,
 139              const struct value_print_options *options)
 140 {
 141   struct gdbarch *gdbarch = get_type_arch (type);
 142   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 143   unsigned int i = 0;   /* Number of characters printed.  */
 144   unsigned len;
 145   struct type *elttype, *unresolved_elttype;
 146   struct type *unresolved_type = type;
 147   unsigned eltlen;
 148   LONGEST val;
 149   CORE_ADDR addr;
 150
 151   CHECK_TYPEDEF (type);
 152   switch (TYPE_CODE (type))
 153     {
 154     case TYPE_CODE_ARRAY:
 155       unresolved_elttype = TYPE_TARGET_TYPE (type);
 156       elttype = check_typedef (unresolved_elttype);
 157       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 158         {
 159           LONGEST low_bound, high_bound;
 160
 161           if (!get_array_bounds (type, &low_bound, &high_bound))
 162             error (_("Could not determine the array high bound"));
 163
 164           eltlen = TYPE_LENGTH (elttype);
 165           len = high_bound - low_bound + 1;
 166           if (options->prettyprint_arrays)
 167             {
 168               print_spaces_filtered (2 + 2 * recurse, stream);
 169             }
 170
 171           /* Print arrays of textual chars with a string syntax, as
 172              long as the entire array is valid.  */
 173           if (c_textual_element_type (unresolved_elttype,
 174                                       options->format)
 175               && value_bytes_available (original_value, embedded_offset,
 176                                         TYPE_LENGTH (type))
 177               && value_bits_valid (original_value,
 178                                    TARGET_CHAR_BIT * embedded_offset,
 179                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 180             {
 181               /* If requested, look for the first null char and only
 182                  print elements up to it.  */
 183               if (options->stop_print_at_null)
 184                 {
 185                   unsigned int temp_len;
 186
 187                   for (temp_len = 0;
 188                        (temp_len < len
 189                         && temp_len < options->print_max
 190                         && extract_unsigned_integer (valaddr + embedded_offset
 191                                                      + temp_len * eltlen,
 192                                                      eltlen, byte_order) != 0);
 193                        ++temp_len)
 194                     ;
 195                   len = temp_len;
 196                 }
 197
 198               LA_PRINT_STRING (stream, unresolved_elttype,
 199                                valaddr + embedded_offset, len,
 200                                NULL, 0, options);
 201               i = len;
 202             }
 203           else
 204             {
 205               fprintf_filtered (stream, "{");
 206               /* If this is a virtual function table, print the 0th
 207                  entry specially, and the rest of the members
 208                  normally.  */
 209               if (cp_is_vtbl_ptr_type (elttype))
 210                 {
 211                   i = 1;
 212                   fprintf_filtered (stream, _("%d vtable entries"),
 213                                     len - 1);
 214                 }
 215               else
 216                 {
 217                   i = 0;
 218                 }
 219               val_print_array_elements (type, valaddr, embedded_offset,
 220                                         address, stream,
 221                                         recurse, original_value, options, i);
 222               fprintf_filtered (stream, "}");
 223             }
 224           break;
 225         }
 226       /* Array of unspecified length: treat like pointer to first
 227          elt.  */
 228       addr = address + embedded_offset;
 229       goto print_unpacked_pointer;
 230
 231     case TYPE_CODE_METHODPTR:
 232       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 233       break;
 234
 235     case TYPE_CODE_PTR:
 236       if (options->format && options->format != 's')
 237         {
 238           val_print_scalar_formatted (type, valaddr, embedded_offset,
 239                                       original_value, options, 0, stream);
 240           break;
 241         }
 242       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 243         {
 244           /* Print the unmangled name if desired.  */
 245           /* Print vtable entry - we only get here if we ARE using
 246              -fvtable_thunks.  (Otherwise, look under
 247              TYPE_CODE_STRUCT.)  */
 248           CORE_ADDR addr
 249             = extract_typed_address (valaddr + embedded_offset, type);
 250
 251           print_function_pointer_address (options, gdbarch, addr, stream);
 252           break;
 253         }
 254       unresolved_elttype = TYPE_TARGET_TYPE (type);
 255       elttype = check_typedef (unresolved_elttype);
 256         {
 257           int want_space;
 258
 259           addr = unpack_pointer (type, valaddr + embedded_offset);
 260         print_unpacked_pointer:
 261
 262           want_space = 0;
 263
 264           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 265             {
 266               /* Try to print what function it points to.  */
 267               print_function_pointer_address (options, gdbarch, addr, stream);
 268               return;
 269             }
 270
 271           if (options->symbol_print)
 272             want_space = print_address_demangle (options, gdbarch, addr,
 273                                                  stream, demangle);
 274           else if (options->addressprint)
 275             {
 276               fputs_filtered (paddress (gdbarch, addr), stream);
 277               want_space = 1;
 278             }
 279
 280           /* For a pointer to a textual type, also print the string
 281              pointed to, unless pointer is null.  */
 282
 283           if (c_textual_element_type (unresolved_elttype,
 284                                       options->format)
 285               && addr != 0)
 286             {
 287               if (want_space)
 288                 fputs_filtered (" ", stream);
 289               i = val_print_string (unresolved_elttype, NULL,
 290                                     addr, -1,
 291                                     stream, options);
 292             }
 293           else if (cp_is_vtbl_member (type))
 294             {
 295               /* Print vtbl's nicely.  */
 296               CORE_ADDR vt_address = unpack_pointer (type,
 297                                                      valaddr
 298                                                      + embedded_offset);
 299               struct minimal_symbol *msymbol =
 300               lookup_minimal_symbol_by_pc (vt_address);
 301
 302               /* If 'symbol_print' is set, we did the work above.  */
 303               if (!options->symbol_print
 304                   && (msymbol != NULL)
 305                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 306                 {
 307                   if (want_space)
 308                     fputs_filtered (" ", stream);
 309                   fputs_filtered (" <", stream);
 310                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 311                   fputs_filtered (">", stream);
 312                   want_space = 1;
 313                 }
 314
 315               if (vt_address && options->vtblprint)
 316                 {
 317                   struct value *vt_val;
 318                   struct symbol *wsym = (struct symbol *) NULL;
 319                   struct type *wtype;
 320                   struct block *block = (struct block *) NULL;
 321                   int is_this_fld;
 322
 323                   if (want_space)
 324                     fputs_filtered (" ", stream);
 325
 326                   if (msymbol != NULL)
 327                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 328                                           block, VAR_DOMAIN,
 329                                           &is_this_fld);
 330
 331                   if (wsym)
 332                     {
 333                       wtype = SYMBOL_TYPE (wsym);
 334                     }
 335                   else
 336                     {
 337                       wtype = unresolved_elttype;
 338                     }
 339                   vt_val = value_at (wtype, vt_address);
 340                   common_val_print (vt_val, stream, recurse + 1,
 341                                     options, current_language);
 342                   if (options->pretty)
 343                     {
 344                       fprintf_filtered (stream, "\n");
 345                       print_spaces_filtered (2 + 2 * recurse, stream);
 346                     }
 347                 }
 348             }
 349           return;
 350         }
 351       break;
 352
 353     case TYPE_CODE_UNION:
 354       if (recurse && !options->unionprint)
 355         {
 356           fprintf_filtered (stream, "{...}");
 357           break;
 358         }
 359       /* Fall through.  */
 360     case TYPE_CODE_STRUCT:
 361       /*FIXME: Abstract this away.  */
 362       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 363         {
 364           /* Print the unmangled name if desired.  */
 365           /* Print vtable entry - we only get here if NOT using
 366              -fvtable_thunks.  (Otherwise, look under
 367              TYPE_CODE_PTR.)  */
 368           int offset = (embedded_offset
 369                         + TYPE_FIELD_BITPOS (type,
 370                                              VTBL_FNADDR_OFFSET) / 8);
 371           struct type *field_type = TYPE_FIELD_TYPE (type,
 372                                                      VTBL_FNADDR_OFFSET);
 373           CORE_ADDR addr
 374             = extract_typed_address (valaddr + offset, field_type);
 375
 376           print_function_pointer_address (options, gdbarch, addr, stream);
 377         }
 378       else
 379         cp_print_value_fields_rtti (type, valaddr,
 380                                     embedded_offset, address,
 381                                     stream, recurse,
 382                                     original_value, options,
 383                                     NULL, 0);
 384       break;
 385
 386     case TYPE_CODE_INT:
 387       if (options->format || options->output_format)
 388         {
 389           struct value_print_options opts = *options;
 390
 391           opts.format = (options->format ? options->format
 392                          : options->output_format);
 393           val_print_scalar_formatted (type, valaddr, embedded_offset,
 394                                       original_value, &opts, 0, stream);
 395         }
 396       else
 397         {
 398           val_print_type_code_int (type, valaddr + embedded_offset,
 399                                    stream);
 400           /* C and C++ has no single byte int type, char is used
 401              instead.  Since we don't know whether the value is really
 402              intended to be used as an integer or a character, print
 403              the character equivalent as well.  */
 404           if (c_textual_element_type (unresolved_type, options->format))
 405             {
 406               fputs_filtered (" ", stream);
 407               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 408                              unresolved_type, stream);
 409             }
 410         }
 411       break;
 412
 413     case TYPE_CODE_MEMBERPTR:
 414       if (!options->format)
 415         {
 416           cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 417           break;
 418         }
 419       /* FALLTHROUGH */
 420
 421     case TYPE_CODE_REF:
 422     case TYPE_CODE_ENUM:
 423     case TYPE_CODE_FLAGS:
 424     case TYPE_CODE_FUNC:
 425     case TYPE_CODE_METHOD:
 426     case TYPE_CODE_BOOL:
 427     case TYPE_CODE_RANGE:
 428     case TYPE_CODE_FLT:
 429     case TYPE_CODE_DECFLOAT:
 430     case TYPE_CODE_VOID:
 431     case TYPE_CODE_ERROR:
 432     case TYPE_CODE_UNDEF:
 433     case TYPE_CODE_COMPLEX:
 434     case TYPE_CODE_CHAR:
 435     default:
 436       generic_val_print (type, valaddr, embedded_offset, address,
 437                          stream, recurse, original_value, options,
 438                          &c_decorations);
 439       break;
 440     }
 441   gdb_flush (stream);
 442 }
 443 \f
 444 void
 445 c_value_print (struct value *val, struct ui_file *stream,
 446                const struct value_print_options *options)
 447 {
 448   struct type *type, *real_type, *val_type;
 449   int full, top, using_enc;
 450   struct value_print_options opts = *options;
 451
 452   opts.deref_ref = 1;
 453
 454   /* If it is a pointer, indicate what it points to.
 455
 456      Print type also if it is a reference.
 457
 458      C++: if it is a member pointer, we will take care
 459      of that when we print it.  */
 460
 461   /* Preserve the original type before stripping typedefs.  We prefer
 462      to pass down the original type when possible, but for local
 463      checks it is better to look past the typedefs.  */
 464   val_type = value_type (val);
 465   type = check_typedef (val_type);
 466
 467   if (TYPE_CODE (type) == TYPE_CODE_PTR
 468       || TYPE_CODE (type) == TYPE_CODE_REF)
 469     {
 470       /* Hack:  remove (char *) for char strings.  Their
 471          type is indicated by the quoted string anyway.
 472          (Don't use c_textual_element_type here; quoted strings
 473          are always exactly (char *), (wchar_t *), or the like.  */
 474       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 475           && TYPE_NAME (val_type) == NULL
 476           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 477           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 478                       "char") == 0
 479               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 480         {
 481           /* Print nothing.  */
 482         }
 483       else if (options->objectprint
 484                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 485         {
 486
 487           if (TYPE_CODE(type) == TYPE_CODE_REF)
 488             {
 489               /* Copy value, change to pointer, so we don't get an
 490                  error about a non-pointer type in
 491                  value_rtti_target_type.  */
 492               struct value *temparg;
 493               temparg=value_copy(val);
 494               deprecated_set_value_type
 495                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 496               val = temparg;
 497             }
 498           /* Pointer to class, check real type of object.  */
 499           fprintf_filtered (stream, "(");
 500
 501           if (value_entirely_available (val))
 502             {
 503               real_type = value_rtti_indirect_type (val, &full, &top,
 504                                                     &using_enc);
 505               if (real_type)
 506                 {
 507                   /* RTTI entry found.  */
 508                   type = real_type;
 509
 510                   /* Need to adjust pointer value.  */
 511                   val = value_from_pointer (type, value_as_address (val) - top);
 512
 513                   /* Note: When we look up RTTI entries, we don't get
 514                      any information on const or volatile
 515                      attributes.  */
 516                 }
 517             }
 518           type_print (type, "", stream, -1);
 519           fprintf_filtered (stream, ") ");
 520           val_type = type;
 521         }
 522       else
 523         {
 524           /* normal case */
 525           fprintf_filtered (stream, "(");
 526           type_print (value_type (val), "", stream, -1);
 527           fprintf_filtered (stream, ") ");
 528         }
 529     }
 530
 531   if (!value_initialized (val))
 532     fprintf_filtered (stream, " [uninitialized] ");
 533
 534   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 535     {
 536       /* Attempt to determine real type of object.  */
 537       real_type = value_rtti_type (val, &full, &top, &using_enc);
 538       if (real_type)
 539         {
 540           /* We have RTTI information, so use it.  */
 541           val = value_full_object (val, real_type,
 542                                    full, top, using_enc);
 543           fprintf_filtered (stream, "(%s%s) ",
 544                             TYPE_NAME (real_type),
 545                             full ? "" : _(" [incomplete object]"));
 546           /* Print out object: enclosing type is same as real_type if
 547              full.  */
 548           val_print (value_enclosing_type (val),
 549                      value_contents_for_printing (val), 0,
 550                      value_address (val), stream, 0,
 551                      val, &opts, current_language);
 552           return;
 553           /* Note: When we look up RTTI entries, we don't get any
 554              information on const or volatile attributes.  */
 555         }
 556       else if (type != check_typedef (value_enclosing_type (val)))
 557         {
 558           /* No RTTI information, so let's do our best.  */
 559           fprintf_filtered (stream, "(%s ?) ",
 560                             TYPE_NAME (value_enclosing_type (val)));
 561           val_print (value_enclosing_type (val),
 562                      value_contents_for_printing (val), 0,
 563                      value_address (val), stream, 0,
 564                      val, &opts, current_language);
 565           return;
 566         }
 567       /* Otherwise, we end up at the return outside this "if".  */
 568     }
 569
 570   val_print (val_type, value_contents_for_printing (val),
 571              value_embedded_offset (val),
 572              value_address (val),
 573              stream, 0,
 574              val, &opts, current_language);
 575 }