gdb/m2-typeprint.c

   1 /* Support for printing Modula 2 types for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1995, 2000, 2001, 2002, 2003,
   3                  2004, 2005, 2006, 2007, 2008, 2009
   4                  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 "gdb_obstack.h"
  23 #include "bfd.h"                /* Binary File Description */
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "gdbcore.h"
  29 #include "m2-lang.h"
  30 #include "target.h"
  31 #include "language.h"
  32 #include "demangle.h"
  33 #include "c-lang.h"
  34 #include "typeprint.h"
  35 #include "cp-abi.h"
  36
  37 #include "gdb_string.h"
  38 #include <errno.h>
  39
  40 static void m2_print_bounds (struct type *type,
  41                              struct ui_file *stream, int show, int level,
  42                              int print_high);
  43
  44 static void m2_typedef (struct type *, struct ui_file *, int, int);
  45 static void m2_array (struct type *, struct ui_file *, int, int);
  46 static void m2_pointer (struct type *, struct ui_file *, int, int);
  47 static void m2_ref (struct type *, struct ui_file *, int, int);
  48 static void m2_procedure (struct type *, struct ui_file *, int, int);
  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 static void m2_type_name (struct type *type, struct ui_file *stream);
  53 static void m2_short_set (struct type *type, struct ui_file *stream,
  54                           int show, int level);
  55 static int m2_long_set (struct type *type, struct ui_file *stream,
  56                         int show, int level);
  57 static int m2_unbounded_array (struct type *type, struct ui_file *stream,
  58                                int show, int level);
  59 static void m2_record_fields (struct type *type, struct ui_file *stream,
  60                               int show, int level);
  61 static void m2_unknown (const char *s, struct type *type,
  62                         struct ui_file *stream, int show, int level);
  63
  64 int m2_is_long_set (struct type *type);
  65 int m2_is_long_set_of_type (struct type *type, struct type **of_type);
  66 int m2_is_unbounded_array (struct type *type);
  67
  68
  69 void
  70 m2_print_type (struct type *type, char *varstring, struct ui_file *stream,
  71                int show, int level)
  72 {
  73   enum type_code code;
  74   int demangled_args;
  75
  76   CHECK_TYPEDEF (type);
  77
  78   QUIT;
  79
  80   wrap_here ("    ");
  81   if (type == NULL)
  82     {
  83       fputs_filtered (_("<type unknown>"), stream);
  84       return;
  85     }
  86
  87   code = TYPE_CODE (type);
  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)
  96           || m2_unbounded_array (type, stream, show, level))
  97         break;
  98       m2_record_fields (type, stream, show, level);
  99       break;
 100
 101     case TYPE_CODE_TYPEDEF:
 102       m2_typedef (type, stream, show, level);
 103       break;
 104
 105     case TYPE_CODE_ARRAY:
 106       m2_array (type, stream, show, level);
 107       break;
 108
 109     case TYPE_CODE_PTR:
 110       m2_pointer (type, stream, show, level);
 111       break;
 112
 113     case TYPE_CODE_REF:
 114       m2_ref (type, stream, show, level);
 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);
 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);
 147       break;
 148
 149     case TYPE_CODE_TEMPLATE:
 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)
 192 {
 193   if (TYPE_HIGH_BOUND (type) == TYPE_LOW_BOUND (type))
 194     m2_print_type (TYPE_DOMAIN_TYPE (type), "", stream, show, level);
 195   else
 196     {
 197       struct type *target = TYPE_TARGET_TYPE (type);
 198
 199       fprintf_filtered (stream, "[");
 200       print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
 201       fprintf_filtered (stream, "..");
 202       print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
 203       fprintf_filtered (stream, "]");
 204     }
 205 }
 206
 207 static void
 208 m2_typedef (struct type *type, struct ui_file *stream, int show,
 209             int level)
 210 {
 211   if (TYPE_NAME (type) != NULL)
 212     {
 213       fputs_filtered (TYPE_NAME (type), stream);
 214       fputs_filtered (" = ", stream);
 215     }
 216   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 217 }
 218
 219 /* m2_array - prints out a Modula-2 ARRAY ... OF type.  */
 220
 221 static void m2_array (struct type *type, struct ui_file *stream,
 222                       int show, int level)
 223 {
 224   fprintf_filtered (stream, "ARRAY [");
 225   if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 226       && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
 227     {
 228       if (TYPE_INDEX_TYPE (type) != 0)
 229         {
 230           m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 0);
 231           fprintf_filtered (stream, "..");
 232           m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
 233         }
 234       else
 235         fprintf_filtered (stream, "%d",
 236                           (TYPE_LENGTH (type)
 237                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 238     }
 239   fprintf_filtered (stream, "] OF ");
 240   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 241 }
 242
 243 static void
 244 m2_pointer (struct type *type, struct ui_file *stream, int show,
 245             int level)
 246 {
 247   if (TYPE_CONST (type))
 248     fprintf_filtered (stream, "[...] : ");
 249   else
 250     fprintf_filtered (stream, "POINTER TO ");
 251
 252   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 253 }
 254
 255 static void
 256 m2_ref (struct type *type, struct ui_file *stream, int show,
 257         int level)
 258 {
 259   fprintf_filtered (stream, "VAR");
 260   m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 261 }
 262
 263 static void
 264 m2_unknown (const char *s, struct type *type, struct ui_file *stream,
 265             int show, int level)
 266 {
 267   fprintf_filtered (stream, "%s %s", s, _("is unknown"));
 268 }
 269
 270 static void m2_union (struct type *type, struct ui_file *stream)
 271 {
 272   fprintf_filtered (stream, "union");
 273 }
 274
 275 static void
 276 m2_procedure (struct type *type, struct ui_file *stream,
 277               int show, int level)
 278 {
 279   fprintf_filtered (stream, "PROCEDURE ");
 280   m2_type_name (type, stream);
 281   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
 282     {
 283       int i, len = TYPE_NFIELDS (type);
 284
 285       fprintf_filtered (stream, " (");
 286       for (i = 0; i < len; i++)
 287         {
 288           if (i > 0)
 289             {
 290               fputs_filtered (", ", stream);
 291               wrap_here ("    ");
 292             }
 293           m2_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 294         }
 295       if (TYPE_TARGET_TYPE (type) != NULL)
 296         {
 297           fprintf_filtered (stream, " : ");
 298           m2_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
 299         }
 300     }
 301 }
 302
 303 static void
 304 m2_print_bounds (struct type *type,
 305                  struct ui_file *stream, int show, int level,
 306                  int print_high)
 307 {
 308   struct type *target = TYPE_TARGET_TYPE (type);
 309
 310   if (target == NULL)
 311     target = builtin_type_int32;
 312
 313   if (TYPE_NFIELDS(type) == 0)
 314     return;
 315
 316   if (print_high)
 317     print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
 318   else
 319     print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
 320 }
 321
 322 static void
 323 m2_short_set (struct type *type, struct ui_file *stream, int show, int level)
 324 {
 325   fprintf_filtered(stream, "SET [");
 326   m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
 327                    show - 1, level, 0);
 328
 329   fprintf_filtered(stream, "..");
 330   m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
 331                    show - 1, level, 1);
 332   fprintf_filtered(stream, "]");
 333 }
 334
 335 int
 336 m2_is_long_set (struct type *type)
 337 {
 338   LONGEST previous_high = 0;  /* unnecessary initialization
 339                                  keeps gcc -Wall happy */
 340   int len, i;
 341   struct type *range;
 342
 343   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 344     {
 345
 346       /* check if all fields of the RECORD are consecutive sets.  */
 347
 348       len = TYPE_NFIELDS (type);
 349       for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 350         {
 351           if (TYPE_FIELD_TYPE (type, i) == NULL)
 352             return 0;
 353           if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) != TYPE_CODE_SET)
 354             return 0;
 355           if (TYPE_FIELD_NAME (type, i) != NULL
 356               && (strcmp (TYPE_FIELD_NAME (type, i), "") != 0))
 357             return 0;
 358           range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
 359           if ((i > TYPE_N_BASECLASSES (type))
 360               && previous_high + 1 != TYPE_LOW_BOUND (range))
 361             return 0;
 362           previous_high = TYPE_HIGH_BOUND (range);
 363         }
 364       return len>0;
 365     }
 366   return 0;
 367 }
 368
 369 /* m2_get_discrete_bounds - a wrapper for get_discrete_bounds which
 370                             understands that CHARs might be signed.
 371                             This should be integrated into gdbtypes.c
 372                             inside get_discrete_bounds.  */
 373
 374 int
 375 m2_get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
 376 {
 377   CHECK_TYPEDEF (type);
 378   switch (TYPE_CODE (type))
 379     {
 380     case TYPE_CODE_CHAR:
 381       if (TYPE_LENGTH (type) < sizeof (LONGEST))
 382         {
 383           if (!TYPE_UNSIGNED (type))
 384             {
 385               *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
 386               *highp = -*lowp - 1;
 387               return 0;
 388             }
 389         }
 390       /* fall through */
 391     default:
 392       return get_discrete_bounds (type, lowp, highp);
 393     }
 394 }
 395
 396 /* m2_is_long_set_of_type - returns TRUE if the long set was declared as
 397                             SET OF <oftype> of_type is assigned to the
 398                             subtype.  */
 399
 400 int
 401 m2_is_long_set_of_type (struct type *type, struct type **of_type)
 402 {
 403   int len, i;
 404   struct type *range;
 405   struct type *target;
 406   LONGEST l1, l2;
 407   LONGEST h1, h2;
 408
 409   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 410     {
 411       len = TYPE_NFIELDS (type);
 412       i = TYPE_N_BASECLASSES (type);
 413       if (len == 0)
 414         return 0;
 415       range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
 416       target = TYPE_TARGET_TYPE (range);
 417       if (target == NULL)
 418         target = builtin_type_int32;
 419
 420       l1 = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
 421       h1 = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)));
 422       *of_type = target;
 423       if (m2_get_discrete_bounds (target, &l2, &h2) >= 0)
 424         return (l1 == l2 && h1 == h2);
 425       error (_("long_set failed to find discrete bounds for its subtype"));
 426       return 0;
 427     }
 428   error (_("expecting long_set"));
 429   return 0;
 430 }
 431
 432 static int
 433 m2_long_set (struct type *type, struct ui_file *stream, int show, int level)
 434 {
 435   struct type *index_type;
 436   struct type *range_type;
 437   struct type *of_type;
 438   int i;
 439   int len = TYPE_NFIELDS (type);
 440   LONGEST low;
 441   LONGEST high;
 442
 443   if (m2_is_long_set (type))
 444     {
 445       if (TYPE_TAG_NAME (type) != NULL)
 446         {
 447           fputs_filtered (TYPE_TAG_NAME (type), stream);
 448           if (show == 0)
 449             return 1;
 450         }
 451       else if (TYPE_NAME (type) != NULL)
 452         {
 453           fputs_filtered (TYPE_NAME (type), stream);
 454           if (show == 0)
 455             return 1;
 456         }
 457
 458       if (TYPE_TAG_NAME (type) != NULL || TYPE_NAME (type) != NULL)
 459         fputs_filtered (" = ", stream);
 460
 461       if (get_long_set_bounds (type, &low, &high))
 462         {
 463           fprintf_filtered(stream, "SET OF ");
 464           i = TYPE_N_BASECLASSES (type);
 465           if (m2_is_long_set_of_type (type, &of_type))
 466             m2_print_type (of_type, "", stream, show - 1, level);
 467           else
 468             {
 469               fprintf_filtered(stream, "[");
 470               m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)),
 471                                stream, show - 1, level, 0);
 472
 473               fprintf_filtered(stream, "..");
 474
 475               m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)),
 476                                stream, show - 1, level, 1);
 477               fprintf_filtered(stream, "]");
 478             }
 479         }
 480       else
 481         /* i18n: Do not translate the "SET OF" part! */
 482         fprintf_filtered(stream, _("SET OF <unknown>"));
 483
 484       return 1;
 485     }
 486   return 0;
 487 }
 488
 489 /* m2_is_unbounded_array - returns TRUE if, type, should be regarded
 490                            as a Modula-2 unbounded ARRAY type.  */
 491
 492 int
 493 m2_is_unbounded_array (struct type *type)
 494 {
 495   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 496     {
 497       /*
 498        *  check if we have a structure with exactly two fields named
 499        *  _m2_contents and _m2_high.  It also checks to see if the
 500        *  type of _m2_contents is a pointer.  The TYPE_TARGET_TYPE
 501        *  of the pointer determines the unbounded ARRAY OF type.
 502        */
 503       if (TYPE_NFIELDS (type) != 2)
 504         return 0;
 505       if (strcmp (TYPE_FIELD_NAME (type, 0), "_m2_contents") != 0)
 506         return 0;
 507       if (strcmp (TYPE_FIELD_NAME (type, 1), "_m2_high") != 0)
 508         return 0;
 509       if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) != TYPE_CODE_PTR)
 510         return 0;
 511       return 1;
 512     }
 513   return 0;
 514 }
 515
 516 /* m2_unbounded_array - if the struct type matches a Modula-2 unbounded
 517                         parameter type then display the type as an
 518                         ARRAY OF type.  Returns TRUE if an unbounded
 519                         array type was detected.  */
 520
 521 static int
 522 m2_unbounded_array (struct type *type, struct ui_file *stream, int show,
 523                     int level)
 524 {
 525   if (m2_is_unbounded_array (type))
 526     {
 527       if (show > 0)
 528         {
 529           fputs_filtered ("ARRAY OF ", stream);
 530           m2_print_type (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
 531                          "", stream, 0, level);
 532         }
 533       return 1;
 534     }
 535   return 0;
 536 }
 537
 538 void
 539 m2_record_fields (struct type *type, struct ui_file *stream, int show,
 540                   int level)
 541 {
 542   /* Print the tag if it exists.  */
 543   if (TYPE_TAG_NAME (type) != NULL)
 544     {
 545       if (strncmp (TYPE_TAG_NAME (type), "$$", 2) != 0)
 546         {
 547           fputs_filtered (TYPE_TAG_NAME (type), stream);
 548           if (show > 0)
 549             fprintf_filtered (stream, " = ");
 550         }
 551     }
 552   wrap_here ("    ");
 553   if (show < 0)
 554     {
 555       if (TYPE_CODE (type) == DECLARED_TYPE_STRUCT)
 556         fprintf_filtered (stream, "RECORD ... END ");
 557       else if (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION)
 558         fprintf_filtered (stream, "CASE ... END ");
 559     }
 560   else if (show > 0)
 561     {
 562       int i;
 563       int len = TYPE_NFIELDS (type);
 564
 565       if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 566         fprintf_filtered (stream, "RECORD\n");
 567       else if (TYPE_CODE (type) == TYPE_CODE_UNION)
 568         /* i18n: Do not translate "CASE" and "OF" */
 569         fprintf_filtered (stream, _("CASE <variant> OF\n"));
 570
 571       for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 572         {
 573           QUIT;
 574
 575           print_spaces_filtered (level + 4, stream);
 576           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 577           fputs_filtered (" : ", stream);
 578           m2_print_type (TYPE_FIELD_TYPE (type, i),
 579                          "",
 580                          stream, 0, level + 4);
 581           if (TYPE_FIELD_PACKED (type, i))
 582             {
 583               /* It is a bitfield.  This code does not attempt
 584                  to look at the bitpos and reconstruct filler,
 585                  unnamed fields.  This would lead to misleading
 586                  results if the compiler does not put out fields
 587                  for such things (I don't know what it does).  */
 588               fprintf_filtered (stream, " : %d",
 589                                 TYPE_FIELD_BITSIZE (type, i));
 590             }
 591           fprintf_filtered (stream, ";\n");
 592         }
 593
 594       fprintfi_filtered (level, stream, "END ");
 595     }
 596 }
 597
 598 void
 599 m2_enum (struct type *type, struct ui_file *stream, int show, int level)
 600 {
 601   int lastval, i, len;
 602
 603   if (show < 0)
 604     {
 605       /* If we just printed a tag name, no need to print anything else.  */
 606       if (TYPE_TAG_NAME (type) == NULL)
 607         fprintf_filtered (stream, "(...)");
 608     }
 609   else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 610     {
 611       fprintf_filtered (stream, "(");
 612       len = TYPE_NFIELDS (type);
 613       lastval = 0;
 614       for (i = 0; i < len; i++)
 615         {
 616           QUIT;
 617           if (i > 0)
 618             fprintf_filtered (stream, ", ");
 619           wrap_here ("    ");
 620           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 621           if (lastval != TYPE_FIELD_BITPOS (type, i))
 622             {
 623               fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
 624               lastval = TYPE_FIELD_BITPOS (type, i);
 625             }
 626           lastval++;
 627         }
 628       fprintf_filtered (stream, ")");
 629     }
 630 }