1 /* Support for printing Modula 2 values for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006, 4 2007, 2008, 2009, 2010 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 "symtab.h" 23 #include "gdbtypes.h" 24 #include "expression.h" 25 #include "value.h" 26 #include "valprint.h" 27 #include "language.h" 28 #include "typeprint.h" 29 #include "c-lang.h" 30 #include "m2-lang.h" 31 #include "target.h" 32 33 static int print_unpacked_pointer (struct type *type, 34 CORE_ADDR address, CORE_ADDR addr, 35 const struct value_print_options *options, 36 struct ui_file *stream); 37 static void 38 m2_print_array_contents (struct type *type, const gdb_byte *valaddr, 39 int embedded_offset, CORE_ADDR address, 40 struct ui_file *stream, int recurse, 41 const struct value *val, 42 const struct value_print_options *options, 43 int len); 44 45 46 /* Print function pointer with inferior address ADDRESS onto stdio 47 stream STREAM. */ 48 49 static void 50 print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address, 51 struct ui_file *stream, int addressprint) 52 { 53 CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address, 54 ¤t_target); 55 56 /* If the function pointer is represented by a description, print the 57 address of the description. */ 58 if (addressprint && func_addr != address) 59 { 60 fputs_filtered ("@", stream); 61 fputs_filtered (paddress (gdbarch, address), stream); 62 fputs_filtered (": ", stream); 63 } 64 print_address_demangle (gdbarch, func_addr, stream, demangle); 65 } 66 67 /* get_long_set_bounds - assigns the bounds of the long set to low and 68 high. */ 69 70 int 71 get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high) 72 { 73 int len, i; 74 75 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 76 { 77 len = TYPE_NFIELDS (type); 78 i = TYPE_N_BASECLASSES (type); 79 if (len == 0) 80 return 0; 81 *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i))); 82 *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, 83 len-1))); 84 return 1; 85 } 86 error (_("expecting long_set")); 87 return 0; 88 } 89 90 static void 91 m2_print_long_set (struct type *type, const gdb_byte *valaddr, 92 int embedded_offset, CORE_ADDR address, 93 struct ui_file *stream) 94 { 95 int empty_set = 1; 96 int element_seen = 0; 97 LONGEST previous_low = 0; 98 LONGEST previous_high= 0; 99 LONGEST i, low_bound, high_bound; 100 LONGEST field_low, field_high; 101 struct type *range; 102 int len, field; 103 struct type *target; 104 int bitval; 105 106 CHECK_TYPEDEF (type); 107 108 fprintf_filtered (stream, "{"); 109 len = TYPE_NFIELDS (type); 110 if (get_long_set_bounds (type, &low_bound, &high_bound)) 111 { 112 field = TYPE_N_BASECLASSES (type); 113 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); 114 } 115 else 116 { 117 fprintf_filtered (stream, " %s }", _("<unknown bounds of set>")); 118 return; 119 } 120 121 target = TYPE_TARGET_TYPE (range); 122 123 if (get_discrete_bounds (range, &field_low, &field_high) >= 0) 124 { 125 for (i = low_bound; i <= high_bound; i++) 126 { 127 bitval = value_bit_index (TYPE_FIELD_TYPE (type, field), 128 (TYPE_FIELD_BITPOS (type, field) / 8) + 129 valaddr + embedded_offset, i); 130 if (bitval < 0) 131 error (_("bit test is out of range")); 132 else if (bitval > 0) 133 { 134 previous_high = i; 135 if (! element_seen) 136 { 137 if (! empty_set) 138 fprintf_filtered (stream, ", "); 139 print_type_scalar (target, i, stream); 140 empty_set = 0; 141 element_seen = 1; 142 previous_low = i; 143 } 144 } 145 else 146 { 147 /* bit is not set */ 148 if (element_seen) 149 { 150 if (previous_low+1 < previous_high) 151 fprintf_filtered (stream, ".."); 152 if (previous_low+1 < previous_high) 153 print_type_scalar (target, previous_high, stream); 154 element_seen = 0; 155 } 156 } 157 if (i == field_high) 158 { 159 field++; 160 if (field == len) 161 break; 162 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); 163 if (get_discrete_bounds (range, &field_low, &field_high) < 0) 164 break; 165 target = TYPE_TARGET_TYPE (range); 166 } 167 } 168 if (element_seen) 169 { 170 if (previous_low+1 < previous_high) 171 { 172 fprintf_filtered (stream, ".."); 173 print_type_scalar (target, previous_high, stream); 174 } 175 element_seen = 0; 176 } 177 fprintf_filtered (stream, "}"); 178 } 179 } 180 181 static void 182 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr, 183 int embedded_offset, CORE_ADDR address, 184 struct ui_file *stream, int recurse, 185 const struct value_print_options *options) 186 { 187 struct type *content_type; 188 CORE_ADDR addr; 189 LONGEST len; 190 struct value *val; 191 192 CHECK_TYPEDEF (type); 193 content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)); 194 195 addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0), 196 (TYPE_FIELD_BITPOS (type, 0) / 8) + 197 valaddr + embedded_offset); 198 199 val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)), 200 addr); 201 len = unpack_field_as_long (type, valaddr + embedded_offset, 1); 202 203 fprintf_filtered (stream, "{"); 204 m2_print_array_contents (value_type (val), value_contents(val), 205 value_embedded_offset (val), addr, stream, 206 recurse, NULL, options, len); 207 fprintf_filtered (stream, ", HIGH = %d}", (int) len); 208 } 209 210 static int 211 print_unpacked_pointer (struct type *type, 212 CORE_ADDR address, CORE_ADDR addr, 213 const struct value_print_options *options, 214 struct ui_file *stream) 215 { 216 struct gdbarch *gdbarch = get_type_arch (type); 217 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); 218 219 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) 220 { 221 /* Try to print what function it points to. */ 222 print_function_pointer_address (gdbarch, addr, stream, 223 options->addressprint); 224 /* Return value is irrelevant except for string pointers. */ 225 return 0; 226 } 227 228 if (options->addressprint && options->format != 's') 229 fputs_filtered (paddress (gdbarch, address), stream); 230 231 /* For a pointer to char or unsigned char, also print the string 232 pointed to, unless pointer is null. */ 233 234 if (TYPE_LENGTH (elttype) == 1 235 && TYPE_CODE (elttype) == TYPE_CODE_INT 236 && (options->format == 0 || options->format == 's') 237 && addr != 0) 238 return val_print_string (TYPE_TARGET_TYPE (type), addr, -1, 239 stream, options); 240 241 return 0; 242 } 243 244 static void 245 print_variable_at_address (struct type *type, 246 const gdb_byte *valaddr, 247 struct ui_file *stream, 248 int recurse, 249 const struct value_print_options *options) 250 { 251 struct gdbarch *gdbarch = get_type_arch (type); 252 CORE_ADDR addr = unpack_pointer (type, valaddr); 253 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); 254 255 fprintf_filtered (stream, "["); 256 fputs_filtered (paddress (gdbarch, addr), stream); 257 fprintf_filtered (stream, "] : "); 258 259 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 260 { 261 struct value *deref_val = 262 value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr)); 263 264 common_val_print (deref_val, stream, recurse, options, current_language); 265 } 266 else 267 fputs_filtered ("???", stream); 268 } 269 270 271 /* m2_print_array_contents - prints out the contents of an 272 array up to a max_print values. 273 It prints arrays of char as a string 274 and all other data types as comma 275 separated values. */ 276 277 static void 278 m2_print_array_contents (struct type *type, const gdb_byte *valaddr, 279 int embedded_offset, CORE_ADDR address, 280 struct ui_file *stream, int recurse, 281 const struct value *val, 282 const struct value_print_options *options, 283 int len) 284 { 285 int eltlen; 286 CHECK_TYPEDEF (type); 287 288 if (TYPE_LENGTH (type) > 0) 289 { 290 eltlen = TYPE_LENGTH (type); 291 if (options->prettyprint_arrays) 292 print_spaces_filtered (2 + 2 * recurse, stream); 293 /* For an array of chars, print with string syntax. */ 294 if (eltlen == 1 && 295 ((TYPE_CODE (type) == TYPE_CODE_INT) 296 || ((current_language->la_language == language_m2) 297 && (TYPE_CODE (type) == TYPE_CODE_CHAR))) 298 && (options->format == 0 || options->format == 's')) 299 val_print_string (type, address, len+1, stream, options); 300 else 301 { 302 fprintf_filtered (stream, "{"); 303 val_print_array_elements (type, valaddr + embedded_offset, 304 address, stream, recurse, val, 305 options, 0); 306 fprintf_filtered (stream, "}"); 307 } 308 } 309 } 310 311 312 /* Print data of type TYPE located at VALADDR (within GDB), which came from 313 the inferior at address ADDRESS, onto stdio stream STREAM according to 314 OPTIONS. The data at VALADDR is in target byte order. 315 316 If the data are a string pointer, returns the number of string characters 317 printed. */ 318 319 int 320 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, 321 CORE_ADDR address, struct ui_file *stream, int recurse, 322 const struct value *original_value, 323 const struct value_print_options *options) 324 { 325 struct gdbarch *gdbarch = get_type_arch (type); 326 unsigned int i = 0; /* Number of characters printed */ 327 unsigned len; 328 struct type *elttype; 329 unsigned eltlen; 330 LONGEST val; 331 CORE_ADDR addr; 332 333 CHECK_TYPEDEF (type); 334 switch (TYPE_CODE (type)) 335 { 336 case TYPE_CODE_ARRAY: 337 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) 338 { 339 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 340 eltlen = TYPE_LENGTH (elttype); 341 len = TYPE_LENGTH (type) / eltlen; 342 if (options->prettyprint_arrays) 343 print_spaces_filtered (2 + 2 * recurse, stream); 344 /* For an array of chars, print with string syntax. */ 345 if (eltlen == 1 && 346 ((TYPE_CODE (elttype) == TYPE_CODE_INT) 347 || ((current_language->la_language == language_m2) 348 && (TYPE_CODE (elttype) == TYPE_CODE_CHAR))) 349 && (options->format == 0 || options->format == 's')) 350 { 351 /* If requested, look for the first null char and only print 352 elements up to it. */ 353 if (options->stop_print_at_null) 354 { 355 unsigned int temp_len; 356 357 /* Look for a NULL char. */ 358 for (temp_len = 0; 359 (valaddr + embedded_offset)[temp_len] 360 && temp_len < len && temp_len < options->print_max; 361 temp_len++); 362 len = temp_len; 363 } 364 365 LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), 366 valaddr + embedded_offset, len, NULL, 367 0, options); 368 i = len; 369 } 370 else 371 { 372 fprintf_filtered (stream, "{"); 373 val_print_array_elements (type, valaddr + embedded_offset, 374 address, stream, recurse, original_value, 375 options, 0); 376 fprintf_filtered (stream, "}"); 377 } 378 break; 379 } 380 /* Array of unspecified length: treat like pointer to first elt. */ 381 print_unpacked_pointer (type, address, address, options, stream); 382 break; 383 384 case TYPE_CODE_PTR: 385 if (TYPE_CONST (type)) 386 print_variable_at_address (type, valaddr + embedded_offset, 387 stream, recurse, options); 388 else if (options->format && options->format != 's') 389 print_scalar_formatted (valaddr + embedded_offset, type, 390 options, 0, stream); 391 else 392 { 393 addr = unpack_pointer (type, valaddr + embedded_offset); 394 print_unpacked_pointer (type, addr, address, options, stream); 395 } 396 break; 397 398 case TYPE_CODE_REF: 399 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 400 if (options->addressprint) 401 { 402 CORE_ADDR addr 403 = extract_typed_address (valaddr + embedded_offset, type); 404 405 fprintf_filtered (stream, "@"); 406 fputs_filtered (paddress (gdbarch, addr), stream); 407 if (options->deref_ref) 408 fputs_filtered (": ", stream); 409 } 410 /* De-reference the reference. */ 411 if (options->deref_ref) 412 { 413 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 414 { 415 struct value *deref_val = 416 value_at 417 (TYPE_TARGET_TYPE (type), 418 unpack_pointer (type, valaddr + embedded_offset)); 419 420 common_val_print (deref_val, stream, recurse, options, 421 current_language); 422 } 423 else 424 fputs_filtered ("???", stream); 425 } 426 break; 427 428 case TYPE_CODE_UNION: 429 if (recurse && !options->unionprint) 430 { 431 fprintf_filtered (stream, "{...}"); 432 break; 433 } 434 /* Fall through. */ 435 case TYPE_CODE_STRUCT: 436 if (m2_is_long_set (type)) 437 m2_print_long_set (type, valaddr, embedded_offset, address, 438 stream); 439 else if (m2_is_unbounded_array (type)) 440 m2_print_unbounded_array (type, valaddr, embedded_offset, 441 address, stream, recurse, options); 442 else 443 cp_print_value_fields (type, type, valaddr, embedded_offset, 444 address, stream, recurse, original_value, 445 options, NULL, 0); 446 break; 447 448 case TYPE_CODE_ENUM: 449 if (options->format) 450 { 451 print_scalar_formatted (valaddr + embedded_offset, type, 452 options, 0, stream); 453 break; 454 } 455 len = TYPE_NFIELDS (type); 456 val = unpack_long (type, valaddr + embedded_offset); 457 for (i = 0; i < len; i++) 458 { 459 QUIT; 460 if (val == TYPE_FIELD_BITPOS (type, i)) 461 { 462 break; 463 } 464 } 465 if (i < len) 466 { 467 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 468 } 469 else 470 { 471 print_longest (stream, 'd', 0, val); 472 } 473 break; 474 475 case TYPE_CODE_FUNC: 476 if (options->format) 477 { 478 print_scalar_formatted (valaddr + embedded_offset, type, 479 options, 0, stream); 480 break; 481 } 482 /* FIXME, we should consider, at least for ANSI C language, eliminating 483 the distinction made between FUNCs and POINTERs to FUNCs. */ 484 fprintf_filtered (stream, "{"); 485 type_print (type, "", stream, -1); 486 fprintf_filtered (stream, "} "); 487 /* Try to print what function it points to, and its address. */ 488 print_address_demangle (gdbarch, address, stream, demangle); 489 break; 490 491 case TYPE_CODE_BOOL: 492 if (options->format || options->output_format) 493 { 494 struct value_print_options opts = *options; 495 496 opts.format = (options->format ? options->format 497 : options->output_format); 498 print_scalar_formatted (valaddr + embedded_offset, type, 499 &opts, 0, stream); 500 } 501 else 502 { 503 val = unpack_long (type, valaddr + embedded_offset); 504 if (val == 0) 505 fputs_filtered ("FALSE", stream); 506 else if (val == 1) 507 fputs_filtered ("TRUE", stream); 508 else 509 fprintf_filtered (stream, "%ld)", (long int) val); 510 } 511 break; 512 513 case TYPE_CODE_RANGE: 514 if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type))) 515 { 516 m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset, 517 address, stream, recurse, original_value, options); 518 break; 519 } 520 /* FIXME: create_range_type does not set the unsigned bit in a 521 range type (I think it probably should copy it from the target 522 type), so we won't print values which are too large to 523 fit in a signed integer correctly. */ 524 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just 525 print with the target type, though, because the size of our type 526 and the target type might differ). */ 527 /* FALLTHROUGH */ 528 529 case TYPE_CODE_INT: 530 if (options->format || options->output_format) 531 { 532 struct value_print_options opts = *options; 533 534 opts.format = (options->format ? options->format 535 : options->output_format); 536 print_scalar_formatted (valaddr + embedded_offset, type, 537 &opts, 0, stream); 538 } 539 else 540 val_print_type_code_int (type, valaddr + embedded_offset, stream); 541 break; 542 543 case TYPE_CODE_CHAR: 544 if (options->format || options->output_format) 545 { 546 struct value_print_options opts = *options; 547 548 opts.format = (options->format ? options->format 549 : options->output_format); 550 print_scalar_formatted (valaddr + embedded_offset, type, 551 &opts, 0, stream); 552 } 553 else 554 { 555 val = unpack_long (type, valaddr + embedded_offset); 556 if (TYPE_UNSIGNED (type)) 557 fprintf_filtered (stream, "%u", (unsigned int) val); 558 else 559 fprintf_filtered (stream, "%d", (int) val); 560 fputs_filtered (" ", stream); 561 LA_PRINT_CHAR ((unsigned char) val, type, stream); 562 } 563 break; 564 565 case TYPE_CODE_FLT: 566 if (options->format) 567 print_scalar_formatted (valaddr + embedded_offset, type, 568 options, 0, stream); 569 else 570 print_floating (valaddr + embedded_offset, type, stream); 571 break; 572 573 case TYPE_CODE_METHOD: 574 break; 575 576 case TYPE_CODE_BITSTRING: 577 case TYPE_CODE_SET: 578 elttype = TYPE_INDEX_TYPE (type); 579 CHECK_TYPEDEF (elttype); 580 if (TYPE_STUB (elttype)) 581 { 582 fprintf_filtered (stream, _("<incomplete type>")); 583 gdb_flush (stream); 584 break; 585 } 586 else 587 { 588 struct type *range = elttype; 589 LONGEST low_bound, high_bound; 590 int i; 591 int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING; 592 int need_comma = 0; 593 594 if (is_bitstring) 595 fputs_filtered ("B'", stream); 596 else 597 fputs_filtered ("{", stream); 598 599 i = get_discrete_bounds (range, &low_bound, &high_bound); 600 maybe_bad_bstring: 601 if (i < 0) 602 { 603 fputs_filtered (_("<error value>"), stream); 604 goto done; 605 } 606 607 for (i = low_bound; i <= high_bound; i++) 608 { 609 int element = value_bit_index (type, valaddr + embedded_offset, 610 i); 611 612 if (element < 0) 613 { 614 i = element; 615 goto maybe_bad_bstring; 616 } 617 if (is_bitstring) 618 fprintf_filtered (stream, "%d", element); 619 else if (element) 620 { 621 if (need_comma) 622 fputs_filtered (", ", stream); 623 print_type_scalar (range, i, stream); 624 need_comma = 1; 625 626 if (i + 1 <= high_bound 627 && value_bit_index (type, valaddr + embedded_offset, 628 ++i)) 629 { 630 int j = i; 631 632 fputs_filtered ("..", stream); 633 while (i + 1 <= high_bound 634 && value_bit_index (type, 635 valaddr + embedded_offset, 636 ++i)) 637 j = i; 638 print_type_scalar (range, j, stream); 639 } 640 } 641 } 642 done: 643 if (is_bitstring) 644 fputs_filtered ("'", stream); 645 else 646 fputs_filtered ("}", stream); 647 } 648 break; 649 650 case TYPE_CODE_VOID: 651 fprintf_filtered (stream, "void"); 652 break; 653 654 case TYPE_CODE_ERROR: 655 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type)); 656 break; 657 658 case TYPE_CODE_UNDEF: 659 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use 660 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar" 661 and no complete type for struct foo in that file. */ 662 fprintf_filtered (stream, _("<incomplete type>")); 663 break; 664 665 default: 666 error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type)); 667 } 668 gdb_flush (stream); 669 return (0); 670 } 671