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 /* c_val_print helper for TYPE_CODE_ARRAY.  */
 229
 230 static void
 231 c_val_print_array (struct type *type, const gdb_byte *valaddr,
 232                    int embedded_offset, CORE_ADDR address,
 233                    struct ui_file *stream, int recurse,
 234                    const struct value *original_value,
 235                    const struct value_print_options *options)
 236 {
 237   struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 238   struct type *elttype = check_typedef (unresolved_elttype);
 239
 240   if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
 241     {
 242       LONGEST low_bound, high_bound;
 243       int eltlen, len;
 244       struct gdbarch *gdbarch = get_type_arch (type);
 245       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 246       unsigned int i = 0;       /* Number of characters printed.  */
 247
 248       if (!get_array_bounds (type, &low_bound, &high_bound))
 249         error (_("Could not determine the array high bound"));
 250
 251       eltlen = TYPE_LENGTH (elttype);
 252       len = high_bound - low_bound + 1;
 253       if (options->prettyformat_arrays)
 254         {
 255           print_spaces_filtered (2 + 2 * recurse, stream);
 256         }
 257
 258       /* Print arrays of textual chars with a string syntax, as
 259          long as the entire array is valid.  */
 260       if (c_textual_element_type (unresolved_elttype,
 261                                   options->format)
 262           && value_bytes_available (original_value, embedded_offset,
 263                                     TYPE_LENGTH (type))
 264           && !value_bits_any_optimized_out (original_value,
 265                                             TARGET_CHAR_BIT * embedded_offset,
 266                                             TARGET_CHAR_BIT * TYPE_LENGTH (type)))
 267         {
 268           int force_ellipses = 0;
 269
 270           /* If requested, look for the first null char and only
 271              print elements up to it.  */
 272           if (options->stop_print_at_null)
 273             {
 274               unsigned int temp_len;
 275
 276               for (temp_len = 0;
 277                    (temp_len < len
 278                     && temp_len < options->print_max
 279                     && extract_unsigned_integer (valaddr + embedded_offset
 280                                                  + temp_len * eltlen,
 281                                                  eltlen, byte_order) != 0);
 282                    ++temp_len)
 283                 ;
 284
 285               /* Force LA_PRINT_STRING to print ellipses if
 286                  we've printed the maximum characters and
 287                  the next character is not \000.  */
 288               if (temp_len == options->print_max && temp_len < len)
 289                 {
 290                   ULONGEST val
 291                     = extract_unsigned_integer (valaddr + embedded_offset
 292                                                 + temp_len * eltlen,
 293                                                 eltlen, byte_order);
 294                   if (val != 0)
 295                     force_ellipses = 1;
 296                 }
 297
 298               len = temp_len;
 299             }
 300
 301           LA_PRINT_STRING (stream, unresolved_elttype,
 302                            valaddr + embedded_offset, len,
 303                            NULL, force_ellipses, options);
 304           i = len;
 305         }
 306       else
 307         {
 308           fprintf_filtered (stream, "{");
 309           /* If this is a virtual function table, print the 0th
 310              entry specially, and the rest of the members
 311              normally.  */
 312           if (cp_is_vtbl_ptr_type (elttype))
 313             {
 314               i = 1;
 315               fprintf_filtered (stream, _("%d vtable entries"),
 316                                 len - 1);
 317             }
 318           else
 319             {
 320               i = 0;
 321             }
 322           val_print_array_elements (type, valaddr, embedded_offset,
 323                                     address, stream,
 324                                     recurse, original_value, options, i);
 325           fprintf_filtered (stream, "}");
 326         }
 327     }
 328   else
 329     {
 330       /* Array of unspecified length: treat like pointer to first elt.  */
 331       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 332                               embedded_offset, address + embedded_offset,
 333                               stream, recurse, options);
 334     }
 335 }
 336
 337 /* c_val_print helper for TYPE_CODE_PTR.  */
 338
 339 static void
 340 c_val_print_ptr (struct type *type, const gdb_byte *valaddr,
 341                  int embedded_offset, struct ui_file *stream, int recurse,
 342                  const struct value *original_value,
 343                  const struct value_print_options *options)
 344 {
 345   if (options->format && options->format != 's')
 346     {
 347       val_print_scalar_formatted (type, valaddr, embedded_offset,
 348                                   original_value, options, 0, stream);
 349     }
 350   else if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 351     {
 352       /* Print the unmangled name if desired.  */
 353       /* Print vtable entry - we only get here if we ARE using
 354          -fvtable_thunks.  (Otherwise, look under
 355          TYPE_CODE_STRUCT.)  */
 356       CORE_ADDR addr
 357         = extract_typed_address (valaddr + embedded_offset, type);
 358       struct gdbarch *gdbarch = get_type_arch (type);
 359
 360       print_function_pointer_address (options, gdbarch, addr, stream);
 361     }
 362   else
 363     {
 364       struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
 365       struct type *elttype = check_typedef (unresolved_elttype);
 366       CORE_ADDR addr = unpack_pointer (type, valaddr + embedded_offset);
 367
 368       print_unpacked_pointer (type, elttype, unresolved_elttype, valaddr,
 369                               embedded_offset, addr, stream, recurse, options);
 370     }
 371 }
 372
 373 /* c_val_print helper for TYPE_CODE_STRUCT.  */
 374
 375 static void
 376 c_val_print_struct (struct type *type, const gdb_byte *valaddr,
 377                     int embedded_offset, CORE_ADDR address,
 378                     struct ui_file *stream, int recurse,
 379                     const struct value *original_value,
 380                     const struct value_print_options *options)
 381 {
 382   if (options->vtblprint && cp_is_vtbl_ptr_type (type))
 383     {
 384       /* Print the unmangled name if desired.  */
 385       /* Print vtable entry - we only get here if NOT using
 386          -fvtable_thunks.  (Otherwise, look under
 387          TYPE_CODE_PTR.)  */
 388       struct gdbarch *gdbarch = get_type_arch (type);
 389       int offset = (embedded_offset
 390                     + TYPE_FIELD_BITPOS (type,
 391                                          VTBL_FNADDR_OFFSET) / 8);
 392       struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
 393       CORE_ADDR addr = extract_typed_address (valaddr + offset, field_type);
 394
 395       print_function_pointer_address (options, gdbarch, addr, stream);
 396     }
 397   else
 398     cp_print_value_fields_rtti (type, valaddr,
 399                                 embedded_offset, address,
 400                                 stream, recurse,
 401                                 original_value, options,
 402                                 NULL, 0);
 403 }
 404
 405 /* c_val_print helper for TYPE_CODE_UNION.  */
 406
 407 static void
 408 c_val_print_union (struct type *type, const gdb_byte *valaddr,
 409                    int embedded_offset, CORE_ADDR address,
 410                    struct ui_file *stream, int recurse,
 411                    const struct value *original_value,
 412                    const struct value_print_options *options)
 413 {
 414   if (recurse && !options->unionprint)
 415     {
 416       fprintf_filtered (stream, "{...}");
 417      }
 418   else
 419     {
 420       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 421                           recurse, original_value, options);
 422     }
 423 }
 424
 425 /* See val_print for a description of the various parameters of this
 426    function; they are identical.  */
 427
 428 void
 429 c_val_print (struct type *type, const gdb_byte *valaddr,
 430              int embedded_offset, CORE_ADDR address,
 431              struct ui_file *stream, int recurse,
 432              const struct value *original_value,
 433              const struct value_print_options *options)
 434 {
 435   struct type *unresolved_type = type;
 436
 437   CHECK_TYPEDEF (type);
 438   switch (TYPE_CODE (type))
 439     {
 440     case TYPE_CODE_ARRAY:
 441       c_val_print_array (type, valaddr, embedded_offset, address, stream,
 442                          recurse, original_value, options);
 443       break;
 444
 445     case TYPE_CODE_METHODPTR:
 446       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 447       break;
 448
 449     case TYPE_CODE_PTR:
 450       c_val_print_ptr (type, valaddr, embedded_offset, stream, recurse,
 451                        original_value, options);
 452       break;
 453
 454     case TYPE_CODE_UNION:
 455       c_val_print_union (type, valaddr, embedded_offset, address, stream,
 456                          recurse, original_value, options);
 457       break;
 458
 459     case TYPE_CODE_STRUCT:
 460       c_val_print_struct (type, valaddr, embedded_offset, address, stream,
 461                           recurse, original_value, options);
 462       break;
 463
 464     case TYPE_CODE_INT:
 465       if (options->format || options->output_format)
 466         {
 467           struct value_print_options opts = *options;
 468
 469           opts.format = (options->format ? options->format
 470                          : options->output_format);
 471           val_print_scalar_formatted (type, valaddr, embedded_offset,
 472                                       original_value, &opts, 0, stream);
 473         }
 474       else
 475         {
 476           val_print_type_code_int (type, valaddr + embedded_offset,
 477                                    stream);
 478           /* C and C++ has no single byte int type, char is used
 479              instead.  Since we don't know whether the value is really
 480              intended to be used as an integer or a character, print
 481              the character equivalent as well.  */
 482           if (c_textual_element_type (unresolved_type, options->format))
 483             {
 484               fputs_filtered (" ", stream);
 485               LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
 486                              unresolved_type, stream);
 487             }
 488         }
 489       break;
 490
 491     case TYPE_CODE_MEMBERPTR:
 492       if (!options->format)
 493         {
 494           cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
 495           break;
 496         }
 497       /* FALLTHROUGH */
 498
 499     case TYPE_CODE_REF:
 500     case TYPE_CODE_ENUM:
 501     case TYPE_CODE_FLAGS:
 502     case TYPE_CODE_FUNC:
 503     case TYPE_CODE_METHOD:
 504     case TYPE_CODE_BOOL:
 505     case TYPE_CODE_RANGE:
 506     case TYPE_CODE_FLT:
 507     case TYPE_CODE_DECFLOAT:
 508     case TYPE_CODE_VOID:
 509     case TYPE_CODE_ERROR:
 510     case TYPE_CODE_UNDEF:
 511     case TYPE_CODE_COMPLEX:
 512     case TYPE_CODE_CHAR:
 513     default:
 514       generic_val_print (type, valaddr, embedded_offset, address,
 515                          stream, recurse, original_value, options,
 516                          &c_decorations);
 517       break;
 518     }
 519   gdb_flush (stream);
 520 }
 521 \f
 522 void
 523 c_value_print (struct value *val, struct ui_file *stream,
 524                const struct value_print_options *options)
 525 {
 526   struct type *type, *real_type, *val_type;
 527   int full, top, using_enc;
 528   struct value_print_options opts = *options;
 529
 530   opts.deref_ref = 1;
 531
 532   /* If it is a pointer, indicate what it points to.
 533
 534      Print type also if it is a reference.
 535
 536      C++: if it is a member pointer, we will take care
 537      of that when we print it.  */
 538
 539   /* Preserve the original type before stripping typedefs.  We prefer
 540      to pass down the original type when possible, but for local
 541      checks it is better to look past the typedefs.  */
 542   val_type = value_type (val);
 543   type = check_typedef (val_type);
 544
 545   if (TYPE_CODE (type) == TYPE_CODE_PTR
 546       || TYPE_CODE (type) == TYPE_CODE_REF)
 547     {
 548       /* Hack:  remove (char *) for char strings.  Their
 549          type is indicated by the quoted string anyway.
 550          (Don't use c_textual_element_type here; quoted strings
 551          are always exactly (char *), (wchar_t *), or the like.  */
 552       if (TYPE_CODE (val_type) == TYPE_CODE_PTR
 553           && TYPE_NAME (val_type) == NULL
 554           && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
 555           && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
 556                       "char") == 0
 557               || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
 558         {
 559           /* Print nothing.  */
 560         }
 561       else if (options->objectprint
 562                && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 563         {
 564           int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
 565
 566           if (is_ref)
 567             val = value_addr (val);
 568
 569           /* Pointer to class, check real type of object.  */
 570           fprintf_filtered (stream, "(");
 571
 572           if (value_entirely_available (val))
 573             {
 574               real_type = value_rtti_indirect_type (val, &full, &top,
 575                                                     &using_enc);
 576               if (real_type)
 577                 {
 578                   /* RTTI entry found.  */
 579                   type = real_type;
 580
 581                   /* Need to adjust pointer value.  */
 582                   val = value_from_pointer (real_type,
 583                                             value_as_address (val) - top);
 584
 585                   if (is_ref)
 586                     {
 587                       val = value_ref (value_ind (val));
 588                       type = value_type (val);
 589                     }
 590
 591                   /* Note: When we look up RTTI entries, we don't get
 592                      any information on const or volatile
 593                      attributes.  */
 594                 }
 595             }
 596           type_print (type, "", stream, -1);
 597           fprintf_filtered (stream, ") ");
 598           val_type = type;
 599         }
 600       else
 601         {
 602           /* normal case */
 603           fprintf_filtered (stream, "(");
 604           type_print (value_type (val), "", stream, -1);
 605           fprintf_filtered (stream, ") ");
 606         }
 607     }
 608
 609   if (!value_initialized (val))
 610     fprintf_filtered (stream, " [uninitialized] ");
 611
 612   if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_STRUCT))
 613     {
 614       /* Attempt to determine real type of object.  */
 615       real_type = value_rtti_type (val, &full, &top, &using_enc);
 616       if (real_type)
 617         {
 618           /* We have RTTI information, so use it.  */
 619           val = value_full_object (val, real_type,
 620                                    full, top, using_enc);
 621           fprintf_filtered (stream, "(%s%s) ",
 622                             TYPE_NAME (real_type),
 623                             full ? "" : _(" [incomplete object]"));
 624           /* Print out object: enclosing type is same as real_type if
 625              full.  */
 626           val_print (value_enclosing_type (val),
 627                      value_contents_for_printing (val), 0,
 628                      value_address (val), stream, 0,
 629                      val, &opts, current_language);
 630           return;
 631           /* Note: When we look up RTTI entries, we don't get any
 632              information on const or volatile attributes.  */
 633         }
 634       else if (type != check_typedef (value_enclosing_type (val)))
 635         {
 636           /* No RTTI information, so let's do our best.  */
 637           fprintf_filtered (stream, "(%s ?) ",
 638                             TYPE_NAME (value_enclosing_type (val)));
 639           val_print (value_enclosing_type (val),
 640                      value_contents_for_printing (val), 0,
 641                      value_address (val), stream, 0,
 642                      val, &opts, current_language);
 643           return;
 644         }
 645       /* Otherwise, we end up at the return outside this "if".  */
 646     }
 647
 648   val_print (val_type, value_contents_for_printing (val),
 649              value_embedded_offset (val),
 650              value_address (val),
 651              stream, 0,
 652              val, &opts, current_language);
 653 }