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