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 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_print_options *options,
  42                          int len);
  43
  44
  45 /* Print function pointer with inferior address ADDRESS onto stdio
  46    stream STREAM.  */
  47
  48 static void
  49 print_function_pointer_address (CORE_ADDR address, struct ui_file *stream,
  50                                 int addressprint)
  51 {
  52   CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
  53                                                             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 (address), stream);
  62       fputs_filtered (": ", stream);
  63     }
  64   print_address_demangle (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, 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 type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 217
 218   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 219     {
 220       /* Try to print what function it points to.  */
 221       print_function_pointer_address (addr, stream, options->addressprint);
 222       /* Return value is irrelevant except for string pointers.  */
 223       return 0;
 224     }
 225
 226   if (options->addressprint && options->format != 's')
 227     fputs_filtered (paddress (address), stream);
 228
 229   /* For a pointer to char or unsigned char, also print the string
 230      pointed to, unless pointer is null.  */
 231
 232   if (TYPE_LENGTH (elttype) == 1
 233       && TYPE_CODE (elttype) == TYPE_CODE_INT
 234       && (options->format == 0 || options->format == 's')
 235       && addr != 0)
 236     return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
 237                              stream, options);
 238
 239   return 0;
 240 }
 241
 242 static void
 243 print_variable_at_address (struct type *type,
 244                            const gdb_byte *valaddr,
 245                            struct ui_file *stream,
 246                            int recurse,
 247                            const struct value_print_options *options)
 248 {
 249   CORE_ADDR addr = unpack_pointer (type, valaddr);
 250   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 251
 252   fprintf_filtered (stream, "[");
 253   fputs_filtered (paddress (addr), stream);
 254   fprintf_filtered (stream, "] : ");
 255
 256   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 257     {
 258       struct value *deref_val =
 259         value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
 260       common_val_print (deref_val, stream, recurse, options, current_language);
 261     }
 262   else
 263     fputs_filtered ("???", stream);
 264 }
 265
 266
 267 /* m2_print_array_contents - prints out the contents of an
 268                              array up to a max_print values.
 269                              It prints arrays of char as a string
 270                              and all other data types as comma
 271                              separated values.  */
 272
 273 static void
 274 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
 275                          int embedded_offset, CORE_ADDR address,
 276                          struct ui_file *stream, int recurse,
 277                          const struct value_print_options *options,
 278                          int len)
 279 {
 280   int eltlen;
 281   CHECK_TYPEDEF (type);
 282
 283   if (TYPE_LENGTH (type) > 0)
 284     {
 285       eltlen = TYPE_LENGTH (type);
 286       if (options->prettyprint_arrays)
 287         print_spaces_filtered (2 + 2 * recurse, stream);
 288       /* For an array of chars, print with string syntax.  */
 289       if (eltlen == 1 &&
 290           ((TYPE_CODE (type) == TYPE_CODE_INT)
 291            || ((current_language->la_language == language_m2)
 292                && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
 293           && (options->format == 0 || options->format == 's'))
 294         val_print_string (type, address, len+1, stream, options);
 295       else
 296         {
 297           fprintf_filtered (stream, "{");
 298           val_print_array_elements (type, valaddr + embedded_offset,
 299                                     address, stream, recurse, options, 0);
 300           fprintf_filtered (stream, "}");
 301         }
 302     }
 303 }
 304
 305
 306 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 307    the inferior at address ADDRESS, onto stdio stream STREAM according to
 308    OPTIONS.  The data at VALADDR is in target byte order.
 309
 310    If the data are a string pointer, returns the number of string characters
 311    printed.  */
 312
 313 int
 314 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 315               CORE_ADDR address, struct ui_file *stream, int recurse,
 316               const struct value_print_options *options)
 317 {
 318   unsigned int i = 0;   /* Number of characters printed */
 319   unsigned len;
 320   struct type *elttype;
 321   unsigned eltlen;
 322   int length_pos, length_size, string_pos;
 323   int char_size;
 324   LONGEST val;
 325   CORE_ADDR addr;
 326
 327   CHECK_TYPEDEF (type);
 328   switch (TYPE_CODE (type))
 329     {
 330     case TYPE_CODE_ARRAY:
 331       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
 332         {
 333           elttype = check_typedef (TYPE_TARGET_TYPE (type));
 334           eltlen = TYPE_LENGTH (elttype);
 335           len = TYPE_LENGTH (type) / eltlen;
 336           if (options->prettyprint_arrays)
 337             print_spaces_filtered (2 + 2 * recurse, stream);
 338           /* For an array of chars, print with string syntax.  */
 339           if (eltlen == 1 &&
 340               ((TYPE_CODE (elttype) == TYPE_CODE_INT)
 341                || ((current_language->la_language == language_m2)
 342                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
 343               && (options->format == 0 || options->format == 's'))
 344             {
 345               /* If requested, look for the first null char and only print
 346                  elements up to it.  */
 347               if (options->stop_print_at_null)
 348                 {
 349                   unsigned int temp_len;
 350
 351                   /* Look for a NULL char. */
 352                   for (temp_len = 0;
 353                        (valaddr + embedded_offset)[temp_len]
 354                          && temp_len < len && temp_len < options->print_max;
 355                        temp_len++);
 356                   len = temp_len;
 357                 }
 358
 359               LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
 360                                valaddr + embedded_offset, len, 0,
 361                                options);
 362               i = len;
 363             }
 364           else
 365             {
 366               fprintf_filtered (stream, "{");
 367               val_print_array_elements (type, valaddr + embedded_offset,
 368                                         address, stream, recurse, options, 0);
 369               fprintf_filtered (stream, "}");
 370             }
 371           break;
 372         }
 373       /* Array of unspecified length: treat like pointer to first elt.  */
 374       print_unpacked_pointer (type, address, address, options, stream);
 375       break;
 376
 377     case TYPE_CODE_PTR:
 378       if (TYPE_CONST (type))
 379         print_variable_at_address (type, valaddr + embedded_offset,
 380                                    stream, recurse, options);
 381       else if (options->format && options->format != 's')
 382         print_scalar_formatted (valaddr + embedded_offset, type,
 383                                 options, 0, stream);
 384       else
 385         {
 386           addr = unpack_pointer (type, valaddr + embedded_offset);
 387           print_unpacked_pointer (type, addr, address, options, stream);
 388         }
 389       break;
 390
 391     case TYPE_CODE_REF:
 392       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 393       if (options->addressprint)
 394         {
 395           CORE_ADDR addr
 396             = extract_typed_address (valaddr + embedded_offset, type);
 397           fprintf_filtered (stream, "@");
 398           fputs_filtered (paddress (addr), stream);
 399           if (options->deref_ref)
 400             fputs_filtered (": ", stream);
 401         }
 402       /* De-reference the reference.  */
 403       if (options->deref_ref)
 404         {
 405           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 406             {
 407               struct value *deref_val =
 408                 value_at
 409                 (TYPE_TARGET_TYPE (type),
 410                  unpack_pointer (type, valaddr + embedded_offset));
 411               common_val_print (deref_val, stream, recurse, options,
 412                                 current_language);
 413             }
 414           else
 415             fputs_filtered ("???", stream);
 416         }
 417       break;
 418
 419     case TYPE_CODE_UNION:
 420       if (recurse && !options->unionprint)
 421         {
 422           fprintf_filtered (stream, "{...}");
 423           break;
 424         }
 425       /* Fall through.  */
 426     case TYPE_CODE_STRUCT:
 427       if (m2_is_long_set (type))
 428         m2_print_long_set (type, valaddr, embedded_offset, address,
 429                            stream);
 430       else if (m2_is_unbounded_array (type))
 431         m2_print_unbounded_array (type, valaddr, embedded_offset,
 432                                   address, stream, recurse, options);
 433       else
 434         cp_print_value_fields (type, type, valaddr, embedded_offset,
 435                                address, stream, recurse, options, NULL, 0);
 436       break;
 437
 438     case TYPE_CODE_ENUM:
 439       if (options->format)
 440         {
 441           print_scalar_formatted (valaddr + embedded_offset, type,
 442                                   options, 0, stream);
 443           break;
 444         }
 445       len = TYPE_NFIELDS (type);
 446       val = unpack_long (type, valaddr + embedded_offset);
 447       for (i = 0; i < len; i++)
 448         {
 449           QUIT;
 450           if (val == TYPE_FIELD_BITPOS (type, i))
 451             {
 452               break;
 453             }
 454         }
 455       if (i < len)
 456         {
 457           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 458         }
 459       else
 460         {
 461           print_longest (stream, 'd', 0, val);
 462         }
 463       break;
 464
 465     case TYPE_CODE_FUNC:
 466       if (options->format)
 467         {
 468           print_scalar_formatted (valaddr + embedded_offset, type,
 469                                   options, 0, stream);
 470           break;
 471         }
 472       /* FIXME, we should consider, at least for ANSI C language, eliminating
 473          the distinction made between FUNCs and POINTERs to FUNCs.  */
 474       fprintf_filtered (stream, "{");
 475       type_print (type, "", stream, -1);
 476       fprintf_filtered (stream, "} ");
 477       /* Try to print what function it points to, and its address.  */
 478       print_address_demangle (address, stream, demangle);
 479       break;
 480
 481     case TYPE_CODE_BOOL:
 482       if (options->format || options->output_format)
 483         {
 484           struct value_print_options opts = *options;
 485           opts.format = (options->format ? options->format
 486                          : options->output_format);
 487           print_scalar_formatted (valaddr + embedded_offset, type,
 488                                   &opts, 0, stream);
 489         }
 490       else
 491         {
 492           val = unpack_long (type, valaddr + embedded_offset);
 493           if (val == 0)
 494             fputs_filtered ("FALSE", stream);
 495           else if (val == 1)
 496             fputs_filtered ("TRUE", stream);
 497           else
 498             fprintf_filtered (stream, "%ld)", (long int) val);
 499         }
 500       break;
 501
 502     case TYPE_CODE_RANGE:
 503       if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
 504         {
 505           m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
 506                         address, stream, recurse, options);
 507           break;
 508         }
 509       /* FIXME: create_range_type does not set the unsigned bit in a
 510          range type (I think it probably should copy it from the target
 511          type), so we won't print values which are too large to
 512          fit in a signed integer correctly.  */
 513       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
 514          print with the target type, though, because the size of our type
 515          and the target type might differ).  */
 516       /* FALLTHROUGH */
 517
 518     case TYPE_CODE_INT:
 519       if (options->format || options->output_format)
 520         {
 521           struct value_print_options opts = *options;
 522           opts.format = (options->format ? options->format
 523                          : options->output_format);
 524           print_scalar_formatted (valaddr + embedded_offset, type,
 525                                   &opts, 0, stream);
 526         }
 527       else
 528         val_print_type_code_int (type, valaddr + embedded_offset, stream);
 529       break;
 530
 531     case TYPE_CODE_CHAR:
 532       if (options->format || options->output_format)
 533         {
 534           struct value_print_options opts = *options;
 535           opts.format = (options->format ? options->format
 536                          : options->output_format);
 537           print_scalar_formatted (valaddr + embedded_offset, type,
 538                                   &opts, 0, stream);
 539         }
 540       else
 541         {
 542           val = unpack_long (type, valaddr + embedded_offset);
 543           if (TYPE_UNSIGNED (type))
 544             fprintf_filtered (stream, "%u", (unsigned int) val);
 545           else
 546             fprintf_filtered (stream, "%d", (int) val);
 547           fputs_filtered (" ", stream);
 548           LA_PRINT_CHAR ((unsigned char) val, type, stream);
 549         }
 550       break;
 551
 552     case TYPE_CODE_FLT:
 553       if (options->format)
 554         print_scalar_formatted (valaddr + embedded_offset, type,
 555                                 options, 0, stream);
 556       else
 557         print_floating (valaddr + embedded_offset, type, stream);
 558       break;
 559
 560     case TYPE_CODE_METHOD:
 561       break;
 562
 563     case TYPE_CODE_BITSTRING:
 564     case TYPE_CODE_SET:
 565       elttype = TYPE_INDEX_TYPE (type);
 566       CHECK_TYPEDEF (elttype);
 567       if (TYPE_STUB (elttype))
 568         {
 569           fprintf_filtered (stream, _("<incomplete type>"));
 570           gdb_flush (stream);
 571           break;
 572         }
 573       else
 574         {
 575           struct type *range = elttype;
 576           LONGEST low_bound, high_bound;
 577           int i;
 578           int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
 579           int need_comma = 0;
 580
 581           if (is_bitstring)
 582             fputs_filtered ("B'", stream);
 583           else
 584             fputs_filtered ("{", stream);
 585
 586           i = get_discrete_bounds (range, &low_bound, &high_bound);
 587         maybe_bad_bstring:
 588           if (i < 0)
 589             {
 590               fputs_filtered (_("<error value>"), stream);
 591               goto done;
 592             }
 593
 594           for (i = low_bound; i <= high_bound; i++)
 595             {
 596               int element = value_bit_index (type, valaddr + embedded_offset,
 597                                              i);
 598               if (element < 0)
 599                 {
 600                   i = element;
 601                   goto maybe_bad_bstring;
 602                 }
 603               if (is_bitstring)
 604                 fprintf_filtered (stream, "%d", element);
 605               else if (element)
 606                 {
 607                   if (need_comma)
 608                     fputs_filtered (", ", stream);
 609                   print_type_scalar (range, i, stream);
 610                   need_comma = 1;
 611
 612                   if (i + 1 <= high_bound
 613                       && value_bit_index (type, valaddr + embedded_offset,
 614                                           ++i))
 615                     {
 616                       int j = i;
 617                       fputs_filtered ("..", stream);
 618                       while (i + 1 <= high_bound
 619                              && value_bit_index (type,
 620                                                  valaddr + embedded_offset,
 621                                                  ++i))
 622                         j = i;
 623                       print_type_scalar (range, j, stream);
 624                     }
 625                 }
 626             }
 627         done:
 628           if (is_bitstring)
 629             fputs_filtered ("'", stream);
 630           else
 631             fputs_filtered ("}", stream);
 632         }
 633       break;
 634
 635     case TYPE_CODE_VOID:
 636       fprintf_filtered (stream, "void");
 637       break;
 638
 639     case TYPE_CODE_ERROR:
 640       fprintf_filtered (stream, _("<error type>"));
 641       break;
 642
 643     case TYPE_CODE_UNDEF:
 644       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
 645          dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
 646          and no complete type for struct foo in that file.  */
 647       fprintf_filtered (stream, _("<incomplete type>"));
 648       break;
 649
 650     default:
 651       error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
 652     }
 653   gdb_flush (stream);
 654   return (0);
 655 }