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