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