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