contrib/gdb-7/gdb/c-valprint.c

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