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, 2011 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, const char *varstring, 71 struct ui_file *stream, 72 int show, int level) 73 { 74 enum type_code code; 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 *of_type; 428 int i; 429 int len = TYPE_NFIELDS (type); 430 LONGEST low; 431 LONGEST high; 432 433 if (m2_is_long_set (type)) 434 { 435 if (TYPE_TAG_NAME (type) != NULL) 436 { 437 fputs_filtered (TYPE_TAG_NAME (type), stream); 438 if (show == 0) 439 return 1; 440 } 441 else if (TYPE_NAME (type) != NULL) 442 { 443 fputs_filtered (TYPE_NAME (type), stream); 444 if (show == 0) 445 return 1; 446 } 447 448 if (TYPE_TAG_NAME (type) != NULL || TYPE_NAME (type) != NULL) 449 fputs_filtered (" = ", stream); 450 451 if (get_long_set_bounds (type, &low, &high)) 452 { 453 fprintf_filtered(stream, "SET OF "); 454 i = TYPE_N_BASECLASSES (type); 455 if (m2_is_long_set_of_type (type, &of_type)) 456 m2_print_type (of_type, "", stream, show - 1, level); 457 else 458 { 459 fprintf_filtered(stream, "["); 460 m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)), 461 stream, show - 1, level, 0); 462 463 fprintf_filtered(stream, ".."); 464 465 m2_print_bounds (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)), 466 stream, show - 1, level, 1); 467 fprintf_filtered(stream, "]"); 468 } 469 } 470 else 471 /* i18n: Do not translate the "SET OF" part! */ 472 fprintf_filtered(stream, _("SET OF <unknown>")); 473 474 return 1; 475 } 476 return 0; 477 } 478 479 /* m2_is_unbounded_array - returns TRUE if, type, should be regarded 480 as a Modula-2 unbounded ARRAY type. */ 481 482 int 483 m2_is_unbounded_array (struct type *type) 484 { 485 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 486 { 487 /* 488 * check if we have a structure with exactly two fields named 489 * _m2_contents and _m2_high. It also checks to see if the 490 * type of _m2_contents is a pointer. The TYPE_TARGET_TYPE 491 * of the pointer determines the unbounded ARRAY OF type. 492 */ 493 if (TYPE_NFIELDS (type) != 2) 494 return 0; 495 if (strcmp (TYPE_FIELD_NAME (type, 0), "_m2_contents") != 0) 496 return 0; 497 if (strcmp (TYPE_FIELD_NAME (type, 1), "_m2_high") != 0) 498 return 0; 499 if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) != TYPE_CODE_PTR) 500 return 0; 501 return 1; 502 } 503 return 0; 504 } 505 506 /* m2_unbounded_array - if the struct type matches a Modula-2 unbounded 507 parameter type then display the type as an 508 ARRAY OF type. Returns TRUE if an unbounded 509 array type was detected. */ 510 511 static int 512 m2_unbounded_array (struct type *type, struct ui_file *stream, int show, 513 int level) 514 { 515 if (m2_is_unbounded_array (type)) 516 { 517 if (show > 0) 518 { 519 fputs_filtered ("ARRAY OF ", stream); 520 m2_print_type (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)), 521 "", stream, 0, level); 522 } 523 return 1; 524 } 525 return 0; 526 } 527 528 void 529 m2_record_fields (struct type *type, struct ui_file *stream, int show, 530 int level) 531 { 532 /* Print the tag if it exists. */ 533 if (TYPE_TAG_NAME (type) != NULL) 534 { 535 if (strncmp (TYPE_TAG_NAME (type), "$$", 2) != 0) 536 { 537 fputs_filtered (TYPE_TAG_NAME (type), stream); 538 if (show > 0) 539 fprintf_filtered (stream, " = "); 540 } 541 } 542 wrap_here (" "); 543 if (show < 0) 544 { 545 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 546 fprintf_filtered (stream, "RECORD ... END "); 547 else if (TYPE_CODE (type) == TYPE_CODE_UNION) 548 fprintf_filtered (stream, "CASE ... END "); 549 } 550 else if (show > 0) 551 { 552 int i; 553 int len = TYPE_NFIELDS (type); 554 555 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 556 fprintf_filtered (stream, "RECORD\n"); 557 else if (TYPE_CODE (type) == TYPE_CODE_UNION) 558 /* i18n: Do not translate "CASE" and "OF". */ 559 fprintf_filtered (stream, _("CASE <variant> OF\n")); 560 561 for (i = TYPE_N_BASECLASSES (type); i < len; i++) 562 { 563 QUIT; 564 565 print_spaces_filtered (level + 4, stream); 566 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 567 fputs_filtered (" : ", stream); 568 m2_print_type (TYPE_FIELD_TYPE (type, i), 569 "", 570 stream, 0, level + 4); 571 if (TYPE_FIELD_PACKED (type, i)) 572 { 573 /* It is a bitfield. This code does not attempt 574 to look at the bitpos and reconstruct filler, 575 unnamed fields. This would lead to misleading 576 results if the compiler does not put out fields 577 for such things (I don't know what it does). */ 578 fprintf_filtered (stream, " : %d", 579 TYPE_FIELD_BITSIZE (type, i)); 580 } 581 fprintf_filtered (stream, ";\n"); 582 } 583 584 fprintfi_filtered (level, stream, "END "); 585 } 586 } 587 588 void 589 m2_enum (struct type *type, struct ui_file *stream, int show, int level) 590 { 591 int lastval, i, len; 592 593 if (show < 0) 594 { 595 /* If we just printed a tag name, no need to print anything else. */ 596 if (TYPE_TAG_NAME (type) == NULL) 597 fprintf_filtered (stream, "(...)"); 598 } 599 else if (show > 0 || TYPE_TAG_NAME (type) == NULL) 600 { 601 fprintf_filtered (stream, "("); 602 len = TYPE_NFIELDS (type); 603 lastval = 0; 604 for (i = 0; i < len; i++) 605 { 606 QUIT; 607 if (i > 0) 608 fprintf_filtered (stream, ", "); 609 wrap_here (" "); 610 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 611 if (lastval != TYPE_FIELD_BITPOS (type, i)) 612 { 613 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i)); 614 lastval = TYPE_FIELD_BITPOS (type, i); 615 } 616 lastval++; 617 } 618 fprintf_filtered (stream, ")"); 619 } 620 } 621