contrib/gdb-7/gdb/m2-typeprint.c

   1 /* Support for printing Modula 2 types for GDB, the GNU debugger.
   2    Copyright (C) 1986-2013 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "gdb_obstack.h"
  21 #include "bfd.h"                /* Binary File Description */
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "m2-lang.h"
  28 #include "target.h"
  29 #include "language.h"
  30 #include "demangle.h"
  31 #include "c-lang.h"
  32 #include "typeprint.h"
  33 #include "cp-abi.h"
  34
  35 #include "gdb_string.h"
  36 #include <errno.h>
  37
  38 static void m2_print_bounds (struct type *type,
  39                              struct ui_file *stream, int show, int level,
  40                              int print_high);
  41
  42 static void m2_typedef (struct type *, struct ui_file *, int, int,
  43                         const struct type_print_options *);
  44 static void m2_array (struct type *, struct ui_file *, int, int,
  45                       const struct type_print_options *);
  46 static void m2_pointer (struct type *, struct ui_file *, int, int,
  47                         const struct type_print_options *);
  48 static void m2_ref (struct type *, struct ui_file *, int, int,
  49                     const struct type_print_options *);
  50 static void m2_procedure (struct type *, struct ui_file *, int, int,
  51                           const struct type_print_options *);
  52 static void m2_union (struct type *, struct ui_file *);
  53 static void m2_enum (struct type *, struct ui_file *, int, int);
  54 static void m2_range (struct type *, struct ui_file *, int, int,
  55                       const struct type_print_options *);
  56 static void m2_type_name (struct type *type, struct ui_file *stream);
  57 static void m2_short_set (struct type *type, struct ui_file *stream,
  58                           int show, int level);
  59 static int m2_long_set (struct type *type, struct ui_file *stream,
  60                         int show, int level, const struct type_print_options *flags);
  61 static int m2_unbounded_array (struct type *type, struct ui_file *stream,
  62                                int show, int level,
  63                                const struct type_print_options *flags);
  64 static void m2_record_fields (struct type *type, struct ui_file *stream,
  65                               int show, int level, const struct type_print_options *flags);
  66 static void m2_unknown (const char *s, struct type *type,
  67                         struct ui_file *stream, int show, int level);
  68
  69 int m2_is_long_set (struct type *type);
  70 int m2_is_long_set_of_type (struct type *type, struct type **of_type);
  71 int m2_is_unbounded_array (struct type *type);
  72
  73
  74 void
  75 m2_print_type (struct type *type, const char *varstring,
  76                struct ui_file *stream,
  77                int show, int level,
  78                const struct type_print_options *flags)
  79 {
  80   CHECK_TYPEDEF (type);
  81
  82   QUIT;
  83
  84   wrap_here ("    ");
  85   if (type == NULL)
  86     {
  87       fputs_filtered (_("<type unknown>"), stream);
  88       return;
  89     }
  90
  91   switch (TYPE_CODE (type))
  92     {
  93     case TYPE_CODE_SET:
  94       m2_short_set(type, stream, show, level);
  95       break;
  96
  97     case TYPE_CODE_STRUCT:
  98       if (m2_long_set (type, stream, show, level, flags)
  99           || m2_unbounded_array (type, stream, show, level, flags))
 100         break;
 101       m2_record_fields (type, stream, show, level, flags);
 102       break;
 103
 104     case TYPE_CODE_TYPEDEF:
 105       m2_typedef (type, stream, show, level, flags);
 106       break;
 107
 108     case TYPE_CODE_ARRAY:
 109       m2_array (type, stream, show, level, flags);
 110       break;
 111
 112     case TYPE_CODE_PTR:
 113       m2_pointer (type, stream, show, level, flags);
 114       break;
 115
 116     case TYPE_CODE_REF:
 117       m2_ref (type, stream, show, level, flags);
 118       break;
 119
 120     case TYPE_CODE_METHOD:
 121       m2_unknown (_("method"), type, stream, show, level);
 122       break;
 123
 124     case TYPE_CODE_FUNC:
 125       m2_procedure (type, stream, show, level, flags);
 126       break;
 127
 128     case TYPE_CODE_UNION:
 129       m2_union (type, stream);
 130       break;
 131
 132     case TYPE_CODE_ENUM:
 133       m2_enum (type, stream, show, level);
 134       break;
 135
 136     case TYPE_CODE_VOID:
 137       break;
 138
 139     case TYPE_CODE_UNDEF:
 140       /* i18n: Do not translate the "struct" part!  */
 141       m2_unknown (_("undef"), type, stream, show, level);
 142       break;
 143
 144     case TYPE_CODE_ERROR:
 145       m2_unknown (_("error"), type, stream, show, level);
 146       break;
 147
 148     case TYPE_CODE_RANGE:
 149       m2_range (type, stream, show, level, flags);
 150       break;
 151
 152     default:
 153       m2_type_name (type, stream);
 154       break;
 155     }
 156 }
 157
 158 /* Print a typedef using M2 syntax.  TYPE is the underlying type.
 159    NEW_SYMBOL is the symbol naming the type.  STREAM is the stream on
 160    which to print.  */
 161
 162 void
 163 m2_print_typedef (struct type *type, struct symbol *new_symbol,
 164                   struct ui_file *stream)
 165 {
 166   CHECK_TYPEDEF (type);
 167   fprintf_filtered (stream, "TYPE ");
 168   if (!TYPE_NAME (SYMBOL_TYPE (new_symbol))
 169       || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
 170                  SYMBOL_LINKAGE_NAME (new_symbol)) != 0)
 171     fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new_symbol));
 172   else
 173     fprintf_filtered (stream, "<builtin> = ");
 174   type_print (type, "", stream, 0);
 175   fprintf_filtered (stream, ";\n");
 176 }
 177
 178 /* m2_type_name - if a, type, has a name then print it.  */
 179
 180 void
 181 m2_type_name (struct type *type, struct ui_file *stream)
 182 {
 183   if (TYPE_NAME (type) != NULL)
 184     fputs_filtered (TYPE_NAME (type), stream);
 185 }
 186
 187 /* m2_range - displays a Modula-2 subrange type.  */
 188
 189 void
 190 m2_range (struct type *type, struct ui_file *stream, int show,
 191           int level, const struct type_print_options *flags)
 192 {
 193   if (TYPE_HIGH_BOUND (type) == TYPE_LOW_BOUND (type))
 194     m2_print_type (TYPE_DOMAIN_TYPE (type), "", stream, show, level,
 195                    flags);
 196   else
 197     {
 198       struct type *target = TYPE_TARGET_TYPE (type);
 199
 200       fprintf_filtered (stream, "[");
 201       print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
 202       fprintf_filtered (stream, "..");
 203       print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
 204       fprintf_filtered (stream, "]");
 205     }
 206 }
 207
 208 static void
 209 m2_typedef (struct type *type, struct ui_file *stream, int show,
 210             int level, const struct type_print_options *flags)
 211 {
 212   if (TYPE_NAME (type) != NULL)
 213     {
 214       fputs_filtered (TYPE_NAME (type), stream);
 215       fputs_filtered (" = ", stream);
 216     }
 217   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
 218 }
 219
 220 /* m2_array - prints out a Modula-2 ARRAY ... OF type.  */
 221
 222 static void m2_array (struct type *type, struct ui_file *stream,
 223                       int show, int level, const struct type_print_options *flags)
 224 {
 225   fprintf_filtered (stream, "ARRAY [");
 226   if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 227       && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
 228     {
 229       if (TYPE_INDEX_TYPE (type) != 0)
 230         {
 231           m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 0);
 232           fprintf_filtered (stream, "..");
 233           m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
 234         }
 235       else
 236         fprintf_filtered (stream, "%d",
 237                           (TYPE_LENGTH (type)
 238                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 239     }
 240   fprintf_filtered (stream, "] OF ");
 241   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
 242 }
 243
 244 static void
 245 m2_pointer (struct type *type, struct ui_file *stream, int show,
 246             int level, const struct type_print_options *flags)
 247 {
 248   if (TYPE_CONST (type))
 249     fprintf_filtered (stream, "[...] : ");
 250   else
 251     fprintf_filtered (stream, "POINTER TO ");
 252
 253   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
 254 }
 255
 256 static void
 257 m2_ref (struct type *type, struct ui_file *stream, int show,
 258         int level, const struct type_print_options *flags)
 259 {
 260   fprintf_filtered (stream, "VAR");
 261   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
 262 }
 263
 264 static void
 265 m2_unknown (const char *s, struct type *type, struct ui_file *stream,
 266             int show, int level)
 267 {
 268   fprintf_filtered (stream, "%s %s", s, _("is unknown"));
 269 }
 270
 271 static void m2_union (struct type *type, struct ui_file *stream)
 272 {
 273   fprintf_filtered (stream, "union");
 274 }
 275
 276 static void
 277 m2_procedure (struct type *type, struct ui_file *stream,
 278               int show, int level, const struct type_print_options *flags)
 279 {
 280   fprintf_filtered (stream, "PROCEDURE ");
 281   m2_type_name (type, stream);
 282   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
 283     {
 284       int i, len = TYPE_NFIELDS (type);
 285
 286       fprintf_filtered (stream, " (");
 287       for (i = 0; i < len; i++)
 288         {
 289           if (i > 0)
 290             {
 291               fputs_filtered (", ", stream);
 292               wrap_here ("    ");
 293             }
 294           m2_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0, flags);
 295         }
 296       if (TYPE_TARGET_TYPE (type) != NULL)
 297         {
 298           fprintf_filtered (stream, " : ");
 299           m2_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
 300         }
 301     }
 302 }
 303
 304 static void
 305 m2_print_bounds (struct type *type,
 306                  struct ui_file *stream, int show, int level,
 307                  int print_high)
 308 {
 309   struct type *target = TYPE_TARGET_TYPE (type);
 310
 311   if (TYPE_NFIELDS(type) == 0)
 312     return;
 313
 314   if (print_high)
 315     print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
 316   else
 317     print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
 318 }
 319
 320 static void
 321 m2_short_set (struct type *type, struct ui_file *stream, int show, int level)
 322 {
 323   fprintf_filtered(stream, "SET [");
 324   m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
 325                    show - 1, level, 0);
 326
 327   fprintf_filtered(stream, "..");
 328   m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
 329                    show - 1, level, 1);
 330   fprintf_filtered(stream, "]");
 331 }
 332
 333 int
 334 m2_is_long_set (struct type *type)
 335 {
 336   LONGEST previous_high = 0;  /* Unnecessary initialization
 337                                  keeps gcc -Wall happy.  */
 338   int len, i;
 339   struct type *range;
 340
 341   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 342     {
 343
 344       /* check if all fields of the RECORD are consecutive sets.  */
 345
 346       len = TYPE_NFIELDS (type);
 347       for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 348         {
 349           if (TYPE_FIELD_TYPE (type, i) == NULL)
 350             return 0;
 351           if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) != TYPE_CODE_SET)
 352             return 0;
 353           if (TYPE_FIELD_NAME (type, i) != NULL
 354               && (strcmp (TYPE_FIELD_NAME (type, i), "") != 0))
 355             return 0;
 356           range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
 357           if ((i > TYPE_N_BASECLASSES (type))
 358               && previous_high + 1 != TYPE_LOW_BOUND (range))
 359             return 0;
 360           previous_high = TYPE_HIGH_BOUND (range);
 361         }
 362       return len>0;
 363     }
 364   return 0;
 365 }
 366
 367 /* m2_get_discrete_bounds - a wrapper for get_discrete_bounds which
 368                             understands that CHARs might be signed.
 369                             This should be integrated into gdbtypes.c
 370                             inside get_discrete_bounds.  */
 371
 372 static int
 373 m2_get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
 374 {
 375   CHECK_TYPEDEF (type);
 376   switch (TYPE_CODE (type))
 377     {
 378     case TYPE_CODE_CHAR:
 379       if (TYPE_LENGTH (type) < sizeof (LONGEST))
 380         {
 381           if (!TYPE_UNSIGNED (type))
 382             {
 383               *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
 384               *highp = -*lowp - 1;
 385               return 0;
 386             }
 387         }
 388       /* fall through */
 389     default:
 390       return get_discrete_bounds (type, lowp, highp);
 391     }
 392 }
 393
 394 /* m2_is_long_set_of_type - returns TRUE if the long set was declared as
 395                             SET OF <oftype> of_type is assigned to the
 396                             subtype.  */
 397
 398 int
 399 m2_is_long_set_of_type (struct type *type, struct type **of_type)
 400 {
 401   int len, i;
 402   struct type *range;
 403   struct type *target;
 404   LONGEST l1, l2;
 405   LONGEST h1, h2;
 406
 407   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 408     {
 409       len = TYPE_NFIELDS (type);
 410       i = TYPE_N_BASECLASSES (type);
 411       if (len == 0)
 412         return 0;
 413       range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
 414       target = TYPE_TARGET_TYPE (range);
 415
 416       l1 = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
 417       h1 = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)));
 418       *of_type = target;
 419       if (m2_get_discrete_bounds (target, &l2, &h2) >= 0)
 420         return (l1 == l2 && h1 == h2);
 421       error (_("long_set failed to find discrete bounds for its subtype"));
 422       return 0;
 423     }
 424   error (_("expecting long_set"));
 425   return 0;
 426 }
 427
 428 static int
 429 m2_long_set (struct type *type, struct ui_file *stream, int show, int level,
 430              const struct type_print_options *flags)
 431 {
 432   struct type *of_type;
 433   int i;
 434   int len = TYPE_NFIELDS (type);
 435   LONGEST low;
 436   LONGEST high;
 437
 438   if (m2_is_long_set (type))
 439     {
 440       if (TYPE_TAG_NAME (type) != NULL)
 441         {
 442           fputs_filtered (TYPE_TAG_NAME (type), stream);
 443           if (show == 0)
 444             return 1;
 445         }
 446       else if (TYPE_NAME (type) != NULL)
 447         {
 448           fputs_filtered (TYPE_NAME (type), stream);
 449           if (show == 0)
 450             return 1;
 451         }
 452
 453       if (TYPE_TAG_NAME (type) != NULL || TYPE_NAME (type) != NULL)
 454         fputs_filtered (" = ", stream);
 455
 456       if (get_long_set_bounds (type, &low, &high))
 457         {
 458           fprintf_filtered(stream, "SET OF ");
 459           i = TYPE_N_BASECLASSES (type);
 460           if (m2_is_long_set_of_type (type, &of_type))
 461             m2_print_type (of_type, "", stream, show - 1, level, flags);
 462           else
 463             {
 464               fprintf_filtered(stream, "[");
 465               m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)),
 466                                stream, show - 1, level, 0);
 467
 468               fprintf_filtered(stream, "..");
 469
 470               m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)),
 471                                stream, show - 1, level, 1);
 472               fprintf_filtered(stream, "]");
 473             }
 474         }
 475       else
 476         /* i18n: Do not translate the "SET OF" part!  */
 477         fprintf_filtered(stream, _("SET OF <unknown>"));
 478
 479       return 1;
 480     }
 481   return 0;
 482 }
 483
 484 /* m2_is_unbounded_array - returns TRUE if, type, should be regarded
 485                            as a Modula-2 unbounded ARRAY type.  */
 486
 487 int
 488 m2_is_unbounded_array (struct type *type)
 489 {
 490   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 491     {
 492       /*
 493        *  check if we have a structure with exactly two fields named
 494        *  _m2_contents and _m2_high.  It also checks to see if the
 495        *  type of _m2_contents is a pointer.  The TYPE_TARGET_TYPE
 496        *  of the pointer determines the unbounded ARRAY OF type.
 497        */
 498       if (TYPE_NFIELDS (type) != 2)
 499         return 0;
 500       if (strcmp (TYPE_FIELD_NAME (type, 0), "_m2_contents") != 0)
 501         return 0;
 502       if (strcmp (TYPE_FIELD_NAME (type, 1), "_m2_high") != 0)
 503         return 0;
 504       if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) != TYPE_CODE_PTR)
 505         return 0;
 506       return 1;
 507     }
 508   return 0;
 509 }
 510
 511 /* m2_unbounded_array - if the struct type matches a Modula-2 unbounded
 512                         parameter type then display the type as an
 513                         ARRAY OF type.  Returns TRUE if an unbounded
 514                         array type was detected.  */
 515
 516 static int
 517 m2_unbounded_array (struct type *type, struct ui_file *stream, int show,
 518                     int level, const struct type_print_options *flags)
 519 {
 520   if (m2_is_unbounded_array (type))
 521     {
 522       if (show > 0)
 523         {
 524           fputs_filtered ("ARRAY OF ", stream);
 525           m2_print_type (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
 526                          "", stream, 0, level, flags);
 527         }
 528       return 1;
 529     }
 530   return 0;
 531 }
 532
 533 void
 534 m2_record_fields (struct type *type, struct ui_file *stream, int show,
 535                   int level, const struct type_print_options *flags)
 536 {
 537   /* Print the tag if it exists.  */
 538   if (TYPE_TAG_NAME (type) != NULL)
 539     {
 540       if (strncmp (TYPE_TAG_NAME (type), "$$", 2) != 0)
 541         {
 542           fputs_filtered (TYPE_TAG_NAME (type), stream);
 543           if (show > 0)
 544             fprintf_filtered (stream, " = ");
 545         }
 546     }
 547   wrap_here ("    ");
 548   if (show < 0)
 549     {
 550       if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 551         fprintf_filtered (stream, "RECORD ... END ");
 552       else if (TYPE_CODE (type) == TYPE_CODE_UNION)
 553         fprintf_filtered (stream, "CASE ... END ");
 554     }
 555   else if (show > 0)
 556     {
 557       int i;
 558       int len = TYPE_NFIELDS (type);
 559
 560       if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 561         fprintf_filtered (stream, "RECORD\n");
 562       else if (TYPE_CODE (type) == TYPE_CODE_UNION)
 563         /* i18n: Do not translate "CASE" and "OF".  */
 564         fprintf_filtered (stream, _("CASE <variant> OF\n"));
 565
 566       for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 567         {
 568           QUIT;
 569
 570           print_spaces_filtered (level + 4, stream);
 571           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 572           fputs_filtered (" : ", stream);
 573           m2_print_type (TYPE_FIELD_TYPE (type, i),
 574                          "",
 575                          stream, 0, level + 4, flags);
 576           if (TYPE_FIELD_PACKED (type, i))
 577             {
 578               /* It is a bitfield.  This code does not attempt
 579                  to look at the bitpos and reconstruct filler,
 580                  unnamed fields.  This would lead to misleading
 581                  results if the compiler does not put out fields
 582                  for such things (I don't know what it does).  */
 583               fprintf_filtered (stream, " : %d",
 584                                 TYPE_FIELD_BITSIZE (type, i));
 585             }
 586           fprintf_filtered (stream, ";\n");
 587         }
 588
 589       fprintfi_filtered (level, stream, "END ");
 590     }
 591 }
 592
 593 void
 594 m2_enum (struct type *type, struct ui_file *stream, int show, int level)
 595 {
 596   LONGEST lastval;
 597   int i, len;
 598
 599   if (show < 0)
 600     {
 601       /* If we just printed a tag name, no need to print anything else.  */
 602       if (TYPE_TAG_NAME (type) == NULL)
 603         fprintf_filtered (stream, "(...)");
 604     }
 605   else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 606     {
 607       fprintf_filtered (stream, "(");
 608       len = TYPE_NFIELDS (type);
 609       lastval = 0;
 610       for (i = 0; i < len; i++)
 611         {
 612           QUIT;
 613           if (i > 0)
 614             fprintf_filtered (stream, ", ");
 615           wrap_here ("    ");
 616           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 617           if (lastval != TYPE_FIELD_ENUMVAL (type, i))
 618             {
 619               fprintf_filtered (stream, " = %s",
 620                                 plongest (TYPE_FIELD_ENUMVAL (type, i)));
 621               lastval = TYPE_FIELD_ENUMVAL (type, i);
 622             }
 623           lastval++;
 624         }
 625       fprintf_filtered (stream, ")");
 626     }
 627 }