1 /* Support for printing Modula 2 values for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "symtab.h" 22 #include "gdbtypes.h" 23 #include "expression.h" 24 #include "value.h" 25 #include "valprint.h" 26 #include "language.h" 27 #include "typeprint.h" 28 #include "c-lang.h" 29 #include "m2-lang.h" 30 #include "target.h" 31 32 static int print_unpacked_pointer (struct type *type, 33 CORE_ADDR address, CORE_ADDR addr, 34 const struct value_print_options *options, 35 struct ui_file *stream); 36 static void 37 m2_print_array_contents (struct type *type, const gdb_byte *valaddr, 38 int embedded_offset, CORE_ADDR address, 39 struct ui_file *stream, int recurse, 40 const struct value *val, 41 const struct value_print_options *options, 42 int len); 43 44 45 /* get_long_set_bounds - assigns the bounds of the long set to low and 46 high. */ 47 48 int 49 get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high) 50 { 51 int len, i; 52 53 if (TYPE_CODE (type) == TYPE_CODE_STRUCT) 54 { 55 len = TYPE_NFIELDS (type); 56 i = TYPE_N_BASECLASSES (type); 57 if (len == 0) 58 return 0; 59 *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i))); 60 *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, 61 len-1))); 62 return 1; 63 } 64 error (_("expecting long_set")); 65 return 0; 66 } 67 68 static void 69 m2_print_long_set (struct type *type, const gdb_byte *valaddr, 70 int embedded_offset, CORE_ADDR address, 71 struct ui_file *stream) 72 { 73 int empty_set = 1; 74 int element_seen = 0; 75 LONGEST previous_low = 0; 76 LONGEST previous_high= 0; 77 LONGEST i, low_bound, high_bound; 78 LONGEST field_low, field_high; 79 struct type *range; 80 int len, field; 81 struct type *target; 82 int bitval; 83 84 CHECK_TYPEDEF (type); 85 86 fprintf_filtered (stream, "{"); 87 len = TYPE_NFIELDS (type); 88 if (get_long_set_bounds (type, &low_bound, &high_bound)) 89 { 90 field = TYPE_N_BASECLASSES (type); 91 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); 92 } 93 else 94 { 95 fprintf_filtered (stream, " %s }", _("<unknown bounds of set>")); 96 return; 97 } 98 99 target = TYPE_TARGET_TYPE (range); 100 101 if (get_discrete_bounds (range, &field_low, &field_high) >= 0) 102 { 103 for (i = low_bound; i <= high_bound; i++) 104 { 105 bitval = value_bit_index (TYPE_FIELD_TYPE (type, field), 106 (TYPE_FIELD_BITPOS (type, field) / 8) + 107 valaddr + embedded_offset, i); 108 if (bitval < 0) 109 error (_("bit test is out of range")); 110 else if (bitval > 0) 111 { 112 previous_high = i; 113 if (! element_seen) 114 { 115 if (! empty_set) 116 fprintf_filtered (stream, ", "); 117 print_type_scalar (target, i, stream); 118 empty_set = 0; 119 element_seen = 1; 120 previous_low = i; 121 } 122 } 123 else 124 { 125 /* bit is not set */ 126 if (element_seen) 127 { 128 if (previous_low+1 < previous_high) 129 fprintf_filtered (stream, ".."); 130 if (previous_low+1 < previous_high) 131 print_type_scalar (target, previous_high, stream); 132 element_seen = 0; 133 } 134 } 135 if (i == field_high) 136 { 137 field++; 138 if (field == len) 139 break; 140 range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field)); 141 if (get_discrete_bounds (range, &field_low, &field_high) < 0) 142 break; 143 target = TYPE_TARGET_TYPE (range); 144 } 145 } 146 if (element_seen) 147 { 148 if (previous_low+1 < previous_high) 149 { 150 fprintf_filtered (stream, ".."); 151 print_type_scalar (target, previous_high, stream); 152 } 153 element_seen = 0; 154 } 155 fprintf_filtered (stream, "}"); 156 } 157 } 158 159 static void 160 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr, 161 int embedded_offset, CORE_ADDR address, 162 struct ui_file *stream, int recurse, 163 const struct value_print_options *options) 164 { 165 struct type *content_type; 166 CORE_ADDR addr; 167 LONGEST len; 168 struct value *val; 169 170 CHECK_TYPEDEF (type); 171 content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)); 172 173 addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0), 174 (TYPE_FIELD_BITPOS (type, 0) / 8) + 175 valaddr + embedded_offset); 176 177 val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)), 178 addr); 179 len = unpack_field_as_long (type, valaddr + embedded_offset, 1); 180 181 fprintf_filtered (stream, "{"); 182 m2_print_array_contents (value_type (val), 183 value_contents_for_printing (val), 184 value_embedded_offset (val), addr, stream, 185 recurse, val, options, len); 186 fprintf_filtered (stream, ", HIGH = %d}", (int) len); 187 } 188 189 static int 190 print_unpacked_pointer (struct type *type, 191 CORE_ADDR address, CORE_ADDR addr, 192 const struct value_print_options *options, 193 struct ui_file *stream) 194 { 195 struct gdbarch *gdbarch = get_type_arch (type); 196 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); 197 int want_space = 0; 198 199 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) 200 { 201 /* Try to print what function it points to. */ 202 print_function_pointer_address (options, gdbarch, addr, stream); 203 /* Return value is irrelevant except for string pointers. */ 204 return 0; 205 } 206 207 if (options->addressprint && options->format != 's') 208 { 209 fputs_filtered (paddress (gdbarch, address), stream); 210 want_space = 1; 211 } 212 213 /* For a pointer to char or unsigned char, also print the string 214 pointed to, unless pointer is null. */ 215 216 if (TYPE_LENGTH (elttype) == 1 217 && TYPE_CODE (elttype) == TYPE_CODE_INT 218 && (options->format == 0 || options->format == 's') 219 && addr != 0) 220 { 221 if (want_space) 222 fputs_filtered (" ", stream); 223 return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1, 224 stream, options); 225 } 226 227 return 0; 228 } 229 230 static void 231 print_variable_at_address (struct type *type, 232 const gdb_byte *valaddr, 233 struct ui_file *stream, 234 int recurse, 235 const struct value_print_options *options) 236 { 237 struct gdbarch *gdbarch = get_type_arch (type); 238 CORE_ADDR addr = unpack_pointer (type, valaddr); 239 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); 240 241 fprintf_filtered (stream, "["); 242 fputs_filtered (paddress (gdbarch, addr), stream); 243 fprintf_filtered (stream, "] : "); 244 245 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 246 { 247 struct value *deref_val = 248 value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr)); 249 250 common_val_print (deref_val, stream, recurse, options, current_language); 251 } 252 else 253 fputs_filtered ("???", stream); 254 } 255 256 257 /* m2_print_array_contents - prints out the contents of an 258 array up to a max_print values. 259 It prints arrays of char as a string 260 and all other data types as comma 261 separated values. */ 262 263 static void 264 m2_print_array_contents (struct type *type, const gdb_byte *valaddr, 265 int embedded_offset, CORE_ADDR address, 266 struct ui_file *stream, int recurse, 267 const struct value *val, 268 const struct value_print_options *options, 269 int len) 270 { 271 CHECK_TYPEDEF (type); 272 273 if (TYPE_LENGTH (type) > 0) 274 { 275 if (options->prettyprint_arrays) 276 print_spaces_filtered (2 + 2 * recurse, stream); 277 /* For an array of chars, print with string syntax. */ 278 if (TYPE_LENGTH (type) == 1 && 279 ((TYPE_CODE (type) == TYPE_CODE_INT) 280 || ((current_language->la_language == language_m2) 281 && (TYPE_CODE (type) == TYPE_CODE_CHAR))) 282 && (options->format == 0 || options->format == 's')) 283 val_print_string (type, NULL, address, len+1, stream, options); 284 else 285 { 286 fprintf_filtered (stream, "{"); 287 val_print_array_elements (type, valaddr, embedded_offset, 288 address, stream, recurse, val, 289 options, 0); 290 fprintf_filtered (stream, "}"); 291 } 292 } 293 } 294 295 /* Decorations for Modula 2. */ 296 297 static const struct generic_val_print_decorations m2_decorations = 298 { 299 "", 300 " + ", 301 " * I", 302 "TRUE", 303 "FALSE", 304 "void" 305 }; 306 307 /* See val_print for a description of the various parameters of this 308 function; they are identical. */ 309 310 void 311 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset, 312 CORE_ADDR address, struct ui_file *stream, int recurse, 313 const struct value *original_value, 314 const struct value_print_options *options) 315 { 316 struct gdbarch *gdbarch = get_type_arch (type); 317 unsigned int i = 0; /* Number of characters printed. */ 318 unsigned len; 319 struct type *elttype; 320 CORE_ADDR addr; 321 322 CHECK_TYPEDEF (type); 323 switch (TYPE_CODE (type)) 324 { 325 case TYPE_CODE_ARRAY: 326 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) 327 { 328 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 329 len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype); 330 if (options->prettyprint_arrays) 331 print_spaces_filtered (2 + 2 * recurse, stream); 332 /* For an array of chars, print with string syntax. */ 333 if (TYPE_LENGTH (elttype) == 1 && 334 ((TYPE_CODE (elttype) == TYPE_CODE_INT) 335 || ((current_language->la_language == language_m2) 336 && (TYPE_CODE (elttype) == TYPE_CODE_CHAR))) 337 && (options->format == 0 || options->format == 's')) 338 { 339 /* If requested, look for the first null char and only print 340 elements up to it. */ 341 if (options->stop_print_at_null) 342 { 343 unsigned int temp_len; 344 345 /* Look for a NULL char. */ 346 for (temp_len = 0; 347 (valaddr + embedded_offset)[temp_len] 348 && temp_len < len && temp_len < options->print_max; 349 temp_len++); 350 len = temp_len; 351 } 352 353 LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type), 354 valaddr + embedded_offset, len, NULL, 355 0, options); 356 i = len; 357 } 358 else 359 { 360 fprintf_filtered (stream, "{"); 361 val_print_array_elements (type, valaddr, embedded_offset, 362 address, stream, 363 recurse, original_value, 364 options, 0); 365 fprintf_filtered (stream, "}"); 366 } 367 break; 368 } 369 /* Array of unspecified length: treat like pointer to first elt. */ 370 print_unpacked_pointer (type, address, address, options, stream); 371 break; 372 373 case TYPE_CODE_PTR: 374 if (TYPE_CONST (type)) 375 print_variable_at_address (type, valaddr + embedded_offset, 376 stream, recurse, options); 377 else if (options->format && options->format != 's') 378 val_print_scalar_formatted (type, valaddr, embedded_offset, 379 original_value, options, 0, stream); 380 else 381 { 382 addr = unpack_pointer (type, valaddr + embedded_offset); 383 print_unpacked_pointer (type, addr, address, options, stream); 384 } 385 break; 386 387 case TYPE_CODE_UNION: 388 if (recurse && !options->unionprint) 389 { 390 fprintf_filtered (stream, "{...}"); 391 break; 392 } 393 /* Fall through. */ 394 case TYPE_CODE_STRUCT: 395 if (m2_is_long_set (type)) 396 m2_print_long_set (type, valaddr, embedded_offset, address, 397 stream); 398 else if (m2_is_unbounded_array (type)) 399 m2_print_unbounded_array (type, valaddr, embedded_offset, 400 address, stream, recurse, options); 401 else 402 cp_print_value_fields (type, type, valaddr, embedded_offset, 403 address, stream, recurse, original_value, 404 options, NULL, 0); 405 break; 406 407 case TYPE_CODE_SET: 408 elttype = TYPE_INDEX_TYPE (type); 409 CHECK_TYPEDEF (elttype); 410 if (TYPE_STUB (elttype)) 411 { 412 fprintf_filtered (stream, _("<incomplete type>")); 413 gdb_flush (stream); 414 break; 415 } 416 else 417 { 418 struct type *range = elttype; 419 LONGEST low_bound, high_bound; 420 int i; 421 int need_comma = 0; 422 423 fputs_filtered ("{", stream); 424 425 i = get_discrete_bounds (range, &low_bound, &high_bound); 426 maybe_bad_bstring: 427 if (i < 0) 428 { 429 fputs_filtered (_("<error value>"), stream); 430 goto done; 431 } 432 433 for (i = low_bound; i <= high_bound; i++) 434 { 435 int element = value_bit_index (type, valaddr + embedded_offset, 436 i); 437 438 if (element < 0) 439 { 440 i = element; 441 goto maybe_bad_bstring; 442 } 443 if (element) 444 { 445 if (need_comma) 446 fputs_filtered (", ", stream); 447 print_type_scalar (range, i, stream); 448 need_comma = 1; 449 450 if (i + 1 <= high_bound 451 && value_bit_index (type, valaddr + embedded_offset, 452 ++i)) 453 { 454 int j = i; 455 456 fputs_filtered ("..", stream); 457 while (i + 1 <= high_bound 458 && value_bit_index (type, 459 valaddr + embedded_offset, 460 ++i)) 461 j = i; 462 print_type_scalar (range, j, stream); 463 } 464 } 465 } 466 done: 467 fputs_filtered ("}", stream); 468 } 469 break; 470 471 case TYPE_CODE_RANGE: 472 if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type))) 473 { 474 m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset, 475 address, stream, recurse, original_value, options); 476 break; 477 } 478 /* FIXME: create_range_type does not set the unsigned bit in a 479 range type (I think it probably should copy it from the target 480 type), so we won't print values which are too large to 481 fit in a signed integer correctly. */ 482 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just 483 print with the target type, though, because the size of our type 484 and the target type might differ). */ 485 /* FALLTHROUGH */ 486 487 case TYPE_CODE_REF: 488 case TYPE_CODE_ENUM: 489 case TYPE_CODE_FUNC: 490 case TYPE_CODE_INT: 491 case TYPE_CODE_FLT: 492 case TYPE_CODE_METHOD: 493 case TYPE_CODE_VOID: 494 case TYPE_CODE_ERROR: 495 case TYPE_CODE_UNDEF: 496 case TYPE_CODE_BOOL: 497 case TYPE_CODE_CHAR: 498 default: 499 generic_val_print (type, valaddr, embedded_offset, address, 500 stream, recurse, original_value, options, 501 &m2_decorations); 502 break; 503 } 504 gdb_flush (stream); 505 } 506