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