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 (TYPE_NFIELDS(type) == 0) 311 return; 312 313 if (print_high) 314 print_type_scalar (target, TYPE_HIGH_BOUND (type), stream); 315 else 316 print_type_scalar (target, TYPE_LOW_BOUND (type), stream); 317 } 318 319 static void 320 m2_short_set (struct type *type, struct ui_file *stream, int show, int level) 321 { 322 fprintf_filtered(stream, "SET ["); 323 m2_print_bounds (TYPE_INDEX_TYPE (type), stream, 324 show - 1, level, 0); 325 326 fprintf_filtered(stream, ".."); 327 m2_print_bounds (TYPE_INDEX_TYPE (type), stream, 328 show - 1, level, 1); 329 fprintf_filtered(stream, "]"); 330 } 331 332 int 333 m2_is_long_set (struct type *type) 334 { 335 LONGEST previous_high = 0; /* unnecessary initialization 336 keeps gcc -Wall happy */ 337 int len, i; 338 struct type *range; 339 340 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 341 { 342 343 /* check if all fields of the RECORD are consecutive sets. */ 344 345 len = TYPE_NFIELDS (type); 346 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 347 { 348 if (TYPE_FIELD_TYPE (type, i) == NULL) 349 return 0; 350 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) != TYPE_CODE_SET) 351 return 0; 352 if (TYPE_FIELD_NAME (type, i) != NULL 353 && (strcmp (TYPE_FIELD_NAME (type, i), "") != 0)) 354 return 0; 355 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)); 356 if ((i > TYPE_N_BASECLASSES (type)) 357 && previous_high + 1 != TYPE_LOW_BOUND (range)) 358 return 0; 359 previous_high = TYPE_HIGH_BOUND (range); 360 } 361 return len>0; 362 } 363 return 0; 364 } 365 366 /* m2_get_discrete_bounds - a wrapper for get_discrete_bounds which 367 understands that CHARs might be signed. 368 This should be integrated into gdbtypes.c 369 inside get_discrete_bounds. */ 370 371 static int 372 m2_get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) 373 { 374 CHECK_TYPEDEF (type); 375 switch (TYPE_CODE (type)) 376 { 377 case TYPE_CODE_CHAR: 378 if (TYPE_LENGTH (type) < sizeof (LONGEST)) 379 { 380 if (!TYPE_UNSIGNED (type)) 381 { 382 *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); 383 *highp = -*lowp - 1; 384 return 0; 385 } 386 } 387 /* fall through */ 388 default: 389 return get_discrete_bounds (type, lowp, highp); 390 } 391 } 392 393 /* m2_is_long_set_of_type - returns TRUE if the long set was declared as 394 SET OF <oftype> of_type is assigned to the 395 subtype. */ 396 397 int 398 m2_is_long_set_of_type (struct type *type, struct type **of_type) 399 { 400 int len, i; 401 struct type *range; 402 struct type *target; 403 LONGEST l1, l2; 404 LONGEST h1, h2; 405 406 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 407 { 408 len = TYPE_NFIELDS (type); 409 i = TYPE_N_BASECLASSES (type); 410 if (len == 0) 411 return 0; 412 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)); 413 target = TYPE_TARGET_TYPE (range); 414 415 l1 = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i))); 416 h1 = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1))); 417 *of_type = target; 418 if (m2_get_discrete_bounds (target, &l2, &h2) >= 0) 419 return (l1 == l2 && h1 == h2); 420 error (_("long_set failed to find discrete bounds for its subtype")); 421 return 0; 422 } 423 error (_("expecting long_set")); 424 return 0; 425 } 426 427 static int 428 m2_long_set (struct type *type, struct ui_file *stream, int show, int level) 429 { 430 struct type *index_type; 431 struct type *range_type; 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); 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) 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); 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) 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) == DECLARED_TYPE_STRUCT) 551 fprintf_filtered (stream, "RECORD ... END "); 552 else if (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_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); 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 int lastval, i, len; 597 598 if (show < 0) 599 { 600 /* If we just printed a tag name, no need to print anything else. */ 601 if (TYPE_TAG_NAME (type) == NULL) 602 fprintf_filtered (stream, "(...)"); 603 } 604 else if (show > 0 || TYPE_TAG_NAME (type) == NULL) 605 { 606 fprintf_filtered (stream, "("); 607 len = TYPE_NFIELDS (type); 608 lastval = 0; 609 for (i = 0; i < len; i++) 610 { 611 QUIT; 612 if (i > 0) 613 fprintf_filtered (stream, ", "); 614 wrap_here (" "); 615 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 616 if (lastval != TYPE_FIELD_BITPOS (type, i)) 617 { 618 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i)); 619 lastval = TYPE_FIELD_BITPOS (type, i); 620 } 621 lastval++; 622 } 623 fprintf_filtered (stream, ")"); 624 } 625 } 626