gdb/m2-typeprint.c

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