1 /* Support for printing C 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 "gdb_string.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 "c-lang.h"
29 #include "cp-abi.h"
30 #include "target.h"
31
32
33 /* A helper for c_textual_element_type. This checks the name of the
34 typedef. This is bogus but it isn't apparent that the compiler
35 provides us the help we may need. */
36
37 static int
textual_name(const char * name)38 textual_name (const char *name)
39 {
40 return (!strcmp (name, "wchar_t")
41 || !strcmp (name, "char16_t")
42 || !strcmp (name, "char32_t"));
43 }
44
45 /* Apply a heuristic to decide whether an array of TYPE or a pointer
46 to TYPE should be printed as a textual string. Return non-zero if
47 it should, or zero if it should be treated as an array of integers
48 or pointer to integers. FORMAT is the current format letter, or 0
49 if none.
50
51 We guess that "char" is a character. Explicitly signed and
52 unsigned character types are also characters. Integer data from
53 vector types is not. The user can override this by using the /s
54 format letter. */
55
56 int
c_textual_element_type(struct type * type,char format)57 c_textual_element_type (struct type *type, char format)
58 {
59 struct type *true_type, *iter_type;
60
61 if (format != 0 && format != 's')
62 return 0;
63
64 /* We also rely on this for its side effect of setting up all the
65 typedef pointers. */
66 true_type = check_typedef (type);
67
68 /* TYPE_CODE_CHAR is always textual. */
69 if (TYPE_CODE (true_type) == TYPE_CODE_CHAR)
70 return 1;
71
72 /* Any other character-like types must be integral. */
73 if (TYPE_CODE (true_type) != TYPE_CODE_INT)
74 return 0;
75
76 /* We peel typedefs one by one, looking for a match. */
77 iter_type = type;
78 while (iter_type)
79 {
80 /* Check the name of the type. */
81 if (TYPE_NAME (iter_type) && textual_name (TYPE_NAME (iter_type)))
82 return 1;
83
84 if (TYPE_CODE (iter_type) != TYPE_CODE_TYPEDEF)
85 break;
86
87 /* Peel a single typedef. If the typedef doesn't have a target
88 type, we use check_typedef and hope the result is ok -- it
89 might be for C++, where wchar_t is a built-in type. */
90 if (TYPE_TARGET_TYPE (iter_type))
91 iter_type = TYPE_TARGET_TYPE (iter_type);
92 else
93 iter_type = check_typedef (iter_type);
94 }
95
96 if (format == 's')
97 {
98 /* Print this as a string if we can manage it. For now, no wide
99 character support. */
100 if (TYPE_CODE (true_type) == TYPE_CODE_INT
101 && TYPE_LENGTH (true_type) == 1)
102 return 1;
103 }
104 else
105 {
106 /* If a one-byte TYPE_CODE_INT is missing the not-a-character
107 flag, then we treat it as text; otherwise, we assume it's
108 being used as data. */
109 if (TYPE_CODE (true_type) == TYPE_CODE_INT
110 && TYPE_LENGTH (true_type) == 1
111 && !TYPE_NOTTEXT (true_type))
112 return 1;
113 }
114
115 return 0;
116 }
117
118 /* Decorations for C. */
119
120 static const struct generic_val_print_decorations c_decorations =
121 {
122 "",
123 " + ",
124 " * I",
125 "true",
126 "false",
127 "void"
128 };
129
130 /* See val_print for a description of the various parameters of this
131 function; they are identical. */
132
133 void
c_val_print(struct type * type,const gdb_byte * valaddr,int embedded_offset,CORE_ADDR address,struct ui_file * stream,int recurse,const struct value * original_value,const struct value_print_options * options)134 c_val_print (struct type *type, const gdb_byte *valaddr,
135 int embedded_offset, CORE_ADDR address,
136 struct ui_file *stream, int recurse,
137 const struct value *original_value,
138 const struct value_print_options *options)
139 {
140 struct gdbarch *gdbarch = get_type_arch (type);
141 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
142 unsigned int i = 0; /* Number of characters printed. */
143 unsigned len;
144 struct type *elttype, *unresolved_elttype;
145 struct type *unresolved_type = type;
146 unsigned eltlen;
147 CORE_ADDR addr;
148
149 CHECK_TYPEDEF (type);
150 switch (TYPE_CODE (type))
151 {
152 case TYPE_CODE_ARRAY:
153 unresolved_elttype = TYPE_TARGET_TYPE (type);
154 elttype = check_typedef (unresolved_elttype);
155 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
156 {
157 LONGEST low_bound, high_bound;
158
159 if (!get_array_bounds (type, &low_bound, &high_bound))
160 error (_("Could not determine the array high bound"));
161
162 eltlen = TYPE_LENGTH (elttype);
163 len = high_bound - low_bound + 1;
164 if (options->prettyprint_arrays)
165 {
166 print_spaces_filtered (2 + 2 * recurse, stream);
167 }
168
169 /* Print arrays of textual chars with a string syntax, as
170 long as the entire array is valid. */
171 if (c_textual_element_type (unresolved_elttype,
172 options->format)
173 && value_bytes_available (original_value, embedded_offset,
174 TYPE_LENGTH (type))
175 && value_bits_valid (original_value,
176 TARGET_CHAR_BIT * embedded_offset,
177 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
178 {
179 int force_ellipses = 0;
180
181 /* If requested, look for the first null char and only
182 print elements up to it. */
183 if (options->stop_print_at_null)
184 {
185 unsigned int temp_len;
186
187 for (temp_len = 0;
188 (temp_len < len
189 && temp_len < options->print_max
190 && extract_unsigned_integer (valaddr + embedded_offset
191 + temp_len * eltlen,
192 eltlen, byte_order) != 0);
193 ++temp_len)
194 ;
195
196 /* Force LA_PRINT_STRING to print ellipses if
197 we've printed the maximum characters and
198 the next character is not \000. */
199 if (temp_len == options->print_max && temp_len < len)
200 {
201 ULONGEST val
202 = extract_unsigned_integer (valaddr + embedded_offset
203 + temp_len * eltlen,
204 eltlen, byte_order);
205 if (val != 0)
206 force_ellipses = 1;
207 }
208
209 len = temp_len;
210 }
211
212 LA_PRINT_STRING (stream, unresolved_elttype,
213 valaddr + embedded_offset, len,
214 NULL, force_ellipses, options);
215 i = len;
216 }
217 else
218 {
219 fprintf_filtered (stream, "{");
220 /* If this is a virtual function table, print the 0th
221 entry specially, and the rest of the members
222 normally. */
223 if (cp_is_vtbl_ptr_type (elttype))
224 {
225 i = 1;
226 fprintf_filtered (stream, _("%d vtable entries"),
227 len - 1);
228 }
229 else
230 {
231 i = 0;
232 }
233 val_print_array_elements (type, valaddr, embedded_offset,
234 address, stream,
235 recurse, original_value, options, i);
236 fprintf_filtered (stream, "}");
237 }
238 break;
239 }
240 /* Array of unspecified length: treat like pointer to first
241 elt. */
242 addr = address + embedded_offset;
243 goto print_unpacked_pointer;
244
245 case TYPE_CODE_METHODPTR:
246 cplus_print_method_ptr (valaddr + embedded_offset, type, stream);
247 break;
248
249 case TYPE_CODE_PTR:
250 if (options->format && options->format != 's')
251 {
252 val_print_scalar_formatted (type, valaddr, embedded_offset,
253 original_value, options, 0, stream);
254 break;
255 }
256 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
257 {
258 /* Print the unmangled name if desired. */
259 /* Print vtable entry - we only get here if we ARE using
260 -fvtable_thunks. (Otherwise, look under
261 TYPE_CODE_STRUCT.) */
262 CORE_ADDR addr
263 = extract_typed_address (valaddr + embedded_offset, type);
264
265 print_function_pointer_address (options, gdbarch, addr, stream);
266 break;
267 }
268 unresolved_elttype = TYPE_TARGET_TYPE (type);
269 elttype = check_typedef (unresolved_elttype);
270 {
271 int want_space;
272
273 addr = unpack_pointer (type, valaddr + embedded_offset);
274 print_unpacked_pointer:
275
276 want_space = 0;
277
278 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
279 {
280 /* Try to print what function it points to. */
281 print_function_pointer_address (options, gdbarch, addr, stream);
282 return;
283 }
284
285 if (options->symbol_print)
286 want_space = print_address_demangle (options, gdbarch, addr,
287 stream, demangle);
288 else if (options->addressprint)
289 {
290 fputs_filtered (paddress (gdbarch, addr), stream);
291 want_space = 1;
292 }
293
294 /* For a pointer to a textual type, also print the string
295 pointed to, unless pointer is null. */
296
297 if (c_textual_element_type (unresolved_elttype,
298 options->format)
299 && addr != 0)
300 {
301 if (want_space)
302 fputs_filtered (" ", stream);
303 i = val_print_string (unresolved_elttype, NULL,
304 addr, -1,
305 stream, options);
306 }
307 else if (cp_is_vtbl_member (type))
308 {
309 /* Print vtbl's nicely. */
310 CORE_ADDR vt_address = unpack_pointer (type,
311 valaddr
312 + embedded_offset);
313 struct minimal_symbol *msymbol =
314 lookup_minimal_symbol_by_pc (vt_address);
315
316 /* If 'symbol_print' is set, we did the work above. */
317 if (!options->symbol_print
318 && (msymbol != NULL)
319 && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
320 {
321 if (want_space)
322 fputs_filtered (" ", stream);
323 fputs_filtered (" <", stream);
324 fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
325 fputs_filtered (">", stream);
326 want_space = 1;
327 }
328
329 if (vt_address && options->vtblprint)
330 {
331 struct value *vt_val;
332 struct symbol *wsym = (struct symbol *) NULL;
333 struct type *wtype;
334 struct block *block = (struct block *) NULL;
335 struct field_of_this_result is_this_fld;
336
337 if (want_space)
338 fputs_filtered (" ", stream);
339
340 if (msymbol != NULL)
341 wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
342 block, VAR_DOMAIN,
343 &is_this_fld);
344
345 if (wsym)
346 {
347 wtype = SYMBOL_TYPE (wsym);
348 }
349 else
350 {
351 wtype = unresolved_elttype;
352 }
353 vt_val = value_at (wtype, vt_address);
354 common_val_print (vt_val, stream, recurse + 1,
355 options, current_language);
356 if (options->pretty)
357 {
358 fprintf_filtered (stream, "\n");
359 print_spaces_filtered (2 + 2 * recurse, stream);
360 }
361 }
362 }
363 return;
364 }
365 break;
366
367 case TYPE_CODE_UNION:
368 if (recurse && !options->unionprint)
369 {
370 fprintf_filtered (stream, "{...}");
371 break;
372 }
373 /* Fall through. */
374 case TYPE_CODE_STRUCT:
375 /*FIXME: Abstract this away. */
376 if (options->vtblprint && cp_is_vtbl_ptr_type (type))
377 {
378 /* Print the unmangled name if desired. */
379 /* Print vtable entry - we only get here if NOT using
380 -fvtable_thunks. (Otherwise, look under
381 TYPE_CODE_PTR.) */
382 int offset = (embedded_offset
383 + TYPE_FIELD_BITPOS (type,
384 VTBL_FNADDR_OFFSET) / 8);
385 struct type *field_type = TYPE_FIELD_TYPE (type,
386 VTBL_FNADDR_OFFSET);
387 CORE_ADDR addr
388 = extract_typed_address (valaddr + offset, field_type);
389
390 print_function_pointer_address (options, gdbarch, addr, stream);
391 }
392 else
393 cp_print_value_fields_rtti (type, valaddr,
394 embedded_offset, address,
395 stream, recurse,
396 original_value, options,
397 NULL, 0);
398 break;
399
400 case TYPE_CODE_INT:
401 if (options->format || options->output_format)
402 {
403 struct value_print_options opts = *options;
404
405 opts.format = (options->format ? options->format
406 : options->output_format);
407 val_print_scalar_formatted (type, valaddr, embedded_offset,
408 original_value, &opts, 0, stream);
409 }
410 else
411 {
412 val_print_type_code_int (type, valaddr + embedded_offset,
413 stream);
414 /* C and C++ has no single byte int type, char is used
415 instead. Since we don't know whether the value is really
416 intended to be used as an integer or a character, print
417 the character equivalent as well. */
418 if (c_textual_element_type (unresolved_type, options->format))
419 {
420 fputs_filtered (" ", stream);
421 LA_PRINT_CHAR (unpack_long (type, valaddr + embedded_offset),
422 unresolved_type, stream);
423 }
424 }
425 break;
426
427 case TYPE_CODE_MEMBERPTR:
428 if (!options->format)
429 {
430 cp_print_class_member (valaddr + embedded_offset, type, stream, "&");
431 break;
432 }
433 /* FALLTHROUGH */
434
435 case TYPE_CODE_REF:
436 case TYPE_CODE_ENUM:
437 case TYPE_CODE_FLAGS:
438 case TYPE_CODE_FUNC:
439 case TYPE_CODE_METHOD:
440 case TYPE_CODE_BOOL:
441 case TYPE_CODE_RANGE:
442 case TYPE_CODE_FLT:
443 case TYPE_CODE_DECFLOAT:
444 case TYPE_CODE_VOID:
445 case TYPE_CODE_ERROR:
446 case TYPE_CODE_UNDEF:
447 case TYPE_CODE_COMPLEX:
448 case TYPE_CODE_CHAR:
449 default:
450 generic_val_print (type, valaddr, embedded_offset, address,
451 stream, recurse, original_value, options,
452 &c_decorations);
453 break;
454 }
455 gdb_flush (stream);
456 }
457
458 void
c_value_print(struct value * val,struct ui_file * stream,const struct value_print_options * options)459 c_value_print (struct value *val, struct ui_file *stream,
460 const struct value_print_options *options)
461 {
462 struct type *type, *real_type, *val_type;
463 int full, top, using_enc;
464 struct value_print_options opts = *options;
465
466 opts.deref_ref = 1;
467
468 /* If it is a pointer, indicate what it points to.
469
470 Print type also if it is a reference.
471
472 C++: if it is a member pointer, we will take care
473 of that when we print it. */
474
475 /* Preserve the original type before stripping typedefs. We prefer
476 to pass down the original type when possible, but for local
477 checks it is better to look past the typedefs. */
478 val_type = value_type (val);
479 type = check_typedef (val_type);
480
481 if (TYPE_CODE (type) == TYPE_CODE_PTR
482 || TYPE_CODE (type) == TYPE_CODE_REF)
483 {
484 /* Hack: remove (char *) for char strings. Their
485 type is indicated by the quoted string anyway.
486 (Don't use c_textual_element_type here; quoted strings
487 are always exactly (char *), (wchar_t *), or the like. */
488 if (TYPE_CODE (val_type) == TYPE_CODE_PTR
489 && TYPE_NAME (val_type) == NULL
490 && TYPE_NAME (TYPE_TARGET_TYPE (val_type)) != NULL
491 && (strcmp (TYPE_NAME (TYPE_TARGET_TYPE (val_type)),
492 "char") == 0
493 || textual_name (TYPE_NAME (TYPE_TARGET_TYPE (val_type)))))
494 {
495 /* Print nothing. */
496 }
497 else if (options->objectprint
498 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
499 {
500
501 if (TYPE_CODE(type) == TYPE_CODE_REF)
502 {
503 /* Copy value, change to pointer, so we don't get an
504 error about a non-pointer type in
505 value_rtti_target_type. */
506 struct value *temparg;
507 temparg=value_copy(val);
508 deprecated_set_value_type
509 (temparg, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
510 val = temparg;
511 }
512 /* Pointer to class, check real type of object. */
513 fprintf_filtered (stream, "(");
514
515 if (value_entirely_available (val))
516 {
517 real_type = value_rtti_indirect_type (val, &full, &top,
518 &using_enc);
519 if (real_type)
520 {
521 /* RTTI entry found. */
522 type = real_type;
523
524 /* Need to adjust pointer value. */
525 val = value_from_pointer (type, value_as_address (val) - top);
526
527 /* Note: When we look up RTTI entries, we don't get
528 any information on const or volatile
529 attributes. */
530 }
531 }
532 type_print (type, "", stream, -1);
533 fprintf_filtered (stream, ") ");
534 val_type = type;
535 }
536 else
537 {
538 /* normal case */
539 fprintf_filtered (stream, "(");
540 type_print (value_type (val), "", stream, -1);
541 fprintf_filtered (stream, ") ");
542 }
543 }
544
545 if (!value_initialized (val))
546 fprintf_filtered (stream, " [uninitialized] ");
547
548 if (options->objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
549 {
550 /* Attempt to determine real type of object. */
551 real_type = value_rtti_type (val, &full, &top, &using_enc);
552 if (real_type)
553 {
554 /* We have RTTI information, so use it. */
555 val = value_full_object (val, real_type,
556 full, top, using_enc);
557 fprintf_filtered (stream, "(%s%s) ",
558 TYPE_NAME (real_type),
559 full ? "" : _(" [incomplete object]"));
560 /* Print out object: enclosing type is same as real_type if
561 full. */
562 val_print (value_enclosing_type (val),
563 value_contents_for_printing (val), 0,
564 value_address (val), stream, 0,
565 val, &opts, current_language);
566 return;
567 /* Note: When we look up RTTI entries, we don't get any
568 information on const or volatile attributes. */
569 }
570 else if (type != check_typedef (value_enclosing_type (val)))
571 {
572 /* No RTTI information, so let's do our best. */
573 fprintf_filtered (stream, "(%s ?) ",
574 TYPE_NAME (value_enclosing_type (val)));
575 val_print (value_enclosing_type (val),
576 value_contents_for_printing (val), 0,
577 value_address (val), stream, 0,
578 val, &opts, current_language);
579 return;
580 }
581 /* Otherwise, we end up at the return outside this "if". */
582 }
583
584 val_print (val_type, value_contents_for_printing (val),
585 value_embedded_offset (val),
586 value_address (val),
587 stream, 0,
588 val, &opts, current_language);
589 }
590