1 /* Support for printing C values for GDB, the GNU debugger. 2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996 3 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 2 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, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 #include "defs.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "expression.h" 25 #include "value.h" 26 #include "demangle.h" 27 #include "valprint.h" 28 #include "language.h" 29 #include "c-lang.h" 30 31 32 /* Print data of type TYPE located at VALADDR (within GDB), which came from 33 the inferior at address ADDRESS, onto stdio stream STREAM according to 34 FORMAT (a letter or 0 for natural format). The data at VALADDR is in 35 target byte order. 36 37 If the data are a string pointer, returns the number of string characters 38 printed. 39 40 If DEREF_REF is nonzero, then dereference references, otherwise just print 41 them like pointers. 42 43 The PRETTY parameter controls prettyprinting. */ 44 45 int 46 c_val_print (type, valaddr, address, stream, format, deref_ref, recurse, 47 pretty) 48 struct type *type; 49 char *valaddr; 50 CORE_ADDR address; 51 GDB_FILE *stream; 52 int format; 53 int deref_ref; 54 int recurse; 55 enum val_prettyprint pretty; 56 { 57 register unsigned int i = 0; /* Number of characters printed */ 58 unsigned len; 59 struct type *elttype; 60 unsigned eltlen; 61 LONGEST val; 62 CORE_ADDR addr; 63 64 CHECK_TYPEDEF (type); 65 switch (TYPE_CODE (type)) 66 { 67 case TYPE_CODE_ARRAY: 68 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) 69 { 70 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 71 eltlen = TYPE_LENGTH (elttype); 72 len = TYPE_LENGTH (type) / eltlen; 73 if (prettyprint_arrays) 74 { 75 print_spaces_filtered (2 + 2 * recurse, stream); 76 } 77 /* For an array of chars, print with string syntax. */ 78 if (eltlen == 1 && 79 ((TYPE_CODE (elttype) == TYPE_CODE_INT) 80 || ((current_language->la_language == language_m2) 81 && (TYPE_CODE (elttype) == TYPE_CODE_CHAR))) 82 && (format == 0 || format == 's')) 83 { 84 /* If requested, look for the first null char and only print 85 elements up to it. */ 86 if (stop_print_at_null) 87 { 88 int temp_len; 89 90 /* Look for a NULL char. */ 91 for (temp_len = 0; 92 valaddr[temp_len] 93 && temp_len < len && temp_len < print_max; 94 temp_len++); 95 len = temp_len; 96 } 97 98 LA_PRINT_STRING (stream, valaddr, len, 0); 99 i = len; 100 } 101 else 102 { 103 fprintf_filtered (stream, "{"); 104 /* If this is a virtual function table, print the 0th 105 entry specially, and the rest of the members normally. */ 106 if (cp_is_vtbl_ptr_type (elttype)) 107 { 108 i = 1; 109 fprintf_filtered (stream, "%d vtable entries", len - 1); 110 } 111 else 112 { 113 i = 0; 114 } 115 val_print_array_elements (type, valaddr, address, stream, 116 format, deref_ref, recurse, pretty, i); 117 fprintf_filtered (stream, "}"); 118 } 119 break; 120 } 121 /* Array of unspecified length: treat like pointer to first elt. */ 122 addr = address; 123 goto print_unpacked_pointer; 124 125 case TYPE_CODE_PTR: 126 if (format && format != 's') 127 { 128 print_scalar_formatted (valaddr, type, format, 0, stream); 129 break; 130 } 131 if (vtblprint && cp_is_vtbl_ptr_type(type)) 132 { 133 /* Print the unmangled name if desired. */ 134 /* Print vtable entry - we only get here if we ARE using 135 -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */ 136 print_address_demangle(extract_address (valaddr, TYPE_LENGTH (type)), 137 stream, demangle); 138 break; 139 } 140 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 141 if (TYPE_CODE (elttype) == TYPE_CODE_METHOD) 142 { 143 cp_print_class_method (valaddr, type, stream); 144 } 145 else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER) 146 { 147 cp_print_class_member (valaddr, 148 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)), 149 stream, "&"); 150 } 151 else 152 { 153 addr = unpack_pointer (type, valaddr); 154 print_unpacked_pointer: 155 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 156 157 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC) 158 { 159 /* Try to print what function it points to. */ 160 print_address_demangle (addr, stream, demangle); 161 /* Return value is irrelevant except for string pointers. */ 162 return (0); 163 } 164 165 if (addressprint && format != 's') 166 { 167 print_address_numeric (addr, 1, stream); 168 } 169 170 /* For a pointer to char or unsigned char, also print the string 171 pointed to, unless pointer is null. */ 172 if (TYPE_LENGTH (elttype) == 1 173 && TYPE_CODE (elttype) == TYPE_CODE_INT 174 && (format == 0 || format == 's') 175 && addr != 0) 176 { 177 i = val_print_string (addr, 0, stream); 178 } 179 else if (cp_is_vtbl_member(type)) 180 { 181 /* print vtbl's nicely */ 182 CORE_ADDR vt_address = unpack_pointer (type, valaddr); 183 184 struct minimal_symbol *msymbol = 185 lookup_minimal_symbol_by_pc (vt_address); 186 if ((msymbol != NULL) && 187 (vt_address == SYMBOL_VALUE_ADDRESS (msymbol))) 188 { 189 fputs_filtered (" <", stream); 190 fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream); 191 fputs_filtered (">", stream); 192 } 193 if (vt_address && vtblprint) 194 { 195 value_ptr vt_val; 196 struct symbol *wsym = (struct symbol *)NULL; 197 struct type *wtype; 198 struct symtab *s; 199 struct block *block = (struct block *)NULL; 200 int is_this_fld; 201 202 if (msymbol != NULL) 203 wsym = lookup_symbol (SYMBOL_NAME(msymbol), block, 204 VAR_NAMESPACE, &is_this_fld, &s); 205 206 if (wsym) 207 { 208 wtype = SYMBOL_TYPE(wsym); 209 } 210 else 211 { 212 wtype = TYPE_TARGET_TYPE(type); 213 } 214 vt_val = value_at (wtype, vt_address); 215 val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val), 216 VALUE_ADDRESS (vt_val), stream, format, 217 deref_ref, recurse + 1, pretty); 218 if (pretty) 219 { 220 fprintf_filtered (stream, "\n"); 221 print_spaces_filtered (2 + 2 * recurse, stream); 222 } 223 } 224 } 225 226 /* Return number of characters printed, including the terminating 227 '\0' if we reached the end. val_print_string takes care including 228 the terminating '\0' if necessary. */ 229 return i; 230 } 231 break; 232 233 case TYPE_CODE_MEMBER: 234 error ("not implemented: member type in c_val_print"); 235 break; 236 237 case TYPE_CODE_REF: 238 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 239 if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER) 240 { 241 cp_print_class_member (valaddr, 242 TYPE_DOMAIN_TYPE (elttype), 243 stream, ""); 244 break; 245 } 246 if (addressprint) 247 { 248 fprintf_filtered (stream, "@"); 249 print_address_numeric 250 (extract_address (valaddr, 251 TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream); 252 if (deref_ref) 253 fputs_filtered (": ", stream); 254 } 255 /* De-reference the reference. */ 256 if (deref_ref) 257 { 258 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 259 { 260 value_ptr deref_val = 261 value_at 262 (TYPE_TARGET_TYPE (type), 263 unpack_pointer (lookup_pointer_type (builtin_type_void), 264 valaddr)); 265 val_print (VALUE_TYPE (deref_val), 266 VALUE_CONTENTS (deref_val), 267 VALUE_ADDRESS (deref_val), stream, format, 268 deref_ref, recurse + 1, pretty); 269 } 270 else 271 fputs_filtered ("???", stream); 272 } 273 break; 274 275 case TYPE_CODE_UNION: 276 if (recurse && !unionprint) 277 { 278 fprintf_filtered (stream, "{...}"); 279 break; 280 } 281 /* Fall through. */ 282 case TYPE_CODE_STRUCT: 283 if (vtblprint && cp_is_vtbl_ptr_type(type)) 284 { 285 /* Print the unmangled name if desired. */ 286 /* Print vtable entry - we only get here if NOT using 287 -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */ 288 print_address_demangle(*((int *) (valaddr + /* FIXME bytesex */ 289 TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8)), 290 stream, demangle); 291 } 292 else 293 cp_print_value_fields (type, valaddr, address, stream, format, 294 recurse, pretty, NULL, 0); 295 break; 296 297 case TYPE_CODE_ENUM: 298 if (format) 299 { 300 print_scalar_formatted (valaddr, type, format, 0, stream); 301 break; 302 } 303 len = TYPE_NFIELDS (type); 304 val = unpack_long (type, valaddr); 305 for (i = 0; i < len; i++) 306 { 307 QUIT; 308 if (val == TYPE_FIELD_BITPOS (type, i)) 309 { 310 break; 311 } 312 } 313 if (i < len) 314 { 315 fputs_filtered (TYPE_FIELD_NAME (type, i), stream); 316 } 317 else 318 { 319 print_longest (stream, 'd', 0, val); 320 } 321 break; 322 323 case TYPE_CODE_FUNC: 324 if (format) 325 { 326 print_scalar_formatted (valaddr, type, format, 0, stream); 327 break; 328 } 329 /* FIXME, we should consider, at least for ANSI C language, eliminating 330 the distinction made between FUNCs and POINTERs to FUNCs. */ 331 fprintf_filtered (stream, "{"); 332 type_print (type, "", stream, -1); 333 fprintf_filtered (stream, "} "); 334 /* Try to print what function it points to, and its address. */ 335 print_address_demangle (address, stream, demangle); 336 break; 337 338 case TYPE_CODE_BOOL: 339 format = format ? format : output_format; 340 if (format) 341 print_scalar_formatted (valaddr, type, format, 0, stream); 342 else 343 { 344 val = unpack_long (type, valaddr); 345 if (val == 0) 346 fputs_filtered ("false", stream); 347 else if (val == 1) 348 fputs_filtered ("true", stream); 349 else 350 print_longest (stream, 'd', 0, val); 351 } 352 break; 353 354 case TYPE_CODE_RANGE: 355 /* FIXME: create_range_type does not set the unsigned bit in a 356 range type (I think it probably should copy it from the target 357 type), so we won't print values which are too large to 358 fit in a signed integer correctly. */ 359 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just 360 print with the target type, though, because the size of our type 361 and the target type might differ). */ 362 /* FALLTHROUGH */ 363 364 case TYPE_CODE_INT: 365 format = format ? format : output_format; 366 if (format) 367 { 368 print_scalar_formatted (valaddr, type, format, 0, stream); 369 } 370 else 371 { 372 val_print_type_code_int (type, valaddr, stream); 373 /* C and C++ has no single byte int type, char is used instead. 374 Since we don't know whether the value is really intended to 375 be used as an integer or a character, print the character 376 equivalent as well. */ 377 if (TYPE_LENGTH (type) == 1) 378 { 379 fputs_filtered (" ", stream); 380 LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr), 381 stream); 382 } 383 } 384 break; 385 386 case TYPE_CODE_CHAR: 387 format = format ? format : output_format; 388 if (format) 389 { 390 print_scalar_formatted (valaddr, type, format, 0, stream); 391 } 392 else 393 { 394 fprintf_filtered (stream, TYPE_UNSIGNED (type) ? "%u" : "%d", 395 unpack_long (type, valaddr)); 396 fputs_filtered (" ", stream); 397 LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr), stream); 398 } 399 break; 400 401 case TYPE_CODE_FLT: 402 if (format) 403 { 404 print_scalar_formatted (valaddr, type, format, 0, stream); 405 } 406 else 407 { 408 print_floating (valaddr, type, stream); 409 } 410 break; 411 412 case TYPE_CODE_VOID: 413 fprintf_filtered (stream, "void"); 414 break; 415 416 case TYPE_CODE_ERROR: 417 fprintf_filtered (stream, "<error type>"); 418 break; 419 420 case TYPE_CODE_UNDEF: 421 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use 422 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar" 423 and no complete type for struct foo in that file. */ 424 fprintf_filtered (stream, "<incomplete type>"); 425 break; 426 427 default: 428 error ("Invalid C/C++ type code %d in symbol table.", TYPE_CODE (type)); 429 } 430 gdb_flush (stream); 431 return (0); 432 } 433 434 int 435 c_value_print (val, stream, format, pretty) 436 value_ptr val; 437 GDB_FILE *stream; 438 int format; 439 enum val_prettyprint pretty; 440 { 441 struct type *type = VALUE_TYPE (val); 442 443 /* If it is a pointer, indicate what it points to. 444 445 Print type also if it is a reference. 446 447 C++: if it is a member pointer, we will take care 448 of that when we print it. */ 449 if (TYPE_CODE (type) == TYPE_CODE_PTR || 450 TYPE_CODE (type) == TYPE_CODE_REF) 451 { 452 /* Hack: remove (char *) for char strings. Their 453 type is indicated by the quoted string anyway. */ 454 if (TYPE_CODE (type) == TYPE_CODE_PTR && 455 TYPE_NAME (type) == NULL && 456 TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL && 457 STREQ (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char")) 458 { 459 /* Print nothing */ 460 } 461 else 462 { 463 fprintf_filtered (stream, "("); 464 type_print (type, "", stream, -1); 465 fprintf_filtered (stream, ") "); 466 } 467 } 468 return val_print (type, VALUE_CONTENTS (val), 469 VALUE_ADDRESS (val) + VALUE_OFFSET (val), 470 stream, format, 1, 0, pretty); 471 } 472