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