gdb/m2-valprint.c

   1 /* Support for printing Modula 2 values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006,
   4                  2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "value.h"
  26 #include "valprint.h"
  27 #include "language.h"
  28 #include "typeprint.h"
  29 #include "c-lang.h"
  30 #include "m2-lang.h"
  31 #include "target.h"
  32
  33 static int print_unpacked_pointer (struct type *type,
  34                                    CORE_ADDR address, CORE_ADDR addr,
  35                                    const struct value_print_options *options,
  36                                    struct ui_file *stream);
  37 static void
  38 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
  39                          int embedded_offset, CORE_ADDR address,
  40                          struct ui_file *stream, int recurse,
  41                          const struct value *val,
  42                          const struct value_print_options *options,
  43                          int len);
  44
  45
  46 /* Print function pointer with inferior address ADDRESS onto stdio
  47    stream STREAM.  */
  48
  49 static void
  50 print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
  51                                 struct ui_file *stream, int addressprint)
  52 {
  53   CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
  54                                                             &current_target);
  55
  56   /* If the function pointer is represented by a description, print the
  57      address of the description.  */
  58   if (addressprint && func_addr != address)
  59     {
  60       fputs_filtered ("@", stream);
  61       fputs_filtered (paddress (gdbarch, address), stream);
  62       fputs_filtered (": ", stream);
  63     }
  64   print_address_demangle (gdbarch, func_addr, stream, demangle);
  65 }
  66
  67 /* get_long_set_bounds - assigns the bounds of the long set to low and
  68                          high.  */
  69
  70 int
  71 get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
  72 {
  73   int len, i;
  74
  75   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
  76     {
  77       len = TYPE_NFIELDS (type);
  78       i = TYPE_N_BASECLASSES (type);
  79       if (len == 0)
  80         return 0;
  81       *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
  82       *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
  83                                                                  len-1)));
  84       return 1;
  85     }
  86   error (_("expecting long_set"));
  87   return 0;
  88 }
  89
  90 static void
  91 m2_print_long_set (struct type *type, const gdb_byte *valaddr,
  92                    int embedded_offset, CORE_ADDR address,
  93                    struct ui_file *stream)
  94 {
  95   int empty_set        = 1;
  96   int element_seen     = 0;
  97   LONGEST previous_low = 0;
  98   LONGEST previous_high= 0;
  99   LONGEST i, low_bound, high_bound;
 100   LONGEST field_low, field_high;
 101   struct type *range;
 102   int len, field;
 103   struct type *target;
 104   int bitval;
 105
 106   CHECK_TYPEDEF (type);
 107
 108   fprintf_filtered (stream, "{");
 109   len = TYPE_NFIELDS (type);
 110   if (get_long_set_bounds (type, &low_bound, &high_bound))
 111     {
 112       field = TYPE_N_BASECLASSES (type);
 113       range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
 114     }
 115   else
 116     {
 117       fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
 118       return;
 119     }
 120
 121   target = TYPE_TARGET_TYPE (range);
 122
 123   if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
 124     {
 125       for (i = low_bound; i <= high_bound; i++)
 126         {
 127           bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
 128                                     (TYPE_FIELD_BITPOS (type, field) / 8) +
 129                                     valaddr + embedded_offset, i);
 130           if (bitval < 0)
 131             error (_("bit test is out of range"));
 132           else if (bitval > 0)
 133             {
 134               previous_high = i;
 135               if (! element_seen)
 136                 {
 137                   if (! empty_set)
 138                     fprintf_filtered (stream, ", ");
 139                   print_type_scalar (target, i, stream);
 140                   empty_set    = 0;
 141                   element_seen = 1;
 142                   previous_low = i;
 143                 }
 144             }
 145           else
 146             {
 147               /* bit is not set */
 148               if (element_seen)
 149                 {
 150                   if (previous_low+1 < previous_high)
 151                     fprintf_filtered (stream, "..");
 152                   if (previous_low+1 < previous_high)
 153                     print_type_scalar (target, previous_high, stream);
 154                   element_seen = 0;
 155                 }
 156             }
 157           if (i == field_high)
 158             {
 159               field++;
 160               if (field == len)
 161                 break;
 162               range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
 163               if (get_discrete_bounds (range, &field_low, &field_high) < 0)
 164                 break;
 165               target = TYPE_TARGET_TYPE (range);
 166             }
 167         }
 168       if (element_seen)
 169         {
 170           if (previous_low+1 < previous_high)
 171             {
 172               fprintf_filtered (stream, "..");
 173               print_type_scalar (target, previous_high, stream);
 174             }
 175           element_seen = 0;
 176         }
 177       fprintf_filtered (stream, "}");
 178     }
 179 }
 180
 181 static void
 182 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
 183                           int embedded_offset, CORE_ADDR address,
 184                           struct ui_file *stream, int recurse,
 185                           const struct value_print_options *options)
 186 {
 187   struct type *content_type;
 188   CORE_ADDR addr;
 189   LONGEST len;
 190   struct value *val;
 191
 192   CHECK_TYPEDEF (type);
 193   content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
 194
 195   addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
 196                          (TYPE_FIELD_BITPOS (type, 0) / 8) +
 197                          valaddr + embedded_offset);
 198
 199   val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
 200                        addr);
 201   len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
 202
 203   fprintf_filtered (stream, "{");
 204   m2_print_array_contents (value_type (val), value_contents(val),
 205                            value_embedded_offset (val), addr, stream,
 206                            recurse, NULL, options, len);
 207   fprintf_filtered (stream, ", HIGH = %d}", (int) len);
 208 }
 209
 210 static int
 211 print_unpacked_pointer (struct type *type,
 212                         CORE_ADDR address, CORE_ADDR addr,
 213                         const struct value_print_options *options,
 214                         struct ui_file *stream)
 215 {
 216   struct gdbarch *gdbarch = get_type_arch (type);
 217   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 218
 219   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 220     {
 221       /* Try to print what function it points to.  */
 222       print_function_pointer_address (gdbarch, addr, stream,
 223                                       options->addressprint);
 224       /* Return value is irrelevant except for string pointers.  */
 225       return 0;
 226     }
 227
 228   if (options->addressprint && options->format != 's')
 229     fputs_filtered (paddress (gdbarch, address), stream);
 230
 231   /* For a pointer to char or unsigned char, also print the string
 232      pointed to, unless pointer is null.  */
 233
 234   if (TYPE_LENGTH (elttype) == 1
 235       && TYPE_CODE (elttype) == TYPE_CODE_INT
 236       && (options->format == 0 || options->format == 's')
 237       && addr != 0)
 238     return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
 239                              stream, options);
 240
 241   return 0;
 242 }
 243
 244 static void
 245 print_variable_at_address (struct type *type,
 246                            const gdb_byte *valaddr,
 247                            struct ui_file *stream,
 248                            int recurse,
 249                            const struct value_print_options *options)
 250 {
 251   struct gdbarch *gdbarch = get_type_arch (type);
 252   CORE_ADDR addr = unpack_pointer (type, valaddr);
 253   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 254
 255   fprintf_filtered (stream, "[");
 256   fputs_filtered (paddress (gdbarch, addr), stream);
 257   fprintf_filtered (stream, "] : ");
 258
 259   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 260     {
 261       struct value *deref_val =
 262         value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
 263
 264       common_val_print (deref_val, stream, recurse, options, current_language);
 265     }
 266   else
 267     fputs_filtered ("???", stream);
 268 }
 269
 270
 271 /* m2_print_array_contents - prints out the contents of an
 272                              array up to a max_print values.
 273                              It prints arrays of char as a string
 274                              and all other data types as comma
 275                              separated values.  */
 276
 277 static void
 278 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
 279                          int embedded_offset, CORE_ADDR address,
 280                          struct ui_file *stream, int recurse,
 281                          const struct value *val,
 282                          const struct value_print_options *options,
 283                          int len)
 284 {
 285   int eltlen;
 286   CHECK_TYPEDEF (type);
 287
 288   if (TYPE_LENGTH (type) > 0)
 289     {
 290       eltlen = TYPE_LENGTH (type);
 291       if (options->prettyprint_arrays)
 292         print_spaces_filtered (2 + 2 * recurse, stream);
 293       /* For an array of chars, print with string syntax.  */
 294       if (eltlen == 1 &&
 295           ((TYPE_CODE (type) == TYPE_CODE_INT)
 296            || ((current_language->la_language == language_m2)
 297                && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
 298           && (options->format == 0 || options->format == 's'))
 299         val_print_string (type, address, len+1, stream, options);
 300       else
 301         {
 302           fprintf_filtered (stream, "{");
 303           val_print_array_elements (type, valaddr + embedded_offset,
 304                                     address, stream, recurse, val,
 305                                     options, 0);
 306           fprintf_filtered (stream, "}");
 307         }
 308     }
 309 }
 310
 311
 312 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 313    the inferior at address ADDRESS, onto stdio stream STREAM according to
 314    OPTIONS.  The data at VALADDR is in target byte order.
 315
 316    If the data are a string pointer, returns the number of string characters
 317    printed.  */
 318
 319 int
 320 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 321               CORE_ADDR address, struct ui_file *stream, int recurse,
 322               const struct value *original_value,
 323               const struct value_print_options *options)
 324 {
 325   struct gdbarch *gdbarch = get_type_arch (type);
 326   unsigned int i = 0;   /* Number of characters printed */
 327   unsigned len;
 328   struct type *elttype;
 329   unsigned eltlen;
 330   LONGEST val;
 331   CORE_ADDR addr;
 332
 333   CHECK_TYPEDEF (type);
 334   switch (TYPE_CODE (type))
 335     {
 336     case TYPE_CODE_ARRAY:
 337       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
 338         {
 339           elttype = check_typedef (TYPE_TARGET_TYPE (type));
 340           eltlen = TYPE_LENGTH (elttype);
 341           len = TYPE_LENGTH (type) / eltlen;
 342           if (options->prettyprint_arrays)
 343             print_spaces_filtered (2 + 2 * recurse, stream);
 344           /* For an array of chars, print with string syntax.  */
 345           if (eltlen == 1 &&
 346               ((TYPE_CODE (elttype) == TYPE_CODE_INT)
 347                || ((current_language->la_language == language_m2)
 348                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
 349               && (options->format == 0 || options->format == 's'))
 350             {
 351               /* If requested, look for the first null char and only print
 352                  elements up to it.  */
 353               if (options->stop_print_at_null)
 354                 {
 355                   unsigned int temp_len;
 356
 357                   /* Look for a NULL char. */
 358                   for (temp_len = 0;
 359                        (valaddr + embedded_offset)[temp_len]
 360                          && temp_len < len && temp_len < options->print_max;
 361                        temp_len++);
 362                   len = temp_len;
 363                 }
 364
 365               LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
 366                                valaddr + embedded_offset, len, NULL,
 367                                0, options);
 368               i = len;
 369             }
 370           else
 371             {
 372               fprintf_filtered (stream, "{");
 373               val_print_array_elements (type, valaddr + embedded_offset,
 374                                         address, stream, recurse, original_value,
 375                                         options, 0);
 376               fprintf_filtered (stream, "}");
 377             }
 378           break;
 379         }
 380       /* Array of unspecified length: treat like pointer to first elt.  */
 381       print_unpacked_pointer (type, address, address, options, stream);
 382       break;
 383
 384     case TYPE_CODE_PTR:
 385       if (TYPE_CONST (type))
 386         print_variable_at_address (type, valaddr + embedded_offset,
 387                                    stream, recurse, options);
 388       else if (options->format && options->format != 's')
 389         print_scalar_formatted (valaddr + embedded_offset, type,
 390                                 options, 0, stream);
 391       else
 392         {
 393           addr = unpack_pointer (type, valaddr + embedded_offset);
 394           print_unpacked_pointer (type, addr, address, options, stream);
 395         }
 396       break;
 397
 398     case TYPE_CODE_REF:
 399       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 400       if (options->addressprint)
 401         {
 402           CORE_ADDR addr
 403             = extract_typed_address (valaddr + embedded_offset, type);
 404
 405           fprintf_filtered (stream, "@");
 406           fputs_filtered (paddress (gdbarch, addr), stream);
 407           if (options->deref_ref)
 408             fputs_filtered (": ", stream);
 409         }
 410       /* De-reference the reference.  */
 411       if (options->deref_ref)
 412         {
 413           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 414             {
 415               struct value *deref_val =
 416                 value_at
 417                 (TYPE_TARGET_TYPE (type),
 418                  unpack_pointer (type, valaddr + embedded_offset));
 419
 420               common_val_print (deref_val, stream, recurse, options,
 421                                 current_language);
 422             }
 423           else
 424             fputs_filtered ("???", stream);
 425         }
 426       break;
 427
 428     case TYPE_CODE_UNION:
 429       if (recurse && !options->unionprint)
 430         {
 431           fprintf_filtered (stream, "{...}");
 432           break;
 433         }
 434       /* Fall through.  */
 435     case TYPE_CODE_STRUCT:
 436       if (m2_is_long_set (type))
 437         m2_print_long_set (type, valaddr, embedded_offset, address,
 438                            stream);
 439       else if (m2_is_unbounded_array (type))
 440         m2_print_unbounded_array (type, valaddr, embedded_offset,
 441                                   address, stream, recurse, options);
 442       else
 443         cp_print_value_fields (type, type, valaddr, embedded_offset,
 444                                address, stream, recurse, original_value,
 445                                options, NULL, 0);
 446       break;
 447
 448     case TYPE_CODE_ENUM:
 449       if (options->format)
 450         {
 451           print_scalar_formatted (valaddr + embedded_offset, type,
 452                                   options, 0, stream);
 453           break;
 454         }
 455       len = TYPE_NFIELDS (type);
 456       val = unpack_long (type, valaddr + embedded_offset);
 457       for (i = 0; i < len; i++)
 458         {
 459           QUIT;
 460           if (val == TYPE_FIELD_BITPOS (type, i))
 461             {
 462               break;
 463             }
 464         }
 465       if (i < len)
 466         {
 467           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 468         }
 469       else
 470         {
 471           print_longest (stream, 'd', 0, val);
 472         }
 473       break;
 474
 475     case TYPE_CODE_FUNC:
 476       if (options->format)
 477         {
 478           print_scalar_formatted (valaddr + embedded_offset, type,
 479                                   options, 0, stream);
 480           break;
 481         }
 482       /* FIXME, we should consider, at least for ANSI C language, eliminating
 483          the distinction made between FUNCs and POINTERs to FUNCs.  */
 484       fprintf_filtered (stream, "{");
 485       type_print (type, "", stream, -1);
 486       fprintf_filtered (stream, "} ");
 487       /* Try to print what function it points to, and its address.  */
 488       print_address_demangle (gdbarch, address, stream, demangle);
 489       break;
 490
 491     case TYPE_CODE_BOOL:
 492       if (options->format || options->output_format)
 493         {
 494           struct value_print_options opts = *options;
 495
 496           opts.format = (options->format ? options->format
 497                          : options->output_format);
 498           print_scalar_formatted (valaddr + embedded_offset, type,
 499                                   &opts, 0, stream);
 500         }
 501       else
 502         {
 503           val = unpack_long (type, valaddr + embedded_offset);
 504           if (val == 0)
 505             fputs_filtered ("FALSE", stream);
 506           else if (val == 1)
 507             fputs_filtered ("TRUE", stream);
 508           else
 509             fprintf_filtered (stream, "%ld)", (long int) val);
 510         }
 511       break;
 512
 513     case TYPE_CODE_RANGE:
 514       if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
 515         {
 516           m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
 517                         address, stream, recurse, original_value, options);
 518           break;
 519         }
 520       /* FIXME: create_range_type does not set the unsigned bit in a
 521          range type (I think it probably should copy it from the target
 522          type), so we won't print values which are too large to
 523          fit in a signed integer correctly.  */
 524       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 525          print with the target type, though, because the size of our type
 526          and the target type might differ).  */
 527       /* FALLTHROUGH */
 528
 529     case TYPE_CODE_INT:
 530       if (options->format || options->output_format)
 531         {
 532           struct value_print_options opts = *options;
 533
 534           opts.format = (options->format ? options->format
 535                          : options->output_format);
 536           print_scalar_formatted (valaddr + embedded_offset, type,
 537                                   &opts, 0, stream);
 538         }
 539       else
 540         val_print_type_code_int (type, valaddr + embedded_offset, stream);
 541       break;
 542
 543     case TYPE_CODE_CHAR:
 544       if (options->format || options->output_format)
 545         {
 546           struct value_print_options opts = *options;
 547
 548           opts.format = (options->format ? options->format
 549                          : options->output_format);
 550           print_scalar_formatted (valaddr + embedded_offset, type,
 551                                   &opts, 0, stream);
 552         }
 553       else
 554         {
 555           val = unpack_long (type, valaddr + embedded_offset);
 556           if (TYPE_UNSIGNED (type))
 557             fprintf_filtered (stream, "%u", (unsigned int) val);
 558           else
 559             fprintf_filtered (stream, "%d", (int) val);
 560           fputs_filtered (" ", stream);
 561           LA_PRINT_CHAR ((unsigned char) val, type, stream);
 562         }
 563       break;
 564
 565     case TYPE_CODE_FLT:
 566       if (options->format)
 567         print_scalar_formatted (valaddr + embedded_offset, type,
 568                                 options, 0, stream);
 569       else
 570         print_floating (valaddr + embedded_offset, type, stream);
 571       break;
 572
 573     case TYPE_CODE_METHOD:
 574       break;
 575
 576     case TYPE_CODE_BITSTRING:
 577     case TYPE_CODE_SET:
 578       elttype = TYPE_INDEX_TYPE (type);
 579       CHECK_TYPEDEF (elttype);
 580       if (TYPE_STUB (elttype))
 581         {
 582           fprintf_filtered (stream, _("<incomplete type>"));
 583           gdb_flush (stream);
 584           break;
 585         }
 586       else
 587         {
 588           struct type *range = elttype;
 589           LONGEST low_bound, high_bound;
 590           int i;
 591           int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
 592           int need_comma = 0;
 593
 594           if (is_bitstring)
 595             fputs_filtered ("B'", stream);
 596           else
 597             fputs_filtered ("{", stream);
 598
 599           i = get_discrete_bounds (range, &low_bound, &high_bound);
 600         maybe_bad_bstring:
 601           if (i < 0)
 602             {
 603               fputs_filtered (_("<error value>"), stream);
 604               goto done;
 605             }
 606
 607           for (i = low_bound; i <= high_bound; i++)
 608             {
 609               int element = value_bit_index (type, valaddr + embedded_offset,
 610                                              i);
 611
 612               if (element < 0)
 613                 {
 614                   i = element;
 615                   goto maybe_bad_bstring;
 616                 }
 617               if (is_bitstring)
 618                 fprintf_filtered (stream, "%d", element);
 619               else if (element)
 620                 {
 621                   if (need_comma)
 622                     fputs_filtered (", ", stream);
 623                   print_type_scalar (range, i, stream);
 624                   need_comma = 1;
 625
 626                   if (i + 1 <= high_bound
 627                       && value_bit_index (type, valaddr + embedded_offset,
 628                                           ++i))
 629                     {
 630                       int j = i;
 631
 632                       fputs_filtered ("..", stream);
 633                       while (i + 1 <= high_bound
 634                              && value_bit_index (type,
 635                                                  valaddr + embedded_offset,
 636                                                  ++i))
 637                         j = i;
 638                       print_type_scalar (range, j, stream);
 639                     }
 640                 }
 641             }
 642         done:
 643           if (is_bitstring)
 644             fputs_filtered ("'", stream);
 645           else
 646             fputs_filtered ("}", stream);
 647         }
 648       break;
 649
 650     case TYPE_CODE_VOID:
 651       fprintf_filtered (stream, "void");
 652       break;
 653
 654     case TYPE_CODE_ERROR:
 655       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
 656       break;
 657
 658     case TYPE_CODE_UNDEF:
 659       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
 660          dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
 661          and no complete type for struct foo in that file.  */
 662       fprintf_filtered (stream, _("<incomplete type>"));
 663       break;
 664
 665     default:
 666       error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
 667     }
 668   gdb_flush (stream);
 669   return (0);
 670 }