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 (gdbarch, addr, stream,
 252                                           options->addressprint);
 253           break;
 254         }
 255       unresolved_elttype = TYPE_TARGET_TYPE (type);
 256       elttype = check_typedef (unresolved_elttype);
 257         {
 258           addr = unpack_pointer (type, valaddr + embedded_offset);
 259         print_unpacked_pointer:
 260
 261           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 262             {
 263               /* Try to print what function it points to.  */
 264               print_function_pointer_address (gdbarch, addr, stream,
 265                                               options->addressprint);
 266               return;
 267             }
 268
 269           if (options->addressprint)
 270             fputs_filtered (paddress (gdbarch, addr), stream);
 271
 272           /* For a pointer to a textual type, also print the string
 273              pointed to, unless pointer is null.  */
 274
 275           if (c_textual_element_type (unresolved_elttype,
 276                                       options->format)
 277               && addr != 0)
 278             {
 279               i = val_print_string (unresolved_elttype, NULL,
 280                                     addr, -1,
 281                                     stream, options);
 282             }
 283           else if (cp_is_vtbl_member (type))
 284             {
 285               /* Print vtbl's nicely.  */
 286               CORE_ADDR vt_address = unpack_pointer (type,
 287                                                      valaddr
 288                                                      + embedded_offset);
 289
 290               struct minimal_symbol *msymbol =
 291               lookup_minimal_symbol_by_pc (vt_address);
 292               if ((msymbol != NULL)
 293                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 294                 {
 295                   fputs_filtered (" <", stream);
 296                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 297                   fputs_filtered (">", stream);
 298                 }
 299               if (vt_address && options->vtblprint)
 300                 {
 301                   struct value *vt_val;
 302                   struct symbol *wsym = (struct symbol *) NULL;
 303                   struct type *wtype;
 304                   struct block *block = (struct block *) NULL;
 305                   int is_this_fld;
 306
 307                   if (msymbol != NULL)
 308                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 309                                           block, VAR_DOMAIN,
 310                                           &is_this_fld);
 311
 312                   if (wsym)
 313                     {
 314                       wtype = SYMBOL_TYPE (wsym);
 315                     }
 316                   else
 317                     {
 318                       wtype = unresolved_elttype;
 319                     }
 320                   vt_val = value_at (wtype, vt_address);
 321                   common_val_print (vt_val, stream, recurse + 1,
 322                                     options, current_language);
 323                   if (options->pretty)
 324                     {
 325                       fprintf_filtered (stream, "\n");
 326                       print_spaces_filtered (2 + 2 * recurse, stream);
 327                     }
 328                 }
 329             }
 330           return;
 331         }
 332       break;
 333
 334     case TYPE_CODE_UNION:
 335       if (recurse && !options->unionprint)
 336         {
 337           fprintf_filtered (stream, "{...}");
 338           break;
 339         }
 340       /* Fall through.  */
 341     case TYPE_CODE_STRUCT:
 342       /*FIXME: Abstract this away.  */
 343       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 344         {
 345           /* Print the unmangled name if desired.  */
 346           /* Print vtable entry - we only get here if NOT using
 347              -fvtable_thunks.  (Otherwise, look under
 348              TYPE_CODE_PTR.)  */
 349           int offset = (embedded_offset
 350                         + TYPE_FIELD_BITPOS (type,
 351                                              VTBL_FNADDR_OFFSET) / 8);
 352           struct type *field_type = TYPE_FIELD_TYPE (type,
 353                                                      VTBL_FNADDR_OFFSET);
 354           CORE_ADDR addr
 355             = extract_typed_address (valaddr + offset, field_type);
 356
 357           print_function_pointer_address (gdbarch, addr, stream,
 358                                           options->addressprint);
 359         }
 360       else
 361         cp_print_value_fields_rtti (type, valaddr,
 362                                     embedded_offset, address,
 363                                     stream, recurse,
 364                                     original_value, options,
 365                                     NULL, 0);
 366       break;
 367
 368     case TYPE_CODE_INT:
 369       if (options->format || options->output_format)
 370         {
 371           struct value_print_options opts = *options;
 372
 373           opts.format = (options->format ? options->format
 374                          : options->output_format);
 375           val_print_scalar_formatted (type, valaddr, embedded_offset,
 376                                       original_value, &opts, 0, stream);
 377         }
 378       else
 379         {
 380           val_print_type_code_int (type, valaddr + embedded_offset,
 381                                    stream);
 382           /* C and C++ has no single byte int type, char is used
 383              instead.  Since we don't know whether the value is really
 384              intended to be used as an integer or a character, print
 385              the character equivalent as well.  */
 386           if (c_textual_element_type (unresolved_type, options->format))
 387             {
 388               fputs_filtered (" ", stream);
 389               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 390                              unresolved_type, stream);
 391             }
 392         }
 393       break;
 394
 395     case TYPE_CODE_MEMBERPTR:
 396       if (!options->format)
 397         {
 398           cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 399           break;
 400         }
 401       /* FALLTHROUGH */
 402
 403     case TYPE_CODE_REF:
 404     case TYPE_CODE_ENUM:
 405     case TYPE_CODE_FLAGS:
 406     case TYPE_CODE_FUNC:
 407     case TYPE_CODE_METHOD:
 408     case TYPE_CODE_BOOL:
 409     case TYPE_CODE_RANGE:
 410     case TYPE_CODE_FLT:
 411     case TYPE_CODE_DECFLOAT:
 412     case TYPE_CODE_VOID:
 413     case TYPE_CODE_ERROR:
 414     case TYPE_CODE_UNDEF:
 415     case TYPE_CODE_COMPLEX:
 416     case TYPE_CODE_CHAR:
 417     default:
 418       generic_val_print (type, valaddr, embedded_offset, address,
 419                          stream, recurse, original_value, options,
 420                          &c_decorations);
 421       break;
 422     }
 423   gdb_flush (stream);
 424 }
 425 \f
 426 void
 427 c_value_print (struct value *val, struct ui_file *stream,
 428                const struct value_print_options *options)
 429 {
 430   struct type *type, *real_type, *val_type;
 431   int full, top, using_enc;
 432   struct value_print_options opts = *options;
 433
 434   opts.deref_ref = 1;
 435
 436   /* If it is a pointer, indicate what it points to.
 437
 438      Print type also if it is a reference.
 439
 440      C++: if it is a member pointer, we will take care
 441      of that when we print it.  */
 442
 443   /* Preserve the original type before stripping typedefs.  We prefer
 444      to pass down the original type when possible, but for local
 445      checks it is better to look past the typedefs.  */
 446   val_type = value_type (val);
 447   type = check_typedef (val_type);
 448
 449   if (TYPE_CODE (type) == TYPE_CODE_PTR
 450       || TYPE_CODE (type) == TYPE_CODE_REF)
 451     {
 452       /* Hack:  remove (char *) for char strings.  Their
 453          type is indicated by the quoted string anyway.
 454          (Don't use c_textual_element_type here; quoted strings
 455          are always exactly (char *), (wchar_t *), or the like.  */
 456       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 457           && TYPE_NAME (val_type) == NULL
 458           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 459           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 460                       "char") == 0
 461               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 462         {
 463           /* Print nothing.  */
 464         }
 465       else if (options->objectprint
 466                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 467         {
 468
 469           if (TYPE_CODE(type) == TYPE_CODE_REF)
 470             {
 471               /* Copy value, change to pointer, so we don't get an
 472                  error about a non-pointer type in
 473                  value_rtti_target_type.  */
 474               struct value *temparg;
 475               temparg=value_copy(val);
 476               deprecated_set_value_type
 477                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 478               val = temparg;
 479             }
 480           /* Pointer to class, check real type of object.  */
 481           fprintf_filtered (stream, "(");
 482
 483           if (value_entirely_available (val))
 484             {
 485               real_type = value_rtti_indirect_type (val, &full, &top,
 486                                                     &using_enc);
 487               if (real_type)
 488                 {
 489                   /* RTTI entry found.  */
 490                   type = real_type;
 491
 492                   /* Need to adjust pointer value.  */
 493                   val = value_from_pointer (type, value_as_address (val) - top);
 494
 495                   /* Note: When we look up RTTI entries, we don't get
 496                      any information on const or volatile
 497                      attributes.  */
 498                 }
 499             }
 500           type_print (type, "", stream, -1);
 501           fprintf_filtered (stream, ") ");
 502           val_type = type;
 503         }
 504       else
 505         {
 506           /* normal case */
 507           fprintf_filtered (stream, "(");
 508           type_print (value_type (val), "", stream, -1);
 509           fprintf_filtered (stream, ") ");
 510         }
 511     }
 512
 513   if (!value_initialized (val))
 514     fprintf_filtered (stream, " [uninitialized] ");
 515
 516   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 517     {
 518       /* Attempt to determine real type of object.  */
 519       real_type = value_rtti_type (val, &full, &top, &using_enc);
 520       if (real_type)
 521         {
 522           /* We have RTTI information, so use it.  */
 523           val = value_full_object (val, real_type,
 524                                    full, top, using_enc);
 525           fprintf_filtered (stream, "(%s%s) ",
 526                             TYPE_NAME (real_type),
 527                             full ? "" : _(" [incomplete object]"));
 528           /* Print out object: enclosing type is same as real_type if
 529              full.  */
 530           val_print (value_enclosing_type (val),
 531                      value_contents_for_printing (val), 0,
 532                      value_address (val), stream, 0,
 533                      val, &opts, current_language);
 534           return;
 535           /* Note: When we look up RTTI entries, we don't get any
 536              information on const or volatile attributes.  */
 537         }
 538       else if (type != check_typedef (value_enclosing_type (val)))
 539         {
 540           /* No RTTI information, so let's do our best.  */
 541           fprintf_filtered (stream, "(%s ?) ",
 542                             TYPE_NAME (value_enclosing_type (val)));
 543           val_print (value_enclosing_type (val),
 544                      value_contents_for_printing (val), 0,
 545                      value_address (val), stream, 0,
 546                      val, &opts, current_language);
 547           return;
 548         }
 549       /* Otherwise, we end up at the return outside this "if".  */
 550     }
 551
 552   val_print (val_type, value_contents_for_printing (val),
 553              value_embedded_offset (val),
 554              value_address (val),
 555              stream, 0,
 556              val, &opts, current_language);
 557 }