1 /* Support for printing Modula 2 types for GDB, the GNU debugger. 2 Copyright (C) 1986-2016 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 } 629