gdb/c-valprint.c

   1 /* Support for printing C values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2003, 2005, 2006, 2007
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "valprint.h"
  29 #include "language.h"
  30 #include "c-lang.h"
  31 #include "cp-abi.h"
  32 #include "target.h"
  33 \f
  34
  35 /* Print function pointer with inferior address ADDRESS onto stdio
  36    stream STREAM.  */
  37
  38 static void
  39 print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
  40 {
  41   CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
  42                                                             address,
  43                                                             &current_target);
  44
  45   /* If the function pointer is represented by a description, print the
  46      address of the description.  */
  47   if (addressprint && func_addr != address)
  48     {
  49       fputs_filtered ("@", stream);
  50       deprecated_print_address_numeric (address, 1, stream);
  51       fputs_filtered (": ", stream);
  52     }
  53   print_address_demangle (func_addr, stream, demangle);
  54 }
  55
  56
  57 /* Print data of type TYPE located at VALADDR (within GDB), which came from
  58    the inferior at address ADDRESS, onto stdio stream STREAM according to
  59    FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
  60    target byte order.
  61
  62    If the data are a string pointer, returns the number of string characters
  63    printed.
  64
  65    If DEREF_REF is nonzero, then dereference references, otherwise just print
  66    them like pointers.
  67
  68    The PRETTY parameter controls prettyprinting.  */
  69
  70 int
  71 c_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
  72              CORE_ADDR address, struct ui_file *stream, int format,
  73              int deref_ref, int recurse, enum val_prettyprint pretty)
  74 {
  75   unsigned int i = 0;   /* Number of characters printed */
  76   unsigned len;
  77   struct type *elttype;
  78   unsigned eltlen;
  79   LONGEST val;
  80   CORE_ADDR addr;
  81
  82   CHECK_TYPEDEF (type);
  83   switch (TYPE_CODE (type))
  84     {
  85     case TYPE_CODE_ARRAY:
  86       elttype = check_typedef (TYPE_TARGET_TYPE (type));
  87       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
  88         {
  89           eltlen = TYPE_LENGTH (elttype);
  90           len = TYPE_LENGTH (type) / eltlen;
  91           if (prettyprint_arrays)
  92             {
  93               print_spaces_filtered (2 + 2 * recurse, stream);
  94             }
  95           /* For an array of chars, print with string syntax.  */
  96           if (eltlen == 1 &&
  97               ((TYPE_CODE (elttype) == TYPE_CODE_INT && TYPE_NOSIGN (elttype))
  98                || ((current_language->la_language == language_m2)
  99                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
 100               && (format == 0 || format == 's'))
 101             {
 102               /* If requested, look for the first null char and only print
 103                  elements up to it.  */
 104               if (stop_print_at_null)
 105                 {
 106                   unsigned int temp_len;
 107
 108                   /* Look for a NULL char. */
 109                   for (temp_len = 0;
 110                        (valaddr + embedded_offset)[temp_len]
 111                        && temp_len < len && temp_len < print_max;
 112                        temp_len++);
 113                   len = temp_len;
 114                 }
 115
 116               LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0);
 117               i = len;
 118             }
 119           else
 120             {
 121               fprintf_filtered (stream, "{");
 122               /* If this is a virtual function table, print the 0th
 123                  entry specially, and the rest of the members normally.  */
 124               if (cp_is_vtbl_ptr_type (elttype))
 125                 {
 126                   i = 1;
 127                   fprintf_filtered (stream, _("%d vtable entries"), len - 1);
 128                 }
 129               else
 130                 {
 131                   i = 0;
 132                 }
 133               val_print_array_elements (type, valaddr + embedded_offset, address, stream,
 134                                      format, deref_ref, recurse, pretty, i);
 135               fprintf_filtered (stream, "}");
 136             }
 137           break;
 138         }
 139       /* Array of unspecified length: treat like pointer to first elt.  */
 140       addr = address;
 141       goto print_unpacked_pointer;
 142
 143     case TYPE_CODE_MEMBERPTR:
 144       if (format)
 145         {
 146           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 147           break;
 148         }
 149       cp_print_class_member (valaddr + embedded_offset,
 150                              TYPE_DOMAIN_TYPE (type),
 151                              stream, "&");
 152       break;
 153
 154     case TYPE_CODE_METHODPTR:
 155       cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
 156       break;
 157
 158     case TYPE_CODE_PTR:
 159       if (format && format != 's')
 160         {
 161           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 162           break;
 163         }
 164       if (vtblprint && cp_is_vtbl_ptr_type (type))
 165         {
 166           /* Print the unmangled name if desired.  */
 167           /* Print vtable entry - we only get here if we ARE using
 168              -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 169           CORE_ADDR addr
 170             = extract_typed_address (valaddr + embedded_offset, type);
 171           print_function_pointer_address (addr, stream);
 172           break;
 173         }
 174       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 175         {
 176           addr = unpack_pointer (type, valaddr + embedded_offset);
 177         print_unpacked_pointer:
 178
 179           if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 180             {
 181               /* Try to print what function it points to.  */
 182               print_function_pointer_address (addr, stream);
 183               /* Return value is irrelevant except for string pointers.  */
 184               return (0);
 185             }
 186
 187           if (addressprint && format != 's')
 188             {
 189               deprecated_print_address_numeric (addr, 1, stream);
 190             }
 191
 192           /* For a pointer to char or unsigned char, also print the string
 193              pointed to, unless pointer is null.  */
 194           /* FIXME: need to handle wchar_t here... */
 195
 196           if (TYPE_LENGTH (elttype) == 1
 197               && TYPE_CODE (elttype) == TYPE_CODE_INT
 198               && (format == 0 || format == 's')
 199               && addr != 0)
 200             {
 201               i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
 202             }
 203           else if (cp_is_vtbl_member (type))
 204             {
 205               /* print vtbl's nicely */
 206               CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
 207
 208               struct minimal_symbol *msymbol =
 209               lookup_minimal_symbol_by_pc (vt_address);
 210               if ((msymbol != NULL) &&
 211                   (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
 212                 {
 213                   fputs_filtered (" <", stream);
 214                   fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
 215                   fputs_filtered (">", stream);
 216                 }
 217               if (vt_address && vtblprint)
 218                 {
 219                   struct value *vt_val;
 220                   struct symbol *wsym = (struct symbol *) NULL;
 221                   struct type *wtype;
 222                   struct block *block = (struct block *) NULL;
 223                   int is_this_fld;
 224
 225                   if (msymbol != NULL)
 226                     wsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), block,
 227                                           VAR_DOMAIN, &is_this_fld, NULL);
 228
 229                   if (wsym)
 230                     {
 231                       wtype = SYMBOL_TYPE (wsym);
 232                     }
 233                   else
 234                     {
 235                       wtype = TYPE_TARGET_TYPE (type);
 236                     }
 237                   vt_val = value_at (wtype, vt_address);
 238                   common_val_print (vt_val, stream, format,
 239                                     deref_ref, recurse + 1, pretty);
 240                   if (pretty)
 241                     {
 242                       fprintf_filtered (stream, "\n");
 243                       print_spaces_filtered (2 + 2 * recurse, stream);
 244                     }
 245                 }
 246             }
 247
 248           /* Return number of characters printed, including the terminating
 249              '\0' if we reached the end.  val_print_string takes care including
 250              the terminating '\0' if necessary.  */
 251           return i;
 252         }
 253       break;
 254
 255     case TYPE_CODE_REF:
 256       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 257       if (addressprint)
 258         {
 259           CORE_ADDR addr
 260             = extract_typed_address (valaddr + embedded_offset, type);
 261           fprintf_filtered (stream, "@");
 262           deprecated_print_address_numeric (addr, 1, stream);
 263           if (deref_ref)
 264             fputs_filtered (": ", stream);
 265         }
 266       /* De-reference the reference.  */
 267       if (deref_ref)
 268         {
 269           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 270             {
 271               struct value *deref_val =
 272               value_at
 273               (TYPE_TARGET_TYPE (type),
 274                unpack_pointer (lookup_pointer_type (builtin_type_void),
 275                                valaddr + embedded_offset));
 276               common_val_print (deref_val, stream, format, deref_ref,
 277                                 recurse, pretty);
 278             }
 279           else
 280             fputs_filtered ("???", stream);
 281         }
 282       break;
 283
 284     case TYPE_CODE_UNION:
 285       if (recurse && !unionprint)
 286         {
 287           fprintf_filtered (stream, "{...}");
 288           break;
 289         }
 290       /* Fall through.  */
 291     case TYPE_CODE_STRUCT:
 292       /*FIXME: Abstract this away */
 293       if (vtblprint && cp_is_vtbl_ptr_type (type))
 294         {
 295           /* Print the unmangled name if desired.  */
 296           /* Print vtable entry - we only get here if NOT using
 297              -fvtable_thunks.  (Otherwise, look under TYPE_CODE_PTR.) */
 298           int offset = (embedded_offset +
 299                         TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
 300           struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
 301           CORE_ADDR addr
 302             = extract_typed_address (valaddr + offset, field_type);
 303
 304           print_function_pointer_address (addr, stream);
 305         }
 306       else
 307         cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format,
 308                                recurse, pretty, NULL, 0);
 309       break;
 310
 311     case TYPE_CODE_ENUM:
 312       if (format)
 313         {
 314           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 315           break;
 316         }
 317       len = TYPE_NFIELDS (type);
 318       val = unpack_long (type, valaddr + embedded_offset);
 319       for (i = 0; i < len; i++)
 320         {
 321           QUIT;
 322           if (val == TYPE_FIELD_BITPOS (type, i))
 323             {
 324               break;
 325             }
 326         }
 327       if (i < len)
 328         {
 329           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 330         }
 331       else
 332         {
 333           print_longest (stream, 'd', 0, val);
 334         }
 335       break;
 336
 337     case TYPE_CODE_FLAGS:
 338       if (format)
 339           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 340       else
 341         val_print_type_code_flags (type, valaddr + embedded_offset, stream);
 342       break;
 343
 344     case TYPE_CODE_FUNC:
 345     case TYPE_CODE_METHOD:
 346       if (format)
 347         {
 348           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 349           break;
 350         }
 351       /* FIXME, we should consider, at least for ANSI C language, eliminating
 352          the distinction made between FUNCs and POINTERs to FUNCs.  */
 353       fprintf_filtered (stream, "{");
 354       type_print (type, "", stream, -1);
 355       fprintf_filtered (stream, "} ");
 356       /* Try to print what function it points to, and its address.  */
 357       print_address_demangle (address, stream, demangle);
 358       break;
 359
 360     case TYPE_CODE_BOOL:
 361       format = format ? format : output_format;
 362       if (format)
 363         print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 364       else
 365         {
 366           val = unpack_long (type, valaddr + embedded_offset);
 367           if (val == 0)
 368             fputs_filtered ("false", stream);
 369           else if (val == 1)
 370             fputs_filtered ("true", stream);
 371           else
 372             print_longest (stream, 'd', 0, val);
 373         }
 374       break;
 375
 376     case TYPE_CODE_RANGE:
 377       /* FIXME: create_range_type does not set the unsigned bit in a
 378          range type (I think it probably should copy it from the target
 379          type), so we won't print values which are too large to
 380          fit in a signed integer correctly.  */
 381       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 382          print with the target type, though, because the size of our type
 383          and the target type might differ).  */
 384       /* FALLTHROUGH */
 385
 386     case TYPE_CODE_INT:
 387       format = format ? format : output_format;
 388       if (format)
 389         {
 390           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 391         }
 392       else
 393         {
 394           val_print_type_code_int (type, valaddr + embedded_offset, stream);
 395           /* C and C++ has no single byte int type, char is used instead.
 396              Since we don't know whether the value is really intended to
 397              be used as an integer or a character, print the character
 398              equivalent as well. */
 399           if (TYPE_LENGTH (type) == 1)
 400             {
 401               fputs_filtered (" ", stream);
 402               LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
 403                              stream);
 404             }
 405         }
 406       break;
 407
 408     case TYPE_CODE_CHAR:
 409       format = format ? format : output_format;
 410       if (format)
 411         {
 412           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 413         }
 414       else
 415         {
 416           val = unpack_long (type, valaddr + embedded_offset);
 417           if (TYPE_UNSIGNED (type))
 418             fprintf_filtered (stream, "%u", (unsigned int) val);
 419           else
 420             fprintf_filtered (stream, "%d", (int) val);
 421           fputs_filtered (" ", stream);
 422           LA_PRINT_CHAR ((unsigned char) val, stream);
 423         }
 424       break;
 425
 426     case TYPE_CODE_FLT:
 427       if (format)
 428         {
 429           print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
 430         }
 431       else
 432         {
 433           print_floating (valaddr + embedded_offset, type, stream);
 434         }
 435       break;
 436
 437     case TYPE_CODE_VOID:
 438       fprintf_filtered (stream, "void");
 439       break;
 440
 441     case TYPE_CODE_ERROR:
 442       fprintf_filtered (stream, _("<error type>"));
 443       break;
 444
 445     case TYPE_CODE_UNDEF:
 446       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
 447          dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
 448          and no complete type for struct foo in that file.  */
 449       fprintf_filtered (stream, _("<incomplete type>"));
 450       break;
 451
 452     case TYPE_CODE_COMPLEX:
 453       if (format)
 454         print_scalar_formatted (valaddr + embedded_offset,
 455                                 TYPE_TARGET_TYPE (type),
 456                                 format, 0, stream);
 457       else
 458         print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
 459                         stream);
 460       fprintf_filtered (stream, " + ");
 461       if (format)
 462         print_scalar_formatted (valaddr + embedded_offset
 463                                 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 464                                 TYPE_TARGET_TYPE (type),
 465                                 format, 0, stream);
 466       else
 467         print_floating (valaddr + embedded_offset
 468                         + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
 469                         TYPE_TARGET_TYPE (type),
 470                         stream);
 471       fprintf_filtered (stream, " * I");
 472       break;
 473
 474     default:
 475       error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
 476     }
 477   gdb_flush (stream);
 478   return (0);
 479 }
 480 \f
 481 int
 482 c_value_print (struct value *val, struct ui_file *stream, int format,
 483                enum val_prettyprint pretty)
 484 {
 485   struct type *type, *real_type;
 486   int full, top, using_enc;
 487
 488   /* If it is a pointer, indicate what it points to.
 489
 490      Print type also if it is a reference.
 491
 492      C++: if it is a member pointer, we will take care
 493      of that when we print it.  */
 494
 495   type = check_typedef (value_type (val));
 496
 497   if (TYPE_CODE (type) == TYPE_CODE_PTR
 498       || TYPE_CODE (type) == TYPE_CODE_REF)
 499     {
 500       /* Hack:  remove (char *) for char strings.  Their
 501          type is indicated by the quoted string anyway. */
 502       if (TYPE_CODE (type) == TYPE_CODE_PTR
 503           && TYPE_NAME (type) == NULL
 504           && TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
 505           && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
 506         {
 507           /* Print nothing */
 508         }
 509       else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 510         {
 511
 512           if (TYPE_CODE(type) == TYPE_CODE_REF)
 513             {
 514               /* Copy value, change to pointer, so we don't get an
 515                * error about a non-pointer type in value_rtti_target_type
 516                */
 517               struct value *temparg;
 518               temparg=value_copy(val);
 519               deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
 520               val=temparg;
 521             }
 522           /* Pointer to class, check real type of object */
 523           fprintf_filtered (stream, "(");
 524           real_type = value_rtti_target_type (val, &full, &top, &using_enc);
 525           if (real_type)
 526             {
 527               /* RTTI entry found */
 528               if (TYPE_CODE (type) == TYPE_CODE_PTR)
 529                 {
 530                   /* create a pointer type pointing to the real type */
 531                   type = lookup_pointer_type (real_type);
 532                 }
 533               else
 534                 {
 535                   /* create a reference type referencing the real type */
 536                   type = lookup_reference_type (real_type);
 537                 }
 538               /* JYG: Need to adjust pointer value. */
 539               /* NOTE: cagney/2005-01-02: THIS IS BOGUS.  */
 540               value_contents_writeable (val)[0] -= top;
 541
 542               /* Note: When we look up RTTI entries, we don't get any
 543                  information on const or volatile attributes */
 544             }
 545           type_print (type, "", stream, -1);
 546           fprintf_filtered (stream, ") ");
 547         }
 548       else
 549         {
 550           /* normal case */
 551           fprintf_filtered (stream, "(");
 552           type_print (value_type (val), "", stream, -1);
 553           fprintf_filtered (stream, ") ");
 554         }
 555     }
 556
 557   if (!value_initialized (val))
 558     fprintf_filtered (stream, " [uninitialized] ");
 559
 560   if (objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
 561     {
 562       /* Attempt to determine real type of object */
 563       real_type = value_rtti_type (val, &full, &top, &using_enc);
 564       if (real_type)
 565         {
 566           /* We have RTTI information, so use it */
 567           val = value_full_object (val, real_type, full, top, using_enc);
 568           fprintf_filtered (stream, "(%s%s) ",
 569                             TYPE_NAME (real_type),
 570                             full ? "" : _(" [incomplete object]"));
 571           /* Print out object: enclosing type is same as real_type if full */
 572           return val_print (value_enclosing_type (val),
 573                             value_contents_all (val), 0,
 574                             VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
 575           /* Note: When we look up RTTI entries, we don't get any information on
 576              const or volatile attributes */
 577         }
 578       else if (type != check_typedef (value_enclosing_type (val)))
 579         {
 580           /* No RTTI information, so let's do our best */
 581           fprintf_filtered (stream, "(%s ?) ",
 582                             TYPE_NAME (value_enclosing_type (val)));
 583           return val_print (value_enclosing_type (val),
 584                             value_contents_all (val), 0,
 585                             VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
 586         }
 587       /* Otherwise, we end up at the return outside this "if" */
 588     }
 589
 590   return val_print (type, value_contents_all (val),
 591                     value_embedded_offset (val),
 592                     VALUE_ADDRESS (val) + value_offset (val),
 593                     stream, format, 1, 0, pretty);
 594 }