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