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   CORE_ADDR addr;
 149
 150   CHECK_TYPEDEF (type);
 151   switch (TYPE_CODE (type))
 152     {
 153     case TYPE_CODE_ARRAY:
 154       unresolved_elttype = TYPE_TARGET_TYPE (type);
 155       elttype = check_typedef (unresolved_elttype);
 156       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 157         {
 158           LONGEST low_bound, high_bound;
 159
 160           if (!get_array_bounds (type, &low_bound, &high_bound))
 161             error (_("Could not determine the array high bound"));
 162
 163           eltlen = TYPE_LENGTH (elttype);
 164           len = high_bound - low_bound + 1;
 165           if (options->prettyprint_arrays)
 166             {
 167               print_spaces_filtered (2 + 2 * recurse, stream);
 168             }
 169
 170           /* Print arrays of textual chars with a string syntax, as
 171              long as the entire array is valid.  */
 172           if (c_textual_element_type (unresolved_elttype,
 173                                       options->format)
 174               && value_bytes_available (original_value, embedded_offset,
 175                                         TYPE_LENGTH (type))
 176               && value_bits_valid (original_value,
 177                                    TARGET_CHAR_BIT * embedded_offset,
 178                                    TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 179             {
 180               int force_ellipses = 0;
 181
 182               /* If requested, look for the first null char and only
 183                  print elements up to it.  */
 184               if (options->stop_print_at_null)
 185                 {
 186                   unsigned int temp_len;
 187
 188                   for (temp_len = 0;
 189                        (temp_len < len
 190                         && temp_len < options->print_max
 191                         && extract_unsigned_integer (valaddr + embedded_offset
 192                                                      + temp_len * eltlen,
 193                                                      eltlen, byte_order) != 0);
 194                        ++temp_len)
 195                     ;
 196
 197                   /* Force LA_PRINT_STRING to print ellipses if
 198                      we've printed the maximum characters and
 199                      the next character is not \000.  */
 200                   if (temp_len == options->print_max && temp_len < len)
 201                     {
 202                       ULONGEST val
 203                         = extract_unsigned_integer (valaddr + embedded_offset
 204                                                     + temp_len * eltlen,
 205                                                     eltlen, byte_order);
 206                       if (val != 0)
 207                         force_ellipses = 1;
 208                     }
 209
 210                   len = temp_len;
 211                 }
 212
 213               LA_PRINT_STRING (stream, unresolved_elttype,
 214                                valaddr + embedded_offset, len,
 215                                NULL, force_ellipses, options);
 216               i = len;
 217             }
 218           else
 219             {
 220               fprintf_filtered (stream, "{");
 221               /* If this is a virtual function table, print the 0th
 222                  entry specially, and the rest of the members
 223                  normally.  */
 224               if (cp_is_vtbl_ptr_type (elttype))
 225                 {
 226                   i = 1;
 227                   fprintf_filtered (stream, _("%d vtable entries"),
 228                                     len - 1);
 229                 }
 230               else
 231                 {
 232                   i = 0;
 233                 }
 234               val_print_array_elements (type, valaddr, embedded_offset,
 235                                         address, stream,
 236                                         recurse, original_value, options, i);
 237               fprintf_filtered (stream, "}");
 238             }
 239           break;
 240         }
 241       /* Array of unspecified length: treat like pointer to first
 242          elt.  */
 243       addr = address + embedded_offset;
 244       goto print_unpacked_pointer;
 245
 246     case TYPE_CODE_METHODPTR:
 247       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 248       break;
 249
 250     case TYPE_CODE_PTR:
 251       if (options->format && options->format != 's')
 252         {
 253           val_print_scalar_formatted (type, valaddr, embedded_offset,
 254                                       original_value, options, 0, stream);
 255           break;
 256         }
 257       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 258         {
 259           /* Print the unmangled name if desired.  */
 260           /* Print vtable entry - we only get here if we ARE using
 261              -fvtable_thunks.  (Otherwise, look under
 262              TYPE_CODE_STRUCT.)  */
 263           CORE_ADDR addr
 264             = extract_typed_address (valaddr + embedded_offset, type);
 265
 266           print_function_pointer_address (options, gdbarch, addr, stream);
 267           break;
 268         }
 269       unresolved_elttype = TYPE_TARGET_TYPE (type);
 270       elttype = check_typedef (unresolved_elttype);
 271         {
 272           int want_space;
 273
 274           addr = unpack_pointer (type, valaddr + embedded_offset);
 275         print_unpacked_pointer:
 276
 277           want_space = 0;
 278
 279           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 280             {
 281               /* Try to print what function it points to.  */
 282               print_function_pointer_address (options, gdbarch, addr, stream);
 283               return;
 284             }
 285
 286           if (options->symbol_print)
 287             want_space = print_address_demangle (options, gdbarch, addr,
 288                                                  stream, demangle);
 289           else if (options->addressprint)
 290             {
 291               fputs_filtered (paddress (gdbarch, addr), stream);
 292               want_space = 1;
 293             }
 294
 295           /* For a pointer to a textual type, also print the string
 296              pointed to, unless pointer is null.  */
 297
 298           if (c_textual_element_type (unresolved_elttype,
 299                                       options->format)
 300               && addr != 0)
 301             {
 302               if (want_space)
 303                 fputs_filtered (" ", stream);
 304               i = val_print_string (unresolved_elttype, NULL,
 305                                     addr, -1,
 306                                     stream, options);
 307             }
 308           else if (cp_is_vtbl_member (type))
 309             {
 310               /* Print vtbl's nicely.  */
 311               CORE_ADDR vt_address = unpack_pointer (type,
 312                                                      valaddr
 313                                                      + embedded_offset);
 314               struct minimal_symbol *msymbol =
 315               lookup_minimal_symbol_by_pc (vt_address);
 316
 317               /* If 'symbol_print' is set, we did the work above.  */
 318               if (!options->symbol_print
 319                   && (msymbol != NULL)
 320                   && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 321                 {
 322                   if (want_space)
 323                     fputs_filtered (" ", stream);
 324                   fputs_filtered (" <", stream);
 325                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 326                   fputs_filtered (">", stream);
 327                   want_space = 1;
 328                 }
 329
 330               if (vt_address && options->vtblprint)
 331                 {
 332                   struct value *vt_val;
 333                   struct symbol *wsym = (struct symbol *) NULL;
 334                   struct type *wtype;
 335                   struct block *block = (struct block *) NULL;
 336                   struct field_of_this_result is_this_fld;
 337
 338                   if (want_space)
 339                     fputs_filtered (" ", stream);
 340
 341                   if (msymbol != NULL)
 342                     wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
 343                                           block, VAR_DOMAIN,
 344                                           &is_this_fld);
 345
 346                   if (wsym)
 347                     {
 348                       wtype = SYMBOL_TYPE (wsym);
 349                     }
 350                   else
 351                     {
 352                       wtype = unresolved_elttype;
 353                     }
 354                   vt_val = value_at (wtype, vt_address);
 355                   common_val_print (vt_val, stream, recurse + 1,
 356                                     options, current_language);
 357                   if (options->pretty)
 358                     {
 359                       fprintf_filtered (stream, "\n");
 360                       print_spaces_filtered (2 + 2 * recurse, stream);
 361                     }
 362                 }
 363             }
 364           return;
 365         }
 366       break;
 367
 368     case TYPE_CODE_UNION:
 369       if (recurse && !options->unionprint)
 370         {
 371           fprintf_filtered (stream, "{...}");
 372           break;
 373         }
 374       /* Fall through.  */
 375     case TYPE_CODE_STRUCT:
 376       /*FIXME: Abstract this away.  */
 377       if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 378         {
 379           /* Print the unmangled name if desired.  */
 380           /* Print vtable entry - we only get here if NOT using
 381              -fvtable_thunks.  (Otherwise, look under
 382              TYPE_CODE_PTR.)  */
 383           int offset = (embedded_offset
 384                         + TYPE_FIELD_BITPOS (type,
 385                                              VTBL_FNADDR_OFFSET) / 8);
 386           struct type *field_type = TYPE_FIELD_TYPE (type,
 387                                                      VTBL_FNADDR_OFFSET);
 388           CORE_ADDR addr
 389             = extract_typed_address (valaddr + offset, field_type);
 390
 391           print_function_pointer_address (options, gdbarch, addr, stream);
 392         }
 393       else
 394         cp_print_value_fields_rtti (type, valaddr,
 395                                     embedded_offset, address,
 396                                     stream, recurse,
 397                                     original_value, options,
 398                                     NULL, 0);
 399       break;
 400
 401     case TYPE_CODE_INT:
 402       if (options->format || options->output_format)
 403         {
 404           struct value_print_options opts = *options;
 405
 406           opts.format = (options->format ? options->format
 407                          : options->output_format);
 408           val_print_scalar_formatted (type, valaddr, embedded_offset,
 409                                       original_value, &opts, 0, stream);
 410         }
 411       else
 412         {
 413           val_print_type_code_int (type, valaddr + embedded_offset,
 414                                    stream);
 415           /* C and C++ has no single byte int type, char is used
 416              instead.  Since we don't know whether the value is really
 417              intended to be used as an integer or a character, print
 418              the character equivalent as well.  */
 419           if (c_textual_element_type (unresolved_type, options->format))
 420             {
 421               fputs_filtered (" ", stream);
 422               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 423                              unresolved_type, stream);
 424             }
 425         }
 426       break;
 427
 428     case TYPE_CODE_MEMBERPTR:
 429       if (!options->format)
 430         {
 431           cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 432           break;
 433         }
 434       /* FALLTHROUGH */
 435
 436     case TYPE_CODE_REF:
 437     case TYPE_CODE_ENUM:
 438     case TYPE_CODE_FLAGS:
 439     case TYPE_CODE_FUNC:
 440     case TYPE_CODE_METHOD:
 441     case TYPE_CODE_BOOL:
 442     case TYPE_CODE_RANGE:
 443     case TYPE_CODE_FLT:
 444     case TYPE_CODE_DECFLOAT:
 445     case TYPE_CODE_VOID:
 446     case TYPE_CODE_ERROR:
 447     case TYPE_CODE_UNDEF:
 448     case TYPE_CODE_COMPLEX:
 449     case TYPE_CODE_CHAR:
 450     default:
 451       generic_val_print (type, valaddr, embedded_offset, address,
 452                          stream, recurse, original_value, options,
 453                          &c_decorations);
 454       break;
 455     }
 456   gdb_flush (stream);
 457 }
 458 \f
 459 void
 460 c_value_print (struct value *val, struct ui_file *stream,
 461                const struct value_print_options *options)
 462 {
 463   struct type *type, *real_type, *val_type;
 464   int full, top, using_enc;
 465   struct value_print_options opts = *options;
 466
 467   opts.deref_ref = 1;
 468
 469   /* If it is a pointer, indicate what it points to.
 470
 471      Print type also if it is a reference.
 472
 473      C++: if it is a member pointer, we will take care
 474      of that when we print it.  */
 475
 476   /* Preserve the original type before stripping typedefs.  We prefer
 477      to pass down the original type when possible, but for local
 478      checks it is better to look past the typedefs.  */
 479   val_type = value_type (val);
 480   type = check_typedef (val_type);
 481
 482   if (TYPE_CODE (type) == TYPE_CODE_PTR
 483       || TYPE_CODE (type) == TYPE_CODE_REF)
 484     {
 485       /* Hack:  remove (char *) for char strings.  Their
 486          type is indicated by the quoted string anyway.
 487          (Don't use c_textual_element_type here; quoted strings
 488          are always exactly (char *), (wchar_t *), or the like.  */
 489       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 490           && TYPE_NAME (val_type) == NULL
 491           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 492           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 493                       "char") == 0
 494               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 495         {
 496           /* Print nothing.  */
 497         }
 498       else if (options->objectprint
 499                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 500         {
 501
 502           if (TYPE_CODE(type) == TYPE_CODE_REF)
 503             {
 504               /* Copy value, change to pointer, so we don't get an
 505                  error about a non-pointer type in
 506                  value_rtti_target_type.  */
 507               struct value *temparg;
 508               temparg=value_copy(val);
 509               deprecated_set_value_type
 510                 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
 511               val = temparg;
 512             }
 513           /* Pointer to class, check real type of object.  */
 514           fprintf_filtered (stream, "(");
 515
 516           if (value_entirely_available (val))
 517             {
 518               real_type = value_rtti_indirect_type (val, &full, &top,
 519                                                     &using_enc);
 520               if (real_type)
 521                 {
 522                   /* RTTI entry found.  */
 523                   type = real_type;
 524
 525                   /* Need to adjust pointer value.  */
 526                   val = value_from_pointer (type, value_as_address (val) - top);
 527
 528                   /* Note: When we look up RTTI entries, we don't get
 529                      any information on const or volatile
 530                      attributes.  */
 531                 }
 532             }
 533           type_print (type, "", stream, -1);
 534           fprintf_filtered (stream, ") ");
 535           val_type = type;
 536         }
 537       else
 538         {
 539           /* normal case */
 540           fprintf_filtered (stream, "(");
 541           type_print (value_type (val), "", stream, -1);
 542           fprintf_filtered (stream, ") ");
 543         }
 544     }
 545
 546   if (!value_initialized (val))
 547     fprintf_filtered (stream, " [uninitialized] ");
 548
 549   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 550     {
 551       /* Attempt to determine real type of object.  */
 552       real_type = value_rtti_type (val, &full, &top, &using_enc);
 553       if (real_type)
 554         {
 555           /* We have RTTI information, so use it.  */
 556           val = value_full_object (val, real_type,
 557                                    full, top, using_enc);
 558           fprintf_filtered (stream, "(%s%s) ",
 559                             TYPE_NAME (real_type),
 560                             full ? "" : _(" [incomplete object]"));
 561           /* Print out object: enclosing type is same as real_type if
 562              full.  */
 563           val_print (value_enclosing_type (val),
 564                      value_contents_for_printing (val), 0,
 565                      value_address (val), stream, 0,
 566                      val, &opts, current_language);
 567           return;
 568           /* Note: When we look up RTTI entries, we don't get any
 569              information on const or volatile attributes.  */
 570         }
 571       else if (type != check_typedef (value_enclosing_type (val)))
 572         {
 573           /* No RTTI information, so let's do our best.  */
 574           fprintf_filtered (stream, "(%s ?) ",
 575                             TYPE_NAME (value_enclosing_type (val)));
 576           val_print (value_enclosing_type (val),
 577                      value_contents_for_printing (val), 0,
 578                      value_address (val), stream, 0,
 579                      val, &opts, current_language);
 580           return;
 581         }
 582       /* Otherwise, we end up at the return outside this "if".  */
 583     }
 584
 585   val_print (val_type, value_contents_for_printing (val),
 586              value_embedded_offset (val),
 587              value_address (val),
 588              stream, 0,
 589              val, &opts, current_language);
 590 }