GDB (xrefs)

/tmp/gdb-8.1/gdb/valprint.c
Go to the documentation of this file.
1 /* Print values for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 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 "value.h"
24 #include "gdbcore.h"
25 #include "gdbcmd.h"
26 #include "target.h"
27 #include "language.h"
28 #include "annotate.h"
29 #include "valprint.h"
30 #include "target-float.h"
31 #include "extension.h"
32 #include "ada-lang.h"
33 #include "gdb_obstack.h"
34 #include "charset.h"
35 #include "typeprint.h"
36 #include <ctype.h>
37 #include <algorithm>
38 #include "common/byte-vector.h"
39
40 /* Maximum number of wchars returned from wchar_iterate. */
41 #define MAX_WCHARS 4
42
43 /* A convenience macro to compute the size of a wchar_t buffer containing X
44 characters. */
45 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
46
47 /* Character buffer size saved while iterating over wchars. */
48 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
49
50 /* A structure to encapsulate state information from iterated
51 character conversions. */
52 struct converted_character
53 {
54 /* The number of characters converted. */
55 int num_chars;
56
57 /* The result of the conversion. See charset.h for more. */
58 enum wchar_iterate_result result;
59
60 /* The (saved) converted character(s). */
61 gdb_wchar_t chars[WCHAR_BUFLEN_MAX];
62
63 /* The first converted target byte. */
64 const gdb_byte *buf;
65
66 /* The number of bytes converted. */
67 size_t buflen;
68
69 /* How many times this character(s) is repeated. */
70 int repeat_count;
71 };
72
73 typedef struct converted_character converted_character_d;
74 DEF_VEC_O (converted_character_d);
75
76 /* Command lists for set/show print raw. */
77 struct cmd_list_element *setprintrawlist;
78 struct cmd_list_element *showprintrawlist;
79
80 /* Prototypes for local functions */
81
82 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
83 int len, int *errptr);
84
85 static void set_input_radix_1 (int, unsigned);
86
87 static void set_output_radix_1 (int, unsigned);
88
89 static void val_print_type_code_flags (struct type *type,
90 const gdb_byte *valaddr,
91 struct ui_file *stream);
92
93 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
94
95 struct value_print_options user_print_options =
96 {
97 Val_prettyformat_default, /* prettyformat */
98 0, /* prettyformat_arrays */
99 0, /* prettyformat_structs */
100 0, /* vtblprint */
101 1, /* unionprint */
102 1, /* addressprint */
103 0, /* objectprint */
104 PRINT_MAX_DEFAULT, /* print_max */
105 10, /* repeat_count_threshold */
106 0, /* output_format */
107 0, /* format */
108 0, /* stop_print_at_null */
109 0, /* print_array_indexes */
110 0, /* deref_ref */
111 1, /* static_field_print */
112 1, /* pascal_static_field_print */
113 0, /* raw */
114 0, /* summary */
115 1 /* symbol_print */
116 };
117
118 /* Initialize *OPTS to be a copy of the user print options. */
119 void
120 get_user_print_options (struct value_print_options *opts)
121 {
122 *opts = user_print_options;
123 }
124
125 /* Initialize *OPTS to be a copy of the user print options, but with
126 pretty-formatting disabled. */
127 void
128 get_no_prettyformat_print_options (struct value_print_options *opts)
129 {
130 *opts = user_print_options;
131 opts->prettyformat = Val_no_prettyformat;
132 }
133
134 /* Initialize *OPTS to be a copy of the user print options, but using
135 FORMAT as the formatting option. */
136 void
137 get_formatted_print_options (struct value_print_options *opts,
138 char format)
139 {
140 *opts = user_print_options;
141 opts->format = format;
142 }
143
144 static void
145 show_print_max (struct ui_file *file, int from_tty,
146 struct cmd_list_element *c, const char *value)
147 {
148 fprintf_filtered (file,
149 _("Limit on string chars or array "
150 "elements to print is %s.\n"),
151 value);
152 }
153
154
155 /* Default input and output radixes, and output format letter. */
156
157 unsigned input_radix = 10;
158 static void
159 show_input_radix (struct ui_file *file, int from_tty,
160 struct cmd_list_element *c, const char *value)
161 {
162 fprintf_filtered (file,
163 _("Default input radix for entering numbers is %s.\n"),
164 value);
165 }
166
167 unsigned output_radix = 10;
168 static void
169 show_output_radix (struct ui_file *file, int from_tty,
170 struct cmd_list_element *c, const char *value)
171 {
172 fprintf_filtered (file,
173 _("Default output radix for printing of values is %s.\n"),
174 value);
175 }
176
177 /* By default we print arrays without printing the index of each element in
178 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
179
180 static void
181 show_print_array_indexes (struct ui_file *file, int from_tty,
182 struct cmd_list_element *c, const char *value)
183 {
184 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
185 }
186
187 /* Print repeat counts if there are more than this many repetitions of an
188 element in an array. Referenced by the low level language dependent
189 print routines. */
190
191 static void
192 show_repeat_count_threshold (struct ui_file *file, int from_tty,
193 struct cmd_list_element *c, const char *value)
194 {
195 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
196 value);
197 }
198
199 /* If nonzero, stops printing of char arrays at first null. */
200
201 static void
202 show_stop_print_at_null (struct ui_file *file, int from_tty,
203 struct cmd_list_element *c, const char *value)
204 {
205 fprintf_filtered (file,
206 _("Printing of char arrays to stop "
207 "at first null char is %s.\n"),
208 value);
209 }
210
211 /* Controls pretty printing of structures. */
212
213 static void
214 show_prettyformat_structs (struct ui_file *file, int from_tty,
215 struct cmd_list_element *c, const char *value)
216 {
217 fprintf_filtered (file, _("Pretty formatting of structures is %s.\n"), value);
218 }
219
220 /* Controls pretty printing of arrays. */
221
222 static void
223 show_prettyformat_arrays (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
225 {
226 fprintf_filtered (file, _("Pretty formatting of arrays is %s.\n"), value);
227 }
228
229 /* If nonzero, causes unions inside structures or other unions to be
230 printed. */
231
232 static void
233 show_unionprint (struct ui_file *file, int from_tty,
234 struct cmd_list_element *c, const char *value)
235 {
236 fprintf_filtered (file,
237 _("Printing of unions interior to structures is %s.\n"),
238 value);
239 }
240
241 /* If nonzero, causes machine addresses to be printed in certain contexts. */
242
243 static void
244 show_addressprint (struct ui_file *file, int from_tty,
245 struct cmd_list_element *c, const char *value)
246 {
247 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
248 }
249
250 static void
251 show_symbol_print (struct ui_file *file, int from_tty,
252 struct cmd_list_element *c, const char *value)
253 {
254 fprintf_filtered (file,
255 _("Printing of symbols when printing pointers is %s.\n"),
256 value);
257 }
258
259
260
261 /* A helper function for val_print. When printing in "summary" mode,
262 we want to print scalar arguments, but not aggregate arguments.
263 This function distinguishes between the two. */
264
265 int
266 val_print_scalar_type_p (struct type *type)
267 {
268 type = check_typedef (type);
269 while (TYPE_IS_REFERENCE (type))
270 {
271 type = TYPE_TARGET_TYPE (type);
272 type = check_typedef (type);
273 }
274 switch (TYPE_CODE (type))
275 {
276 case TYPE_CODE_ARRAY:
277 case TYPE_CODE_STRUCT:
278 case TYPE_CODE_UNION:
279 case TYPE_CODE_SET:
280 case TYPE_CODE_STRING:
281 return 0;
282 default:
283 return 1;
284 }
285 }
286
287 /* See its definition in value.h. */
288
289 int
290 valprint_check_validity (struct ui_file *stream,
291 struct type *type,
292 LONGEST embedded_offset,
293 const struct value *val)
294 {
295 type = check_typedef (type);
296
297 if (type_not_associated (type))
298 {
299 val_print_not_associated (stream);
300 return 0;
301 }
302
303 if (type_not_allocated (type))
304 {
305 val_print_not_allocated (stream);
306 return 0;
307 }
308
309 if (TYPE_CODE (type) != TYPE_CODE_UNION
310 && TYPE_CODE (type) != TYPE_CODE_STRUCT
311 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
312 {
313 if (value_bits_any_optimized_out (val,
314 TARGET_CHAR_BIT * embedded_offset,
315 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
316 {
317 val_print_optimized_out (val, stream);
318 return 0;
319 }
320
321 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
322 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
323 {
324 const int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
325 int ref_is_addressable = 0;
326
327 if (is_ref)
328 {
329 const struct value *deref_val = coerce_ref_if_computed (val);
330
331 if (deref_val != NULL)
332 ref_is_addressable = value_lval_const (deref_val) == lval_memory;
333 }
334
335 if (!is_ref || !ref_is_addressable)
336 fputs_filtered (_("<synthetic pointer>"), stream);
337
338 /* C++ references should be valid even if they're synthetic. */
339 return is_ref;
340 }
341
342 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
343 {
344 val_print_unavailable (stream);
345 return 0;
346 }
347 }
348
349 return 1;
350 }
351
352 void
353 val_print_optimized_out (const struct value *val, struct ui_file *stream)
354 {
355 if (val != NULL && value_lval_const (val) == lval_register)
356 val_print_not_saved (stream);
357 else
358 fprintf_filtered (stream, _("<optimized out>"));
359 }
360
361 void
362 val_print_not_saved (struct ui_file *stream)
363 {
364 fprintf_filtered (stream, _("<not saved>"));
365 }
366
367 void
368 val_print_unavailable (struct ui_file *stream)
369 {
370 fprintf_filtered (stream, _("<unavailable>"));
371 }
372
373 void
374 val_print_invalid_address (struct ui_file *stream)
375 {
376 fprintf_filtered (stream, _("<invalid address>"));
377 }
378
379 /* Print a pointer based on the type of its target.
380
381 Arguments to this functions are roughly the same as those in
382 generic_val_print. A difference is that ADDRESS is the address to print,
383 with embedded_offset already added. ELTTYPE represents
384 the pointed type after check_typedef. */
385
386 static void
387 print_unpacked_pointer (struct type *type, struct type *elttype,
388 CORE_ADDR address, struct ui_file *stream,
389 const struct value_print_options *options)
390 {
391 struct gdbarch *gdbarch = get_type_arch (type);
392
393 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
394 {
395 /* Try to print what function it points to. */
396 print_function_pointer_address (options, gdbarch, address, stream);
397 return;
398 }
399
400 if (options->symbol_print)
401 print_address_demangle (options, gdbarch, address, stream, demangle);
402 else if (options->addressprint)
403 fputs_filtered (paddress (gdbarch, address), stream);
404 }
405
406 /* generic_val_print helper for TYPE_CODE_ARRAY. */
407
408 static void
409 generic_val_print_array (struct type *type,
410 int embedded_offset, CORE_ADDR address,
411 struct ui_file *stream, int recurse,
412 struct value *original_value,
413 const struct value_print_options *options,
414 const struct
415 generic_val_print_decorations *decorations)
416 {
417 struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
418 struct type *elttype = check_typedef (unresolved_elttype);
419
420 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
421 {
422 LONGEST low_bound, high_bound;
423
424 if (!get_array_bounds (type, &low_bound, &high_bound))
425 error (_("Could not determine the array high bound"));
426
427 if (options->prettyformat_arrays)
428 {
429 print_spaces_filtered (2 + 2 * recurse, stream);
430 }
431
432 fputs_filtered (decorations->array_start, stream);
433 val_print_array_elements (type, embedded_offset,
434 address, stream,
435 recurse, original_value, options, 0);
436 fputs_filtered (decorations->array_end, stream);
437 }
438 else
439 {
440 /* Array of unspecified length: treat like pointer to first elt. */
441 print_unpacked_pointer (type, elttype, address + embedded_offset, stream,
442 options);
443 }
444
445 }
446
447 /* generic_val_print helper for TYPE_CODE_PTR. */
448
449 static void
450 generic_val_print_ptr (struct type *type,
451 int embedded_offset, struct ui_file *stream,
452 struct value *original_value,
453 const struct value_print_options *options)
454 {
455 struct gdbarch *gdbarch = get_type_arch (type);
456 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
457
458 if (options->format && options->format != 's')
459 {
460 val_print_scalar_formatted (type, embedded_offset,
461 original_value, options, 0, stream);
462 }
463 else
464 {
465 struct type *unresolved_elttype = TYPE_TARGET_TYPE(type);
466 struct type *elttype = check_typedef (unresolved_elttype);
467 const gdb_byte *valaddr = value_contents_for_printing (original_value);
468 CORE_ADDR addr = unpack_pointer (type,
469 valaddr + embedded_offset * unit_size);
470
471 print_unpacked_pointer (type, elttype, addr, stream, options);
472 }
473 }
474
475
476 /* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
477
478 static void
479 generic_val_print_memberptr (struct type *type,
480 int embedded_offset, struct ui_file *stream,
481 struct value *original_value,
482 const struct value_print_options *options)
483 {
484 val_print_scalar_formatted (type, embedded_offset,
485 original_value, options, 0, stream);
486 }
487
488 /* Print '@' followed by the address contained in ADDRESS_BUFFER. */
489
490 static void
491 print_ref_address (struct type *type, const gdb_byte *address_buffer,
492 int embedded_offset, struct ui_file *stream)
493 {
494 struct gdbarch *gdbarch = get_type_arch (type);
495
496 if (address_buffer != NULL)
497 {
498 CORE_ADDR address
499 = extract_typed_address (address_buffer + embedded_offset, type);
500
501 fprintf_filtered (stream, "@");
502 fputs_filtered (paddress (gdbarch, address), stream);
503 }
504 /* Else: we have a non-addressable value, such as a DW_AT_const_value. */
505 }
506
507 /* If VAL is addressable, return the value contents buffer of a value that
508 represents a pointer to VAL. Otherwise return NULL. */
509
510 static const gdb_byte *
511 get_value_addr_contents (struct value *deref_val)
512 {
513 gdb_assert (deref_val != NULL);
514
515 if (value_lval_const (deref_val) == lval_memory)
516 return value_contents_for_printing_const (value_addr (deref_val));
517 else
518 {
519 /* We have a non-addressable value, such as a DW_AT_const_value. */
520 return NULL;
521 }
522 }
523
524 /* generic_val_print helper for TYPE_CODE_{RVALUE_,}REF. */
525
526 static void
527 generic_val_print_ref (struct type *type,
528 int embedded_offset, struct ui_file *stream, int recurse,
529 struct value *original_value,
530 const struct value_print_options *options)
531 {
532 struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
533 struct value *deref_val = NULL;
534 const int value_is_synthetic
535 = value_bits_synthetic_pointer (original_value,
536 TARGET_CHAR_BIT * embedded_offset,
537 TARGET_CHAR_BIT * TYPE_LENGTH (type));
538 const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
539 || options->deref_ref);
540 const int type_is_defined = TYPE_CODE (elttype) != TYPE_CODE_UNDEF;
541 const gdb_byte *valaddr = value_contents_for_printing (original_value);
542
543 if (must_coerce_ref && type_is_defined)
544 {
545 deref_val = coerce_ref_if_computed (original_value);
546
547 if (deref_val != NULL)
548 {
549 /* More complicated computed references are not supported. */
550 gdb_assert (embedded_offset == 0);
551 }
552 else
553 deref_val = value_at (TYPE_TARGET_TYPE (type),
554 unpack_pointer (type, valaddr + embedded_offset));
555 }
556 /* Else, original_value isn't a synthetic reference or we don't have to print
557 the reference's contents.
558
559 Notice that for references to TYPE_CODE_STRUCT, 'set print object on' will
560 cause original_value to be a not_lval instead of an lval_computed,
561 which will make value_bits_synthetic_pointer return false.
562 This happens because if options->objectprint is true, c_value_print will
563 overwrite original_value's contents with the result of coercing
564 the reference through value_addr, and then set its type back to
565 TYPE_CODE_REF. In that case we don't have to coerce the reference again;
566 we can simply treat it as non-synthetic and move on. */
567
568 if (options->addressprint)
569 {
570 const gdb_byte *address = (value_is_synthetic && type_is_defined
571 ? get_value_addr_contents (deref_val)
572 : valaddr);
573
574 print_ref_address (type, address, embedded_offset, stream);
575
576 if (options->deref_ref)
577 fputs_filtered (": ", stream);
578 }
579
580 if (options->deref_ref)
581 {
582 if (type_is_defined)
583 common_val_print (deref_val, stream, recurse, options,
584 current_language);
585 else
586 fputs_filtered ("???", stream);
587 }
588 }
589
590 /* Helper function for generic_val_print_enum.
591 This is also used to print enums in TYPE_CODE_FLAGS values. */
592
593 static void
594 generic_val_print_enum_1 (struct type *type, LONGEST val,
595 struct ui_file *stream)
596 {
597 unsigned int i;
598 unsigned int len;
599
600 len = TYPE_NFIELDS (type);
601 for (i = 0; i < len; i++)
602 {
603 QUIT;
604 if (val == TYPE_FIELD_ENUMVAL (type, i))
605 {
606 break;
607 }
608 }
609 if (i < len)
610 {
611 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
612 }
613 else if (TYPE_FLAG_ENUM (type))
614 {
615 int first = 1;
616
617 /* We have a "flag" enum, so we try to decompose it into
618 pieces as appropriate. A flag enum has disjoint
619 constants by definition. */
620 fputs_filtered ("(", stream);
621 for (i = 0; i < len; ++i)
622 {
623 QUIT;
624
625 if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0)
626 {
627 if (!first)
628 fputs_filtered (" | ", stream);
629 first = 0;
630
631 val &= ~TYPE_FIELD_ENUMVAL (type, i);
632 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
633 }
634 }
635
636 if (first || val != 0)
637 {
638 if (!first)
639 fputs_filtered (" | ", stream);
640 fputs_filtered ("unknown: ", stream);
641 print_longest (stream, 'd', 0, val);
642 }
643
644 fputs_filtered (")", stream);
645 }
646 else
647 print_longest (stream, 'd', 0, val);
648 }
649
650 /* generic_val_print helper for TYPE_CODE_ENUM. */
651
652 static void
653 generic_val_print_enum (struct type *type,
654 int embedded_offset, struct ui_file *stream,
655 struct value *original_value,
656 const struct value_print_options *options)
657 {
658 LONGEST val;
659 struct gdbarch *gdbarch = get_type_arch (type);
660 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
661
662 if (options->format)
663 {
664 val_print_scalar_formatted (type, embedded_offset,
665 original_value, options, 0, stream);
666 }
667 else
668 {
669 const gdb_byte *valaddr = value_contents_for_printing (original_value);
670
671 val = unpack_long (type, valaddr + embedded_offset * unit_size);
672
673 generic_val_print_enum_1 (type, val, stream);
674 }
675 }
676
677 /* generic_val_print helper for TYPE_CODE_FLAGS. */
678
679 static void
680 generic_val_print_flags (struct type *type,
681 int embedded_offset, struct ui_file *stream,
682 struct value *original_value,
683 const struct value_print_options *options)
684
685 {
686 if (options->format)
687 val_print_scalar_formatted (type, embedded_offset, original_value,
688 options, 0, stream);
689 else
690 {
691 const gdb_byte *valaddr = value_contents_for_printing (original_value);
692
693 val_print_type_code_flags (type, valaddr + embedded_offset, stream);
694 }
695 }
696
697 /* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
698
699 static void
700 generic_val_print_func (struct type *type,
701 int embedded_offset, CORE_ADDR address,
702 struct ui_file *stream,
703 struct value *original_value,
704 const struct value_print_options *options)
705 {
706 struct gdbarch *gdbarch = get_type_arch (type);
707
708 if (options->format)
709 {
710 val_print_scalar_formatted (type, embedded_offset,
711 original_value, options, 0, stream);
712 }
713 else
714 {
715 /* FIXME, we should consider, at least for ANSI C language,
716 eliminating the distinction made between FUNCs and POINTERs
717 to FUNCs. */
718 fprintf_filtered (stream, "{");
719 type_print (type, "", stream, -1);
720 fprintf_filtered (stream, "} ");
721 /* Try to print what function it points to, and its address. */
722 print_address_demangle (options, gdbarch, address, stream, demangle);
723 }
724 }
725
726 /* generic_val_print helper for TYPE_CODE_BOOL. */
727
728 static void
729 generic_val_print_bool (struct type *type,
730 int embedded_offset, struct ui_file *stream,
731 struct value *original_value,
732 const struct value_print_options *options,
733 const struct generic_val_print_decorations *decorations)
734 {
735 LONGEST val;
736 struct gdbarch *gdbarch = get_type_arch (type);
737 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
738
739 if (options->format || options->output_format)
740 {
741 struct value_print_options opts = *options;
742 opts.format = (options->format ? options->format
743 : options->output_format);
744 val_print_scalar_formatted (type, embedded_offset,
745 original_value, &opts, 0, stream);
746 }
747 else
748 {
749 const gdb_byte *valaddr = value_contents_for_printing (original_value);
750
751 val = unpack_long (type, valaddr + embedded_offset * unit_size);
752 if (val == 0)
753 fputs_filtered (decorations->false_name, stream);
754 else if (val == 1)
755 fputs_filtered (decorations->true_name, stream);
756 else
757 print_longest (stream, 'd', 0, val);
758 }
759 }
760
761 /* generic_val_print helper for TYPE_CODE_INT. */
762
763 static void
764 generic_val_print_int (struct type *type,
765 int embedded_offset, struct ui_file *stream,
766 struct value *original_value,
767 const struct value_print_options *options)
768 {
769 struct value_print_options opts = *options;
770
771 opts.format = (options->format ? options->format
772 : options->output_format);
773 val_print_scalar_formatted (type, embedded_offset,
774 original_value, &opts, 0, stream);
775 }
776
777 /* generic_val_print helper for TYPE_CODE_CHAR. */
778
779 static void
780 generic_val_print_char (struct type *type, struct type *unresolved_type,
781 int embedded_offset,
782 struct ui_file *stream,
783 struct value *original_value,
784 const struct value_print_options *options)
785 {
786 LONGEST val;
787 struct gdbarch *gdbarch = get_type_arch (type);
788 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
789
790 if (options->format || options->output_format)
791 {
792 struct value_print_options opts = *options;
793
794 opts.format = (options->format ? options->format
795 : options->output_format);
796 val_print_scalar_formatted (type, embedded_offset,
797 original_value, &opts, 0, stream);
798 }
799 else
800 {
801 const gdb_byte *valaddr = value_contents_for_printing (original_value);
802
803 val = unpack_long (type, valaddr + embedded_offset * unit_size);
804 if (TYPE_UNSIGNED (type))
805 fprintf_filtered (stream, "%u", (unsigned int) val);
806 else
807 fprintf_filtered (stream, "%d", (int) val);
808 fputs_filtered (" ", stream);
809 LA_PRINT_CHAR (val, unresolved_type, stream);
810 }
811 }
812
813 /* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */
814
815 static void
816 generic_val_print_float (struct type *type,
817 int embedded_offset, struct ui_file *stream,
818 struct value *original_value,
819 const struct value_print_options *options)
820 {
821 struct gdbarch *gdbarch = get_type_arch (type);
822 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
823
824 if (options->format)
825 {
826 val_print_scalar_formatted (type, embedded_offset,
827 original_value, options, 0, stream);
828 }
829 else
830 {
831 const gdb_byte *valaddr = value_contents_for_printing (original_value);
832
833 print_floating (valaddr + embedded_offset * unit_size, type, stream);
834 }
835 }
836
837 /* generic_val_print helper for TYPE_CODE_COMPLEX. */
838
839 static void
840 generic_val_print_complex (struct type *type,
841 int embedded_offset, struct ui_file *stream,
842 struct value *original_value,
843 const struct value_print_options *options,
844 const struct generic_val_print_decorations
845 *decorations)
846 {
847 struct gdbarch *gdbarch = get_type_arch (type);
848 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
849 const gdb_byte *valaddr = value_contents_for_printing (original_value);
850
851 fprintf_filtered (stream, "%s", decorations->complex_prefix);
852 if (options->format)
853 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
854 embedded_offset, original_value, options, 0,
855 stream);
856 else
857 print_floating (valaddr + embedded_offset * unit_size,
858 TYPE_TARGET_TYPE (type), stream);
859 fprintf_filtered (stream, "%s", decorations->complex_infix);
860 if (options->format)
861 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
862 embedded_offset
863 + type_length_units (TYPE_TARGET_TYPE (type)),
864 original_value, options, 0, stream);
865 else
866 print_floating (valaddr + embedded_offset * unit_size
867 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
868 TYPE_TARGET_TYPE (type), stream);
869 fprintf_filtered (stream, "%s", decorations->complex_suffix);
870 }
871
872 /* A generic val_print that is suitable for use by language
873 implementations of the la_val_print method. This function can
874 handle most type codes, though not all, notably exception
875 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
876 the caller.
877
878 Most arguments are as to val_print.
879
880 The additional DECORATIONS argument can be used to customize the
881 output in some small, language-specific ways. */
882
883 void
884 generic_val_print (struct type *type,
885 int embedded_offset, CORE_ADDR address,
886 struct ui_file *stream, int recurse,
887 struct value *original_value,
888 const struct value_print_options *options,
889 const struct generic_val_print_decorations *decorations)
890 {
891 struct type *unresolved_type = type;
892
893 type = check_typedef (type);
894 switch (TYPE_CODE (type))
895 {
896 case TYPE_CODE_ARRAY:
897 generic_val_print_array (type, embedded_offset, address, stream,
898 recurse, original_value, options, decorations);
899 break;
900
901 case TYPE_CODE_MEMBERPTR:
902 generic_val_print_memberptr (type, embedded_offset, stream,
903 original_value, options);
904 break;
905
906 case TYPE_CODE_PTR:
907 generic_val_print_ptr (type, embedded_offset, stream,
908 original_value, options);
909 break;
910
911 case TYPE_CODE_REF:
912 case TYPE_CODE_RVALUE_REF:
913 generic_val_print_ref (type, embedded_offset, stream, recurse,
914 original_value, options);
915 break;
916
917 case TYPE_CODE_ENUM:
918 generic_val_print_enum (type, embedded_offset, stream,
919 original_value, options);
920 break;
921
922 case TYPE_CODE_FLAGS:
923 generic_val_print_flags (type, embedded_offset, stream,
924 original_value, options);
925 break;
926
927 case TYPE_CODE_FUNC:
928 case TYPE_CODE_METHOD:
929 generic_val_print_func (type, embedded_offset, address, stream,
930 original_value, options);
931 break;
932
933 case TYPE_CODE_BOOL:
934 generic_val_print_bool (type, embedded_offset, stream,
935 original_value, options, decorations);
936 break;
937
938 case TYPE_CODE_RANGE:
939 /* FIXME: create_static_range_type does not set the unsigned bit in a
940 range type (I think it probably should copy it from the
941 target type), so we won't print values which are too large to
942 fit in a signed integer correctly. */
943 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
944 print with the target type, though, because the size of our
945 type and the target type might differ). */
946
947 /* FALLTHROUGH */
948
949 case TYPE_CODE_INT:
950 generic_val_print_int (type, embedded_offset, stream,
951 original_value, options);
952 break;
953
954 case TYPE_CODE_CHAR:
955 generic_val_print_char (type, unresolved_type, embedded_offset,
956 stream, original_value, options);
957 break;
958
959 case TYPE_CODE_FLT:
960 case TYPE_CODE_DECFLOAT:
961 generic_val_print_float (type, embedded_offset, stream,
962 original_value, options);
963 break;
964
965 case TYPE_CODE_VOID:
966 fputs_filtered (decorations->void_name, stream);
967 break;
968
969 case TYPE_CODE_ERROR:
970 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
971 break;
972
973 case TYPE_CODE_UNDEF:
974 /* This happens (without TYPE_STUB set) on systems which don't use
975 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
976 and no complete type for struct foo in that file. */
977 fprintf_filtered (stream, _("<incomplete type>"));
978 break;
979
980 case TYPE_CODE_COMPLEX:
981 generic_val_print_complex (type, embedded_offset, stream,
982 original_value, options, decorations);
983 break;
984
985 case TYPE_CODE_UNION:
986 case TYPE_CODE_STRUCT:
987 case TYPE_CODE_METHODPTR:
988 default:
989 error (_("Unhandled type code %d in symbol table."),
990 TYPE_CODE (type));
991 }
992 gdb_flush (stream);
993 }
994
995 /* Print using the given LANGUAGE the data of type TYPE located at
996 VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came
997 from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto
998 stdio stream STREAM according to OPTIONS. VAL is the whole object
999 that came from ADDRESS.
1000
1001 The language printers will pass down an adjusted EMBEDDED_OFFSET to
1002 further helper subroutines as subfields of TYPE are printed. In
1003 such cases, VAL is passed down unadjusted, so
1004 that VAL can be queried for metadata about the contents data being
1005 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
1006 buffer. For example: "has this field been optimized out", or "I'm
1007 printing an object while inspecting a traceframe; has this
1008 particular piece of data been collected?".
1009
1010 RECURSE indicates the amount of indentation to supply before
1011 continuation lines; this amount is roughly twice the value of
1012 RECURSE. */
1013
1014 void
1015 val_print (struct type *type, LONGEST embedded_offset,
1016 CORE_ADDR address, struct ui_file *stream, int recurse,
1017 struct value *val,
1018 const struct value_print_options *options,
1019 const struct language_defn *language)
1020 {
1021 int ret = 0;
1022 struct value_print_options local_opts = *options;
1023 struct type *real_type = check_typedef (type);
1024
1025 if (local_opts.prettyformat == Val_prettyformat_default)
1026 local_opts.prettyformat = (local_opts.prettyformat_structs
1027 ? Val_prettyformat : Val_no_prettyformat);
1028
1029 QUIT;
1030
1031 /* Ensure that the type is complete and not just a stub. If the type is
1032 only a stub and we can't find and substitute its complete type, then
1033 print appropriate string and return. */
1034
1035 if (TYPE_STUB (real_type))
1036 {
1037 fprintf_filtered (stream, _("<incomplete type>"));
1038 gdb_flush (stream);
1039 return;
1040 }
1041
1042 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
1043 return;
1044
1045 if (!options->raw)
1046 {
1047 ret = apply_ext_lang_val_pretty_printer (type, embedded_offset,
1048 address, stream, recurse,
1049 val, options, language);
1050 if (ret)
1051 return;
1052 }
1053
1054 /* Handle summary mode. If the value is a scalar, print it;
1055 otherwise, print an ellipsis. */
1056 if (options->summary && !val_print_scalar_type_p (type))
1057 {
1058 fprintf_filtered (stream, "...");
1059 return;
1060 }
1061
1062 TRY
1063 {
1064 language->la_val_print (type, embedded_offset, address,
1065 stream, recurse, val,
1066 &local_opts);
1067 }
1068 CATCH (except, RETURN_MASK_ERROR)
1069 {
1070 fprintf_filtered (stream, _("<error reading variable>"));
1071 }
1072 END_CATCH
1073 }
1074
1075 /* Check whether the value VAL is printable. Return 1 if it is;
1076 return 0 and print an appropriate error message to STREAM according to
1077 OPTIONS if it is not. */
1078
1079 static int
1080 value_check_printable (struct value *val, struct ui_file *stream,
1081 const struct value_print_options *options)
1082 {
1083 if (val == 0)
1084 {
1085 fprintf_filtered (stream, _("<address of value unknown>"));
1086 return 0;
1087 }
1088
1089 if (value_entirely_optimized_out (val))
1090 {
1091 if (options->summary && !val_print_scalar_type_p (value_type (val)))
1092 fprintf_filtered (stream, "...");
1093 else
1094 val_print_optimized_out (val, stream);
1095 return 0;
1096 }
1097
1098 if (value_entirely_unavailable (val))
1099 {
1100 if (options->summary && !val_print_scalar_type_p (value_type (val)))
1101 fprintf_filtered (stream, "...");
1102 else
1103 val_print_unavailable (stream);
1104 return 0;
1105 }
1106
1107 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
1108 {
1109 fprintf_filtered (stream, _("<internal function %s>"),
1110 value_internal_function_name (val));
1111 return 0;
1112 }
1113
1114 if (type_not_associated (value_type (val)))
1115 {
1116 val_print_not_associated (stream);
1117 return 0;
1118 }
1119
1120 if (type_not_allocated (value_type (val)))
1121 {
1122 val_print_not_allocated (stream);
1123 return 0;
1124 }
1125
1126 return 1;
1127 }
1128
1129 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
1130 to OPTIONS.
1131
1132 This is a preferable interface to val_print, above, because it uses
1133 GDB's value mechanism. */
1134
1135 void
1136 common_val_print (struct value *val, struct ui_file *stream, int recurse,
1137 const struct value_print_options *options,
1138 const struct language_defn *language)
1139 {
1140 if (!value_check_printable (val, stream, options))
1141 return;
1142
1143 if (language->la_language == language_ada)
1144 /* The value might have a dynamic type, which would cause trouble
1145 below when trying to extract the value contents (since the value
1146 size is determined from the type size which is unknown). So
1147 get a fixed representation of our value. */
1148 val = ada_to_fixed_value (val);
1149
1150 if (value_lazy (val))
1151 value_fetch_lazy (val);
1152
1153 val_print (value_type (val),
1154 value_embedded_offset (val), value_address (val),
1155 stream, recurse,
1156 val, options, language);
1157 }
1158
1159 /* Print on stream STREAM the value VAL according to OPTIONS. The value
1160 is printed using the current_language syntax. */
1161
1162 void
1163 value_print (struct value *val, struct ui_file *stream,
1164 const struct value_print_options *options)
1165 {
1166 if (!value_check_printable (val, stream, options))
1167 return;
1168
1169 if (!options->raw)
1170 {
1171 int r
1172 = apply_ext_lang_val_pretty_printer (value_type (val),
1173 value_embedded_offset (val),
1174 value_address (val),
1175 stream, 0,
1176 val, options, current_language);
1177
1178 if (r)
1179 return;
1180 }
1181
1182 LA_VALUE_PRINT (val, stream, options);
1183 }
1184
1185 static void
1186 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
1187 struct ui_file *stream)
1188 {
1189 ULONGEST val = unpack_long (type, valaddr);
1190 int field, nfields = TYPE_NFIELDS (type);
1191 struct gdbarch *gdbarch = get_type_arch (type);
1192 struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
1193
1194 fputs_filtered ("[", stream);
1195 for (field = 0; field < nfields; field++)
1196 {
1197 if (TYPE_FIELD_NAME (type, field)[0] != '\0')
1198 {
1199 struct type *field_type = TYPE_FIELD_TYPE (type, field);
1200
1201 if (field_type == bool_type
1202 /* We require boolean types here to be one bit wide. This is a
1203 problematic place to notify the user of an internal error
1204 though. Instead just fall through and print the field as an
1205 int. */
1206 && TYPE_FIELD_BITSIZE (type, field) == 1)
1207 {
1208 if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
1209 fprintf_filtered (stream, " %s",
1210 TYPE_FIELD_NAME (type, field));
1211 }
1212 else
1213 {
1214 unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
1215 ULONGEST field_val
1216 = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1);
1217
1218 if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
1219 field_val &= ((ULONGEST) 1 << field_len) - 1;
1220 fprintf_filtered (stream, " %s=",
1221 TYPE_FIELD_NAME (type, field));
1222 if (TYPE_CODE (field_type) == TYPE_CODE_ENUM)
1223 generic_val_print_enum_1 (field_type, field_val, stream);
1224 else
1225 print_longest (stream, 'd', 0, field_val);
1226 }
1227 }
1228 }
1229 fputs_filtered (" ]", stream);
1230 }
1231
1232 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
1233 according to OPTIONS and SIZE on STREAM. Format i is not supported
1234 at this level.
1235
1236 This is how the elements of an array or structure are printed
1237 with a format. */
1238
1239 void
1240 val_print_scalar_formatted (struct type *type,
1241 LONGEST embedded_offset,
1242 struct value *val,
1243 const struct value_print_options *options,
1244 int size,
1245 struct ui_file *stream)
1246 {
1247 struct gdbarch *arch = get_type_arch (type);
1248 int unit_size = gdbarch_addressable_memory_unit_size (arch);
1249
1250 gdb_assert (val != NULL);
1251
1252 /* If we get here with a string format, try again without it. Go
1253 all the way back to the language printers, which may call us
1254 again. */
1255 if (options->format == 's')
1256 {
1257 struct value_print_options opts = *options;
1258 opts.format = 0;
1259 opts.deref_ref = 0;
1260 val_print (type, embedded_offset, 0, stream, 0, val, &opts,
1261 current_language);
1262 return;
1263 }
1264
1265 /* value_contents_for_printing fetches all VAL's contents. They are
1266 needed to check whether VAL is optimized-out or unavailable
1267 below. */
1268 const gdb_byte *valaddr = value_contents_for_printing (val);
1269
1270 /* A scalar object that does not have all bits available can't be
1271 printed, because all bits contribute to its representation. */
1272 if (value_bits_any_optimized_out (val,
1273 TARGET_CHAR_BIT * embedded_offset,
1274 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
1275 val_print_optimized_out (val, stream);
1276 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
1277 val_print_unavailable (stream);
1278 else
1279 print_scalar_formatted (valaddr + embedded_offset * unit_size, type,
1280 options, size, stream);
1281 }
1282
1283 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1284 The raison d'etre of this function is to consolidate printing of
1285 LONG_LONG's into this one function. The format chars b,h,w,g are
1286 from print_scalar_formatted(). Numbers are printed using C
1287 format.
1288
1289 USE_C_FORMAT means to use C format in all cases. Without it,
1290 'o' and 'x' format do not include the standard C radix prefix
1291 (leading 0 or 0x).
1292
1293 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1294 and was intended to request formating according to the current
1295 language and would be used for most integers that GDB prints. The
1296 exceptional cases were things like protocols where the format of
1297 the integer is a protocol thing, not a user-visible thing). The
1298 parameter remains to preserve the information of what things might
1299 be printed with language-specific format, should we ever resurrect
1300 that capability. */
1301
1302 void
1303 print_longest (struct ui_file *stream, int format, int use_c_format,
1304 LONGEST val_long)
1305 {
1306 const char *val;
1307
1308 switch (format)
1309 {
1310 case 'd':
1311 val = int_string (val_long, 10, 1, 0, 1); break;
1312 case 'u':
1313 val = int_string (val_long, 10, 0, 0, 1); break;
1314 case 'x':
1315 val = int_string (val_long, 16, 0, 0, use_c_format); break;
1316 case 'b':
1317 val = int_string (val_long, 16, 0, 2, 1); break;
1318 case 'h':
1319 val = int_string (val_long, 16, 0, 4, 1); break;
1320 case 'w':
1321 val = int_string (val_long, 16, 0, 8, 1); break;
1322 case 'g':
1323 val = int_string (val_long, 16, 0, 16, 1); break;
1324 break;
1325 case 'o':
1326 val = int_string (val_long, 8, 0, 0, use_c_format); break;
1327 default:
1328 internal_error (__FILE__, __LINE__,
1329 _("failed internal consistency check"));
1330 }
1331 fputs_filtered (val, stream);
1332 }
1333
1334 /* This used to be a macro, but I don't think it is called often enough
1335 to merit such treatment. */
1336 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1337 arguments to a function, number in a value history, register number, etc.)
1338 where the value must not be larger than can fit in an int. */
1339
1340 int
1341 longest_to_int (LONGEST arg)
1342 {
1343 /* Let the compiler do the work. */
1344 int rtnval = (int) arg;
1345
1346 /* Check for overflows or underflows. */
1347 if (sizeof (LONGEST) > sizeof (int))
1348 {
1349 if (rtnval != arg)
1350 {
1351 error (_("Value out of range."));
1352 }
1353 }
1354 return (rtnval);
1355 }
1356
1357 /* Print a floating point value of floating-point type TYPE,
1358 pointed to in GDB by VALADDR, on STREAM. */
1359
1360 void
1361 print_floating (const gdb_byte *valaddr, struct type *type,
1362 struct ui_file *stream)
1363 {
1364 std::string str = target_float_to_string (valaddr, type);
1365 fputs_filtered (str.c_str (), stream);
1366 }
1367
1368 void
1369 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
1370 unsigned len, enum bfd_endian byte_order, bool zero_pad)
1371 {
1372 const gdb_byte *p;
1373 unsigned int i;
1374 int b;
1375 bool seen_a_one = false;
1376
1377 /* Declared "int" so it will be signed.
1378 This ensures that right shift will shift in zeros. */
1379
1380 const int mask = 0x080;
1381
1382 if (byte_order == BFD_ENDIAN_BIG)
1383 {
1384 for (p = valaddr;
1385 p < valaddr + len;
1386 p++)
1387 {
1388 /* Every byte has 8 binary characters; peel off
1389 and print from the MSB end. */
1390
1391 for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++)
1392 {
1393 if (*p & (mask >> i))
1394 b = '1';
1395 else
1396 b = '0';
1397
1398 if (zero_pad || seen_a_one || b == '1')
1399 fputc_filtered (b, stream);
1400 if (b == '1')
1401 seen_a_one = true;
1402 }
1403 }
1404 }
1405 else
1406 {
1407 for (p = valaddr + len - 1;
1408 p >= valaddr;
1409 p--)
1410 {
1411 for (i = 0; i < (HOST_CHAR_BIT * sizeof (*p)); i++)
1412 {
1413 if (*p & (mask >> i))
1414 b = '1';
1415 else
1416 b = '0';
1417
1418 if (zero_pad || seen_a_one || b == '1')
1419 fputc_filtered (b, stream);
1420 if (b == '1')
1421 seen_a_one = true;
1422 }
1423 }
1424 }
1425
1426 /* When not zero-padding, ensure that something is printed when the
1427 input is 0. */
1428 if (!zero_pad && !seen_a_one)
1429 fputc_filtered ('0', stream);
1430 }
1431
1432 /* A helper for print_octal_chars that emits a single octal digit,
1433 optionally suppressing it if is zero and updating SEEN_A_ONE. */
1434
1435 static void
1436 emit_octal_digit (struct ui_file *stream, bool *seen_a_one, int digit)
1437 {
1438 if (*seen_a_one || digit != 0)
1439 fprintf_filtered (stream, "%o", digit);
1440 if (digit != 0)
1441 *seen_a_one = true;
1442 }
1443
1444 /* VALADDR points to an integer of LEN bytes.
1445 Print it in octal on stream or format it in buf. */
1446
1447 void
1448 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1449 unsigned len, enum bfd_endian byte_order)
1450 {
1451 const gdb_byte *p;
1452 unsigned char octa1, octa2, octa3, carry;
1453 int cycle;
1454
1455 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1456 * the extra bits, which cycle every three bytes:
1457 *
1458 * Byte side: 0 1 2 3
1459 * | | | |
1460 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1461 *
1462 * Octal side: 0 1 carry 3 4 carry ...
1463 *
1464 * Cycle number: 0 1 2
1465 *
1466 * But of course we are printing from the high side, so we have to
1467 * figure out where in the cycle we are so that we end up with no
1468 * left over bits at the end.
1469 */
1470 #define BITS_IN_OCTAL 3
1471 #define HIGH_ZERO 0340
1472 #define LOW_ZERO 0034
1473 #define CARRY_ZERO 0003
1474 static_assert (HIGH_ZERO + LOW_ZERO + CARRY_ZERO == 0xff,
1475 "cycle zero constants are wrong");
1476 #define HIGH_ONE 0200
1477 #define MID_ONE 0160
1478 #define LOW_ONE 0016
1479 #define CARRY_ONE 0001
1480 static_assert (HIGH_ONE + MID_ONE + LOW_ONE + CARRY_ONE == 0xff,
1481 "cycle one constants are wrong");
1482 #define HIGH_TWO 0300
1483 #define MID_TWO 0070
1484 #define LOW_TWO 0007
1485 static_assert (HIGH_TWO + MID_TWO + LOW_TWO == 0xff,
1486 "cycle two constants are wrong");
1487
1488 /* For 32 we start in cycle 2, with two bits and one bit carry;
1489 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1490
1491 cycle = (len * HOST_CHAR_BIT) % BITS_IN_OCTAL;
1492 carry = 0;
1493
1494 fputs_filtered ("0", stream);
1495 bool seen_a_one = false;
1496 if (byte_order == BFD_ENDIAN_BIG)
1497 {
1498 for (p = valaddr;
1499 p < valaddr + len;
1500 p++)
1501 {
1502 switch (cycle)
1503 {
1504 case 0:
1505 /* No carry in, carry out two bits. */
1506
1507 octa1 = (HIGH_ZERO & *p) >> 5;
1508 octa2 = (LOW_ZERO & *p) >> 2;
1509 carry = (CARRY_ZERO & *p);
1510 emit_octal_digit (stream, &seen_a_one, octa1);
1511 emit_octal_digit (stream, &seen_a_one, octa2);
1512 break;
1513
1514 case 1:
1515 /* Carry in two bits, carry out one bit. */
1516
1517 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1518 octa2 = (MID_ONE & *p) >> 4;
1519 octa3 = (LOW_ONE & *p) >> 1;
1520 carry = (CARRY_ONE & *p);
1521 emit_octal_digit (stream, &seen_a_one, octa1);
1522 emit_octal_digit (stream, &seen_a_one, octa2);
1523 emit_octal_digit (stream, &seen_a_one, octa3);
1524 break;
1525
1526 case 2:
1527 /* Carry in one bit, no carry out. */
1528
1529 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1530 octa2 = (MID_TWO & *p) >> 3;
1531 octa3 = (LOW_TWO & *p);
1532 carry = 0;
1533 emit_octal_digit (stream, &seen_a_one, octa1);
1534 emit_octal_digit (stream, &seen_a_one, octa2);
1535 emit_octal_digit (stream, &seen_a_one, octa3);
1536 break;
1537
1538 default:
1539 error (_("Internal error in octal conversion;"));
1540 }
1541
1542 cycle++;
1543 cycle = cycle % BITS_IN_OCTAL;
1544 }
1545 }
1546 else
1547 {
1548 for (p = valaddr + len - 1;
1549 p >= valaddr;
1550 p--)
1551 {
1552 switch (cycle)
1553 {
1554 case 0:
1555 /* Carry out, no carry in */
1556
1557 octa1 = (HIGH_ZERO & *p) >> 5;
1558 octa2 = (LOW_ZERO & *p) >> 2;
1559 carry = (CARRY_ZERO & *p);
1560 emit_octal_digit (stream, &seen_a_one, octa1);
1561 emit_octal_digit (stream, &seen_a_one, octa2);
1562 break;
1563
1564 case 1:
1565 /* Carry in, carry out */
1566
1567 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1568 octa2 = (MID_ONE & *p) >> 4;
1569 octa3 = (LOW_ONE & *p) >> 1;
1570 carry = (CARRY_ONE & *p);
1571 emit_octal_digit (stream, &seen_a_one, octa1);
1572 emit_octal_digit (stream, &seen_a_one, octa2);
1573 emit_octal_digit (stream, &seen_a_one, octa3);
1574 break;
1575
1576 case 2:
1577 /* Carry in, no carry out */
1578
1579 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1580 octa2 = (MID_TWO & *p) >> 3;
1581 octa3 = (LOW_TWO & *p);
1582 carry = 0;
1583 emit_octal_digit (stream, &seen_a_one, octa1);
1584 emit_octal_digit (stream, &seen_a_one, octa2);
1585 emit_octal_digit (stream, &seen_a_one, octa3);
1586 break;
1587
1588 default:
1589 error (_("Internal error in octal conversion;"));
1590 }
1591
1592 cycle++;
1593 cycle = cycle % BITS_IN_OCTAL;
1594 }
1595 }
1596
1597 }
1598
1599 /* Possibly negate the integer represented by BYTES. It contains LEN
1600 bytes in the specified byte order. If the integer is negative,
1601 copy it into OUT_VEC, negate it, and return true. Otherwise, do
1602 nothing and return false. */
1603
1604 static bool
1605 maybe_negate_by_bytes (const gdb_byte *bytes, unsigned len,
1606 enum bfd_endian byte_order,
1607 gdb::byte_vector *out_vec)
1608 {
1609 gdb_byte sign_byte;
1610 if (byte_order == BFD_ENDIAN_BIG)
1611 sign_byte = bytes[0];
1612 else
1613 sign_byte = bytes[len - 1];
1614 if ((sign_byte & 0x80) == 0)
1615 return false;
1616
1617 out_vec->resize (len);
1618
1619 /* Compute -x == 1 + ~x. */
1620 if (byte_order == BFD_ENDIAN_LITTLE)
1621 {
1622 unsigned carry = 1;
1623 for (unsigned i = 0; i < len; ++i)
1624 {
1625 unsigned tem = (0xff & ~bytes[i]) + carry;
1626 (*out_vec)[i] = tem & 0xff;
1627 carry = tem / 256;
1628 }
1629 }
1630 else
1631 {
1632 unsigned carry = 1;
1633 for (unsigned i = len; i > 0; --i)
1634 {
1635 unsigned tem = (0xff & ~bytes[i - 1]) + carry;
1636 (*out_vec)[i - 1] = tem & 0xff;
1637 carry = tem / 256;
1638 }
1639 }
1640
1641 return true;
1642 }
1643
1644 /* VALADDR points to an integer of LEN bytes.
1645 Print it in decimal on stream or format it in buf. */
1646
1647 void
1648 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1649 unsigned len, bool is_signed,
1650 enum bfd_endian byte_order)
1651 {
1652 #define TEN 10
1653 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1654 #define CARRY_LEFT( x ) ((x) % TEN)
1655 #define SHIFT( x ) ((x) << 4)
1656 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1657 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1658
1659 const gdb_byte *p;
1660 int carry;
1661 int decimal_len;
1662 int i, j, decimal_digits;
1663 int dummy;
1664 int flip;
1665
1666 gdb::byte_vector negated_bytes;
1667 if (is_signed
1668 && maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes))
1669 {
1670 fputs_filtered ("-", stream);
1671 valaddr = negated_bytes.data ();
1672 }
1673
1674 /* Base-ten number is less than twice as many digits
1675 as the base 16 number, which is 2 digits per byte. */
1676
1677 decimal_len = len * 2 * 2;
1678 std::vector<unsigned char> digits (decimal_len, 0);
1679
1680 /* Ok, we have an unknown number of bytes of data to be printed in
1681 * decimal.
1682 *
1683 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1684 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1685 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1686 *
1687 * The trick is that "digits" holds a base-10 number, but sometimes
1688 * the individual digits are > 10.
1689 *
1690 * Outer loop is per nibble (hex digit) of input, from MSD end to
1691 * LSD end.
1692 */
1693 decimal_digits = 0; /* Number of decimal digits so far */
1694 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
1695 flip = 0;
1696 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
1697 {
1698 /*
1699 * Multiply current base-ten number by 16 in place.
1700 * Each digit was between 0 and 9, now is between
1701 * 0 and 144.
1702 */
1703 for (j = 0; j < decimal_digits; j++)
1704 {
1705 digits[j] = SHIFT (digits[j]);
1706 }
1707
1708 /* Take the next nibble off the input and add it to what
1709 * we've got in the LSB position. Bottom 'digit' is now
1710 * between 0 and 159.
1711 *
1712 * "flip" is used to run this loop twice for each byte.
1713 */
1714 if (flip == 0)
1715 {
1716 /* Take top nibble. */
1717
1718 digits[0] += HIGH_NIBBLE (*p);
1719 flip = 1;
1720 }
1721 else
1722 {
1723 /* Take low nibble and bump our pointer "p". */
1724
1725 digits[0] += LOW_NIBBLE (*p);
1726 if (byte_order == BFD_ENDIAN_BIG)
1727 p++;
1728 else
1729 p--;
1730 flip = 0;
1731 }
1732
1733 /* Re-decimalize. We have to do this often enough
1734 * that we don't overflow, but once per nibble is
1735 * overkill. Easier this way, though. Note that the
1736 * carry is often larger than 10 (e.g. max initial
1737 * carry out of lowest nibble is 15, could bubble all
1738 * the way up greater than 10). So we have to do
1739 * the carrying beyond the last current digit.
1740 */
1741 carry = 0;
1742 for (j = 0; j < decimal_len - 1; j++)
1743 {
1744 digits[j] += carry;
1745
1746 /* "/" won't handle an unsigned char with
1747 * a value that if signed would be negative.
1748 * So extend to longword int via "dummy".
1749 */
1750 dummy = digits[j];
1751 carry = CARRY_OUT (dummy);
1752 digits[j] = CARRY_LEFT (dummy);
1753
1754 if (j >= decimal_digits && carry == 0)
1755 {
1756 /*
1757 * All higher digits are 0 and we
1758 * no longer have a carry.
1759 *
1760 * Note: "j" is 0-based, "decimal_digits" is
1761 * 1-based.
1762 */
1763 decimal_digits = j + 1;
1764 break;
1765 }
1766 }
1767 }
1768
1769 /* Ok, now "digits" is the decimal representation, with
1770 the "decimal_digits" actual digits. Print! */
1771
1772 for (i = decimal_digits - 1; i > 0 && digits[i] == 0; --i)
1773 ;
1774
1775 for (; i >= 0; i--)
1776 {
1777 fprintf_filtered (stream, "%1d", digits[i]);
1778 }
1779 }
1780
1781 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1782
1783 void
1784 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
1785 unsigned len, enum bfd_endian byte_order,
1786 bool zero_pad)
1787 {
1788 const gdb_byte *p;
1789
1790 fputs_filtered ("0x", stream);
1791 if (byte_order == BFD_ENDIAN_BIG)
1792 {
1793 p = valaddr;
1794
1795 if (!zero_pad)
1796 {
1797 /* Strip leading 0 bytes, but be sure to leave at least a
1798 single byte at the end. */
1799 for (; p < valaddr + len - 1 && !*p; ++p)
1800 ;
1801 }
1802
1803 const gdb_byte *first = p;
1804 for (;
1805 p < valaddr + len;
1806 p++)
1807 {
1808 /* When not zero-padding, use a different format for the
1809 very first byte printed. */
1810 if (!zero_pad && p == first)
1811 fprintf_filtered (stream, "%x", *p);
1812 else
1813 fprintf_filtered (stream, "%02x", *p);
1814 }
1815 }
1816 else
1817 {
1818 p = valaddr + len - 1;
1819
1820 if (!zero_pad)
1821 {
1822 /* Strip leading 0 bytes, but be sure to leave at least a
1823 single byte at the end. */
1824 for (; p >= valaddr + 1 && !*p; --p)
1825 ;
1826 }
1827
1828 const gdb_byte *first = p;
1829 for (;
1830 p >= valaddr;
1831 p--)
1832 {
1833 /* When not zero-padding, use a different format for the
1834 very first byte printed. */
1835 if (!zero_pad && p == first)
1836 fprintf_filtered (stream, "%x", *p);
1837 else
1838 fprintf_filtered (stream, "%02x", *p);
1839 }
1840 }
1841 }
1842
1843 /* VALADDR points to a char integer of LEN bytes.
1844 Print it out in appropriate language form on stream.
1845 Omit any leading zero chars. */
1846
1847 void
1848 print_char_chars (struct ui_file *stream, struct type *type,
1849 const gdb_byte *valaddr,
1850 unsigned len, enum bfd_endian byte_order)
1851 {
1852 const gdb_byte *p;
1853
1854 if (byte_order == BFD_ENDIAN_BIG)
1855 {
1856 p = valaddr;
1857 while (p < valaddr + len - 1 && *p == 0)
1858 ++p;
1859
1860 while (p < valaddr + len)
1861 {
1862 LA_EMIT_CHAR (*p, type, stream, '\'');
1863 ++p;
1864 }
1865 }
1866 else
1867 {
1868 p = valaddr + len - 1;
1869 while (p > valaddr && *p == 0)
1870 --p;
1871
1872 while (p >= valaddr)
1873 {
1874 LA_EMIT_CHAR (*p, type, stream, '\'');
1875 --p;
1876 }
1877 }
1878 }
1879
1880 /* Print function pointer with inferior address ADDRESS onto stdio
1881 stream STREAM. */
1882
1883 void
1884 print_function_pointer_address (const struct value_print_options *options,
1885 struct gdbarch *gdbarch,
1886 CORE_ADDR address,
1887 struct ui_file *stream)
1888 {
1889 CORE_ADDR func_addr
1890 = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
1891 &current_target);
1892
1893 /* If the function pointer is represented by a description, print
1894 the address of the description. */
1895 if (options->addressprint && func_addr != address)
1896 {
1897 fputs_filtered ("@", stream);
1898 fputs_filtered (paddress (gdbarch, address), stream);
1899 fputs_filtered (": ", stream);
1900 }
1901 print_address_demangle (options, gdbarch, func_addr, stream, demangle);
1902 }
1903
1904
1905 /* Print on STREAM using the given OPTIONS the index for the element
1906 at INDEX of an array whose index type is INDEX_TYPE. */
1907
1908 void
1909 maybe_print_array_index (struct type *index_type, LONGEST index,
1910 struct ui_file *stream,
1911 const struct value_print_options *options)
1912 {
1913 struct value *index_value;
1914
1915 if (!options->print_array_indexes)
1916 return;
1917
1918 index_value = value_from_longest (index_type, index);
1919
1920 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1921 }
1922
1923 /* Called by various <lang>_val_print routines to print elements of an
1924 array in the form "<elem1>, <elem2>, <elem3>, ...".
1925
1926 (FIXME?) Assumes array element separator is a comma, which is correct
1927 for all languages currently handled.
1928 (FIXME?) Some languages have a notation for repeated array elements,
1929 perhaps we should try to use that notation when appropriate. */
1930
1931 void
1932 val_print_array_elements (struct type *type,
1933 LONGEST embedded_offset,
1934 CORE_ADDR address, struct ui_file *stream,
1935 int recurse,
1936 struct value *val,
1937 const struct value_print_options *options,
1938 unsigned int i)
1939 {
1940 unsigned int things_printed = 0;
1941 unsigned len;
1942 struct type *elttype, *index_type, *base_index_type;
1943 unsigned eltlen;
1944 /* Position of the array element we are examining to see
1945 whether it is repeated. */
1946 unsigned int rep1;
1947 /* Number of repetitions we have detected so far. */
1948 unsigned int reps;
1949 LONGEST low_bound, high_bound;
1950 LONGEST low_pos, high_pos;
1951
1952 elttype = TYPE_TARGET_TYPE (type);
1953 eltlen = type_length_units (check_typedef (elttype));
1954 index_type = TYPE_INDEX_TYPE (type);
1955
1956 if (get_array_bounds (type, &low_bound, &high_bound))
1957 {
1958 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
1959 base_index_type = TYPE_TARGET_TYPE (index_type);
1960 else
1961 base_index_type = index_type;
1962
1963 /* Non-contiguous enumerations types can by used as index types
1964 in some languages (e.g. Ada). In this case, the array length
1965 shall be computed from the positions of the first and last
1966 literal in the enumeration type, and not from the values
1967 of these literals. */
1968 if (!discrete_position (base_index_type, low_bound, &low_pos)
1969 || !discrete_position (base_index_type, high_bound, &high_pos))
1970 {
1971 warning (_("unable to get positions in array, use bounds instead"));
1972 low_pos = low_bound;
1973 high_pos = high_bound;
1974 }
1975
1976 /* The array length should normally be HIGH_POS - LOW_POS + 1.
1977 But we have to be a little extra careful, because some languages
1978 such as Ada allow LOW_POS to be greater than HIGH_POS for
1979 empty arrays. In that situation, the array length is just zero,
1980 not negative! */
1981 if (low_pos > high_pos)
1982 len = 0;
1983 else
1984 len = high_pos - low_pos + 1;
1985 }
1986 else
1987 {
1988 warning (_("unable to get bounds of array, assuming null array"));
1989 low_bound = 0;
1990 len = 0;
1991 }
1992
1993 annotate_array_section_begin (i, elttype);
1994
1995 for (; i < len && things_printed < options->print_max; i++)
1996 {
1997 if (i != 0)
1998 {
1999 if (options->prettyformat_arrays)
2000 {
2001 fprintf_filtered (stream, ",\n");
2002 print_spaces_filtered (2 + 2 * recurse, stream);
2003 }
2004 else
2005 {
2006 fprintf_filtered (stream, ", ");
2007 }
2008 }
2009 wrap_here (n_spaces (2 + 2 * recurse));
2010 maybe_print_array_index (index_type, i + low_bound,
2011 stream, options);
2012
2013 rep1 = i + 1;
2014 reps = 1;
2015 /* Only check for reps if repeat_count_threshold is not set to
2016 UINT_MAX (unlimited). */
2017 if (options->repeat_count_threshold < UINT_MAX)
2018 {
2019 while (rep1 < len
2020 && value_contents_eq (val,
2021 embedded_offset + i * eltlen,
2022 val,
2023 (embedded_offset
2024 + rep1 * eltlen),
2025 eltlen))
2026 {
2027 ++reps;
2028 ++rep1;
2029 }
2030 }
2031
2032 if (reps > options->repeat_count_threshold)
2033 {
2034 val_print (elttype, embedded_offset + i * eltlen,
2035 address, stream, recurse + 1, val, options,
2036 current_language);
2037 annotate_elt_rep (reps);
2038 fprintf_filtered (stream, " <repeats %u times>", reps);
2039 annotate_elt_rep_end ();
2040
2041 i = rep1 - 1;
2042 things_printed += options->repeat_count_threshold;
2043 }
2044 else
2045 {
2046 val_print (elttype, embedded_offset + i * eltlen,
2047 address,
2048 stream, recurse + 1, val, options, current_language);
2049 annotate_elt ();
2050 things_printed++;
2051 }
2052 }
2053 annotate_array_section_end ();
2054 if (i < len)
2055 {
2056 fprintf_filtered (stream, "...");
2057 }
2058 }
2059
2060 /* Read LEN bytes of target memory at address MEMADDR, placing the
2061 results in GDB's memory at MYADDR. Returns a count of the bytes
2062 actually read, and optionally a target_xfer_status value in the
2063 location pointed to by ERRPTR if ERRPTR is non-null. */
2064
2065 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
2066 function be eliminated. */
2067
2068 static int
2069 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
2070 int len, int *errptr)
2071 {
2072 int nread; /* Number of bytes actually read. */
2073 int errcode; /* Error from last read. */
2074
2075 /* First try a complete read. */
2076 errcode = target_read_memory (memaddr, myaddr, len);
2077 if (errcode == 0)
2078 {
2079 /* Got it all. */
2080 nread = len;
2081 }
2082 else
2083 {
2084 /* Loop, reading one byte at a time until we get as much as we can. */
2085 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
2086 {
2087 errcode = target_read_memory (memaddr++, myaddr++, 1);
2088 }
2089 /* If an error, the last read was unsuccessful, so adjust count. */
2090 if (errcode != 0)
2091 {
2092 nread--;
2093 }
2094 }
2095 if (errptr != NULL)
2096 {
2097 *errptr = errcode;
2098 }
2099 return (nread);
2100 }
2101
2102 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
2103 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
2104 allocated buffer containing the string, which the caller is responsible to
2105 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
2106 success, or a target_xfer_status on failure.
2107
2108 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2109 (including eventual NULs in the middle or end of the string).
2110
2111 If LEN is -1, stops at the first null character (not necessarily
2112 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2113 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2114 the string.
2115
2116 Unless an exception is thrown, BUFFER will always be allocated, even on
2117 failure. In this case, some characters might have been read before the
2118 failure happened. Check BYTES_READ to recognize this situation.
2119
2120 Note: There was a FIXME asking to make this code use target_read_string,
2121 but this function is more general (can read past null characters, up to
2122 given LEN). Besides, it is used much more often than target_read_string
2123 so it is more tested. Perhaps callers of target_read_string should use
2124 this function instead? */
2125
2126 int
2127 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
2128 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
2129 {
2130 int errcode; /* Errno returned from bad reads. */
2131 unsigned int nfetch; /* Chars to fetch / chars fetched. */
2132 gdb_byte *bufptr; /* Pointer to next available byte in
2133 buffer. */
2134 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2135
2136 /* Loop until we either have all the characters, or we encounter
2137 some error, such as bumping into the end of the address space. */
2138
2139 *buffer = NULL;
2140
2141 old_chain = make_cleanup (free_current_contents, buffer);
2142
2143 if (len > 0)
2144 {
2145 /* We want fetchlimit chars, so we might as well read them all in
2146 one operation. */
2147 unsigned int fetchlen = std::min ((unsigned) len, fetchlimit);
2148
2149 *buffer = (gdb_byte *) xmalloc (fetchlen * width);
2150 bufptr = *buffer;
2151
2152 nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
2153 / width;
2154 addr += nfetch * width;
2155 bufptr += nfetch * width;
2156 }
2157 else if (len == -1)
2158 {
2159 unsigned long bufsize = 0;
2160 unsigned int chunksize; /* Size of each fetch, in chars. */
2161 int found_nul; /* Non-zero if we found the nul char. */
2162 gdb_byte *limit; /* First location past end of fetch buffer. */
2163
2164 found_nul = 0;
2165 /* We are looking for a NUL terminator to end the fetching, so we
2166 might as well read in blocks that are large enough to be efficient,
2167 but not so large as to be slow if fetchlimit happens to be large.
2168 So we choose the minimum of 8 and fetchlimit. We used to use 200
2169 instead of 8 but 200 is way too big for remote debugging over a
2170 serial line. */
2171 chunksize = std::min (8u, fetchlimit);
2172
2173 do
2174 {
2175 QUIT;
2176 nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize);
2177
2178 if (*buffer == NULL)
2179 *buffer = (gdb_byte *) xmalloc (nfetch * width);
2180 else
2181 *buffer = (gdb_byte *) xrealloc (*buffer,
2182 (nfetch + bufsize) * width);
2183
2184 bufptr = *buffer + bufsize * width;
2185 bufsize += nfetch;
2186
2187 /* Read as much as we can. */
2188 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
2189 / width;
2190
2191 /* Scan this chunk for the null character that terminates the string
2192 to print. If found, we don't need to fetch any more. Note
2193 that bufptr is explicitly left pointing at the next character
2194 after the null character, or at the next character after the end
2195 of the buffer. */
2196
2197 limit = bufptr + nfetch * width;
2198 while (bufptr < limit)
2199 {
2200 unsigned long c;
2201
2202 c = extract_unsigned_integer (bufptr, width, byte_order);
2203 addr += width;
2204 bufptr += width;
2205 if (c == 0)
2206 {
2207 /* We don't care about any error which happened after
2208 the NUL terminator. */
2209 errcode = 0;
2210 found_nul = 1;
2211 break;
2212 }
2213 }
2214 }
2215 while (errcode == 0 /* no error */
2216 && bufptr - *buffer < fetchlimit * width /* no overrun */
2217 && !found_nul); /* haven't found NUL yet */
2218 }
2219 else
2220 { /* Length of string is really 0! */
2221 /* We always allocate *buffer. */
2222 *buffer = bufptr = (gdb_byte *) xmalloc (1);
2223 errcode = 0;
2224 }
2225
2226 /* bufptr and addr now point immediately beyond the last byte which we
2227 consider part of the string (including a '\0' which ends the string). */
2228 *bytes_read = bufptr - *buffer;
2229
2230 QUIT;
2231
2232 discard_cleanups (old_chain);
2233
2234 return errcode;
2235 }
2236
2237 /* Return true if print_wchar can display W without resorting to a
2238 numeric escape, false otherwise. */
2239
2240 static int
2241 wchar_printable (gdb_wchar_t w)
2242 {
2243 return (gdb_iswprint (w)
2244 || w == LCST ('\a') || w == LCST ('\b')
2245 || w == LCST ('\f') || w == LCST ('\n')
2246 || w == LCST ('\r') || w == LCST ('\t')
2247 || w == LCST ('\v'));
2248 }
2249
2250 /* A helper function that converts the contents of STRING to wide
2251 characters and then appends them to OUTPUT. */
2252
2253 static void
2254 append_string_as_wide (const char *string,
2255 struct obstack *output)
2256 {
2257 for (; *string; ++string)
2258 {
2259 gdb_wchar_t w = gdb_btowc (*string);
2260 obstack_grow (output, &w, sizeof (gdb_wchar_t));
2261 }
2262 }
2263
2264 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2265 original (target) bytes representing the character, ORIG_LEN is the
2266 number of valid bytes. WIDTH is the number of bytes in a base
2267 characters of the type. OUTPUT is an obstack to which wide
2268 characters are emitted. QUOTER is a (narrow) character indicating
2269 the style of quotes surrounding the character to be printed.
2270 NEED_ESCAPE is an in/out flag which is used to track numeric
2271 escapes across calls. */
2272
2273 static void
2274 print_wchar (gdb_wint_t w, const gdb_byte *orig,
2275 int orig_len, int width,
2276 enum bfd_endian byte_order,
2277 struct obstack *output,
2278 int quoter, int *need_escapep)
2279 {
2280 int need_escape = *need_escapep;
2281
2282 *need_escapep = 0;
2283
2284 /* iswprint implementation on Windows returns 1 for tab character.
2285 In order to avoid different printout on this host, we explicitly
2286 use wchar_printable function. */
2287 switch (w)
2288 {
2289 case LCST ('\a'):
2290 obstack_grow_wstr (output, LCST ("\\a"));
2291 break;
2292 case LCST ('\b'):
2293 obstack_grow_wstr (output, LCST ("\\b"));
2294 break;
2295 case LCST ('\f'):
2296 obstack_grow_wstr (output, LCST ("\\f"));
2297 break;
2298 case LCST ('\n'):
2299 obstack_grow_wstr (output, LCST ("\\n"));
2300 break;
2301 case LCST ('\r'):
2302 obstack_grow_wstr (output, LCST ("\\r"));
2303 break;
2304 case LCST ('\t'):
2305 obstack_grow_wstr (output, LCST ("\\t"));
2306 break;
2307 case LCST ('\v'):
2308 obstack_grow_wstr (output, LCST ("\\v"));
2309 break;
2310 default:
2311 {
2312 if (wchar_printable (w) && (!need_escape || (!gdb_iswdigit (w)
2313 && w != LCST ('8')
2314 && w != LCST ('9'))))
2315 {
2316 gdb_wchar_t wchar = w;
2317
2318 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
2319 obstack_grow_wstr (output, LCST ("\\"));
2320 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
2321 }
2322 else
2323 {
2324 int i;
2325
2326 for (i = 0; i + width <= orig_len; i += width)
2327 {
2328 char octal[30];
2329 ULONGEST value;
2330
2331 value = extract_unsigned_integer (&orig[i], width,
2332 byte_order);
2333 /* If the value fits in 3 octal digits, print it that
2334 way. Otherwise, print it as a hex escape. */
2335 if (value <= 0777)
2336 xsnprintf (octal, sizeof (octal), "\\%.3o",
2337 (int) (value & 0777));
2338 else
2339 xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
2340 append_string_as_wide (octal, output);
2341 }
2342 /* If we somehow have extra bytes, print them now. */
2343 while (i < orig_len)
2344 {
2345 char octal[5];
2346
2347 xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff);
2348 append_string_as_wide (octal, output);
2349 ++i;
2350 }
2351
2352 *need_escapep = 1;
2353 }
2354 break;
2355 }
2356 }
2357 }
2358
2359 /* Print the character C on STREAM as part of the contents of a
2360 literal string whose delimiter is QUOTER. ENCODING names the
2361 encoding of C. */
2362
2363 void
2364 generic_emit_char (int c, struct type *type, struct ui_file *stream,
2365 int quoter, const char *encoding)
2366 {
2367 enum bfd_endian byte_order
2368 = gdbarch_byte_order (get_type_arch (type));
2369 gdb_byte *buf;
2370 int need_escape = 0;
2371
2372 buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
2373 pack_long (buf, type, c);
2374
2375 wchar_iterator iter (buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type));
2376
2377 /* This holds the printable form of the wchar_t data. */
2378 auto_obstack wchar_buf;
2379
2380 while (1)
2381 {
2382 int num_chars;
2383 gdb_wchar_t *chars;
2384 const gdb_byte *buf;
2385 size_t buflen;
2386 int print_escape = 1;
2387 enum wchar_iterate_result result;
2388
2389 num_chars = iter.iterate (&result, &chars, &buf, &buflen);
2390 if (num_chars < 0)
2391 break;
2392 if (num_chars > 0)
2393 {
2394 /* If all characters are printable, print them. Otherwise,
2395 we're going to have to print an escape sequence. We
2396 check all characters because we want to print the target
2397 bytes in the escape sequence, and we don't know character
2398 boundaries there. */
2399 int i;
2400
2401 print_escape = 0;
2402 for (i = 0; i < num_chars; ++i)
2403 if (!wchar_printable (chars[i]))
2404 {
2405 print_escape = 1;
2406 break;
2407 }
2408
2409 if (!print_escape)
2410 {
2411 for (i = 0; i < num_chars; ++i)
2412 print_wchar (chars[i], buf, buflen,
2413 TYPE_LENGTH (type), byte_order,
2414 &wchar_buf, quoter, &need_escape);
2415 }
2416 }
2417
2418 /* This handles the NUM_CHARS == 0 case as well. */
2419 if (print_escape)
2420 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
2421 byte_order, &wchar_buf, quoter, &need_escape);
2422 }
2423
2424 /* The output in the host encoding. */
2425 auto_obstack output;
2426
2427 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2428 (gdb_byte *) obstack_base (&wchar_buf),
2429 obstack_object_size (&wchar_buf),
2430 sizeof (gdb_wchar_t), &output, translit_char);
2431 obstack_1grow (&output, '\0');
2432
2433 fputs_filtered ((const char *) obstack_base (&output), stream);
2434 }
2435
2436 /* Return the repeat count of the next character/byte in ITER,
2437 storing the result in VEC. */
2438
2439 static int
2440 count_next_character (wchar_iterator *iter,
2441 VEC (converted_character_d) **vec)
2442 {
2443 struct converted_character *current;
2444
2445 if (VEC_empty (converted_character_d, *vec))
2446 {
2447 struct converted_character tmp;
2448 gdb_wchar_t *chars;
2449
2450 tmp.num_chars
2451 = iter->iterate (&tmp.result, &chars, &tmp.buf, &tmp.buflen);
2452 if (tmp.num_chars > 0)
2453 {
2454 gdb_assert (tmp.num_chars < MAX_WCHARS);
2455 memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t));
2456 }
2457 VEC_safe_push (converted_character_d, *vec, &tmp);
2458 }
2459
2460 current = VEC_last (converted_character_d, *vec);
2461
2462 /* Count repeated characters or bytes. */
2463 current->repeat_count = 1;
2464 if (current->num_chars == -1)
2465 {
2466 /* EOF */
2467 return -1;
2468 }
2469 else
2470 {
2471 gdb_wchar_t *chars;
2472 struct converted_character d;
2473 int repeat;
2474
2475 d.repeat_count = 0;
2476
2477 while (1)
2478 {
2479 /* Get the next character. */
2480 d.num_chars = iter->iterate (&d.result, &chars, &d.buf, &d.buflen);
2481
2482 /* If a character was successfully converted, save the character
2483 into the converted character. */
2484 if (d.num_chars > 0)
2485 {
2486 gdb_assert (d.num_chars < MAX_WCHARS);
2487 memcpy (d.chars, chars, WCHAR_BUFLEN (d.num_chars));
2488 }
2489
2490 /* Determine if the current character is the same as this
2491 new character. */
2492 if (d.num_chars == current->num_chars && d.result == current->result)
2493 {
2494 /* There are two cases to consider:
2495
2496 1) Equality of converted character (num_chars > 0)
2497 2) Equality of non-converted character (num_chars == 0) */
2498 if ((current->num_chars > 0
2499 && memcmp (current->chars, d.chars,
2500 WCHAR_BUFLEN (current->num_chars)) == 0)
2501 || (current->num_chars == 0
2502 && current->buflen == d.buflen
2503 && memcmp (current->buf, d.buf, current->buflen) == 0))
2504 ++current->repeat_count;
2505 else
2506 break;
2507 }
2508 else
2509 break;
2510 }
2511
2512 /* Push this next converted character onto the result vector. */
2513 repeat = current->repeat_count;
2514 VEC_safe_push (converted_character_d, *vec, &d);
2515 return repeat;
2516 }
2517 }
2518
2519 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2520 character to use with string output. WIDTH is the size of the output
2521 character type. BYTE_ORDER is the the target byte order. OPTIONS
2522 is the user's print options. */
2523
2524 static void
2525 print_converted_chars_to_obstack (struct obstack *obstack,
2526 VEC (converted_character_d) *chars,
2527 int quote_char, int width,
2528 enum bfd_endian byte_order,
2529 const struct value_print_options *options)
2530 {
2531 unsigned int idx;
2532 struct converted_character *elem;
2533 enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
2534 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
2535 int need_escape = 0;
2536
2537 /* Set the start state. */
2538 idx = 0;
2539 last = state = START;
2540 elem = NULL;
2541
2542 while (1)
2543 {
2544 switch (state)
2545 {
2546 case START:
2547 /* Nothing to do. */
2548 break;
2549
2550 case SINGLE:
2551 {
2552 int j;
2553
2554 /* We are outputting a single character
2555 (< options->repeat_count_threshold). */
2556
2557 if (last != SINGLE)
2558 {
2559 /* We were outputting some other type of content, so we
2560 must output and a comma and a quote. */
2561 if (last != START)
2562 obstack_grow_wstr (obstack, LCST (", "));
2563 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2564 }
2565 /* Output the character. */
2566 for (j = 0; j < elem->repeat_count; ++j)
2567 {
2568 if (elem->result == wchar_iterate_ok)
2569 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2570 byte_order, obstack, quote_char, &need_escape);
2571 else
2572 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2573 byte_order, obstack, quote_char, &need_escape);
2574 }
2575 }
2576 break;
2577
2578 case REPEAT:
2579 {
2580 int j;
2581 char *s;
2582
2583 /* We are outputting a character with a repeat count
2584 greater than options->repeat_count_threshold. */
2585
2586 if (last == SINGLE)
2587 {
2588 /* We were outputting a single string. Terminate the
2589 string. */
2590 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2591 }
2592 if (last != START)
2593 obstack_grow_wstr (obstack, LCST (", "));
2594
2595 /* Output the character and repeat string. */
2596 obstack_grow_wstr (obstack, LCST ("'"));
2597 if (elem->result == wchar_iterate_ok)
2598 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2599 byte_order, obstack, quote_char, &need_escape);
2600 else
2601 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2602 byte_order, obstack, quote_char, &need_escape);
2603 obstack_grow_wstr (obstack, LCST ("'"));
2604 s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count);
2605 for (j = 0; s[j]; ++j)
2606 {
2607 gdb_wchar_t w = gdb_btowc (s[j]);
2608 obstack_grow (obstack, &w, sizeof (gdb_wchar_t));
2609 }
2610 xfree (s);
2611 }
2612 break;
2613
2614 case INCOMPLETE:
2615 /* We are outputting an incomplete sequence. */
2616 if (last == SINGLE)
2617 {
2618 /* If we were outputting a string of SINGLE characters,
2619 terminate the quote. */
2620 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2621 }
2622 if (last != START)
2623 obstack_grow_wstr (obstack, LCST (", "));
2624
2625 /* Output the incomplete sequence string. */
2626 obstack_grow_wstr (obstack, LCST ("<incomplete sequence "));
2627 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order,
2628 obstack, 0, &need_escape);
2629 obstack_grow_wstr (obstack, LCST (">"));
2630
2631 /* We do not attempt to outupt anything after this. */
2632 state = FINISH;
2633 break;
2634
2635 case FINISH:
2636 /* All done. If we were outputting a string of SINGLE
2637 characters, the string must be terminated. Otherwise,
2638 REPEAT and INCOMPLETE are always left properly terminated. */
2639 if (last == SINGLE)
2640 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2641
2642 return;
2643 }
2644
2645 /* Get the next element and state. */
2646 last = state;
2647 if (state != FINISH)
2648 {
2649 elem = VEC_index (converted_character_d, chars, idx++);
2650 switch (elem->result)
2651 {
2652 case wchar_iterate_ok:
2653 case wchar_iterate_invalid:
2654 if (elem->repeat_count > options->repeat_count_threshold)
2655 state = REPEAT;
2656 else
2657 state = SINGLE;
2658 break;
2659
2660 case wchar_iterate_incomplete:
2661 state = INCOMPLETE;
2662 break;
2663
2664 case wchar_iterate_eof:
2665 state = FINISH;
2666 break;
2667 }
2668 }
2669 }
2670 }
2671
2672 /* Print the character string STRING, printing at most LENGTH
2673 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2674 the type of each character. OPTIONS holds the printing options;
2675 printing stops early if the number hits print_max; repeat counts
2676 are printed as appropriate. Print ellipses at the end if we had to
2677 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2678 QUOTE_CHAR is the character to print at each end of the string. If
2679 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2680 omitted. */
2681
2682 void
2683 generic_printstr (struct ui_file *stream, struct type *type,
2684 const gdb_byte *string, unsigned int length,
2685 const char *encoding, int force_ellipses,
2686 int quote_char, int c_style_terminator,
2687 const struct value_print_options *options)
2688 {
2689 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2690 unsigned int i;
2691 int width = TYPE_LENGTH (type);
2692 struct cleanup *cleanup;
2693 int finished = 0;
2694 struct converted_character *last;
2695 VEC (converted_character_d) *converted_chars;
2696
2697 if (length == -1)
2698 {
2699 unsigned long current_char = 1;
2700
2701 for (i = 0; current_char; ++i)
2702 {
2703 QUIT;
2704 current_char = extract_unsigned_integer (string + i * width,
2705 width, byte_order);
2706 }
2707 length = i;
2708 }
2709
2710 /* If the string was not truncated due to `set print elements', and
2711 the last byte of it is a null, we don't print that, in
2712 traditional C style. */
2713 if (c_style_terminator
2714 && !force_ellipses
2715 && length > 0
2716 && (extract_unsigned_integer (string + (length - 1) * width,
2717 width, byte_order) == 0))
2718 length--;
2719
2720 if (length == 0)
2721 {
2722 fputs_filtered ("\"\"", stream);
2723 return;
2724 }
2725
2726 /* Arrange to iterate over the characters, in wchar_t form. */
2727 wchar_iterator iter (string, length * width, encoding, width);
2728 converted_chars = NULL;
2729 cleanup = make_cleanup (VEC_cleanup (converted_character_d),
2730 &converted_chars);
2731
2732 /* Convert characters until the string is over or the maximum
2733 number of printed characters has been reached. */
2734 i = 0;
2735 while (i < options->print_max)
2736 {
2737 int r;
2738
2739 QUIT;
2740
2741 /* Grab the next character and repeat count. */
2742 r = count_next_character (&iter, &converted_chars);
2743
2744 /* If less than zero, the end of the input string was reached. */
2745 if (r < 0)
2746 break;
2747
2748 /* Otherwise, add the count to the total print count and get
2749 the next character. */
2750 i += r;
2751 }
2752
2753 /* Get the last element and determine if the entire string was
2754 processed. */
2755 last = VEC_last (converted_character_d, converted_chars);
2756 finished = (last->result == wchar_iterate_eof);
2757
2758 /* Ensure that CONVERTED_CHARS is terminated. */
2759 last->result = wchar_iterate_eof;
2760
2761 /* WCHAR_BUF is the obstack we use to represent the string in
2762 wchar_t form. */
2763 auto_obstack wchar_buf;
2764
2765 /* Print the output string to the obstack. */
2766 print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char,
2767 width, byte_order, options);
2768
2769 if (force_ellipses || !finished)
2770 obstack_grow_wstr (&wchar_buf, LCST ("..."));
2771
2772 /* OUTPUT is where we collect `char's for printing. */
2773 auto_obstack output;
2774
2775 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2776 (gdb_byte *) obstack_base (&wchar_buf),
2777 obstack_object_size (&wchar_buf),
2778 sizeof (gdb_wchar_t), &output, translit_char);
2779 obstack_1grow (&output, '\0');
2780
2781 fputs_filtered ((const char *) obstack_base (&output), stream);
2782
2783 do_cleanups (cleanup);
2784 }
2785
2786 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2787 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2788 stops at the first null byte, otherwise printing proceeds (including null
2789 bytes) until either print_max or LEN characters have been printed,
2790 whichever is smaller. ENCODING is the name of the string's
2791 encoding. It can be NULL, in which case the target encoding is
2792 assumed. */
2793
2794 int
2795 val_print_string (struct type *elttype, const char *encoding,
2796 CORE_ADDR addr, int len,
2797 struct ui_file *stream,
2798 const struct value_print_options *options)
2799 {
2800 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
2801 int err; /* Non-zero if we got a bad read. */
2802 int found_nul; /* Non-zero if we found the nul char. */
2803 unsigned int fetchlimit; /* Maximum number of chars to print. */
2804 int bytes_read;
2805 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
2806 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2807 struct gdbarch *gdbarch = get_type_arch (elttype);
2808 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2809 int width = TYPE_LENGTH (elttype);
2810
2811 /* First we need to figure out the limit on the number of characters we are
2812 going to attempt to fetch and print. This is actually pretty simple. If
2813 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2814 LEN is -1, then the limit is print_max. This is true regardless of
2815 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2816 because finding the null byte (or available memory) is what actually
2817 limits the fetch. */
2818
2819 fetchlimit = (len == -1 ? options->print_max : std::min ((unsigned) len,
2820 options->print_max));
2821
2822 err = read_string (addr, len, width, fetchlimit, byte_order,
2823 &buffer, &bytes_read);
2824 old_chain = make_cleanup (xfree, buffer);
2825
2826 addr += bytes_read;
2827
2828 /* We now have either successfully filled the buffer to fetchlimit,
2829 or terminated early due to an error or finding a null char when
2830 LEN is -1. */
2831
2832 /* Determine found_nul by looking at the last character read. */
2833 found_nul = 0;
2834 if (bytes_read >= width)
2835 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
2836 byte_order) == 0;
2837 if (len == -1 && !found_nul)
2838 {
2839 gdb_byte *peekbuf;
2840
2841 /* We didn't find a NUL terminator we were looking for. Attempt
2842 to peek at the next character. If not successful, or it is not
2843 a null byte, then force ellipsis to be printed. */
2844
2845 peekbuf = (gdb_byte *) alloca (width);
2846
2847 if (target_read_memory (addr, peekbuf, width) == 0
2848 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
2849 force_ellipsis = 1;
2850 }
2851 else if ((len >= 0 && err != 0) || (len > bytes_read / width))
2852 {
2853 /* Getting an error when we have a requested length, or fetching less
2854 than the number of characters actually requested, always make us
2855 print ellipsis. */
2856 force_ellipsis = 1;
2857 }
2858
2859 /* If we get an error before fetching anything, don't print a string.
2860 But if we fetch something and then get an error, print the string
2861 and then the error message. */
2862 if (err == 0 || bytes_read > 0)
2863 {
2864 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
2865 encoding, force_ellipsis, options);
2866 }
2867
2868 if (err != 0)
2869 {
2870 std::string str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr);
2871
2872 fprintf_filtered (stream, "<error: ");
2873 fputs_filtered (str.c_str (), stream);
2874 fprintf_filtered (stream, ">");
2875 }
2876
2877 gdb_flush (stream);
2878 do_cleanups (old_chain);
2879
2880 return (bytes_read / width);
2881 }
2882
2883
2884 /* The 'set input-radix' command writes to this auxiliary variable.
2885 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2886 it is left unchanged. */
2887
2888 static unsigned input_radix_1 = 10;
2889
2890 /* Validate an input or output radix setting, and make sure the user
2891 knows what they really did here. Radix setting is confusing, e.g.
2892 setting the input radix to "10" never changes it! */
2893
2894 static void
2895 set_input_radix (const char *args, int from_tty, struct cmd_list_element *c)
2896 {
2897 set_input_radix_1 (from_tty, input_radix_1);
2898 }
2899
2900 static void
2901 set_input_radix_1 (int from_tty, unsigned radix)
2902 {
2903 /* We don't currently disallow any input radix except 0 or 1, which don't
2904 make any mathematical sense. In theory, we can deal with any input
2905 radix greater than 1, even if we don't have unique digits for every
2906 value from 0 to radix-1, but in practice we lose on large radix values.
2907 We should either fix the lossage or restrict the radix range more.
2908 (FIXME). */
2909
2910 if (radix < 2)
2911 {
2912 input_radix_1 = input_radix;
2913 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2914 radix);
2915 }
2916 input_radix_1 = input_radix = radix;
2917 if (from_tty)
2918 {
2919 printf_filtered (_("Input radix now set to "
2920 "decimal %u, hex %x, octal %o.\n"),
2921 radix, radix, radix);
2922 }
2923 }
2924
2925 /* The 'set output-radix' command writes to this auxiliary variable.
2926 If the requested radix is valid, OUTPUT_RADIX is updated,
2927 otherwise, it is left unchanged. */
2928
2929 static unsigned output_radix_1 = 10;
2930
2931 static void
2932 set_output_radix (const char *args, int from_tty, struct cmd_list_element *c)
2933 {
2934 set_output_radix_1 (from_tty, output_radix_1);
2935 }
2936
2937 static void
2938 set_output_radix_1 (int from_tty, unsigned radix)
2939 {
2940 /* Validate the radix and disallow ones that we aren't prepared to
2941 handle correctly, leaving the radix unchanged. */
2942 switch (radix)
2943 {
2944 case 16:
2945 user_print_options.output_format = 'x'; /* hex */
2946 break;
2947 case 10:
2948 user_print_options.output_format = 0; /* decimal */
2949 break;
2950 case 8:
2951 user_print_options.output_format = 'o'; /* octal */
2952 break;
2953 default:
2954 output_radix_1 = output_radix;
2955 error (_("Unsupported output radix ``decimal %u''; "
2956 "output radix unchanged."),
2957 radix);
2958 }
2959 output_radix_1 = output_radix = radix;
2960 if (from_tty)
2961 {
2962 printf_filtered (_("Output radix now set to "
2963 "decimal %u, hex %x, octal %o.\n"),
2964 radix, radix, radix);
2965 }
2966 }
2967
2968 /* Set both the input and output radix at once. Try to set the output radix
2969 first, since it has the most restrictive range. An radix that is valid as
2970 an output radix is also valid as an input radix.
2971
2972 It may be useful to have an unusual input radix. If the user wishes to
2973 set an input radix that is not valid as an output radix, he needs to use
2974 the 'set input-radix' command. */
2975
2976 static void
2977 set_radix (const char *arg, int from_tty)
2978 {
2979 unsigned radix;
2980
2981 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
2982 set_output_radix_1 (0, radix);
2983 set_input_radix_1 (0, radix);
2984 if (from_tty)
2985 {
2986 printf_filtered (_("Input and output radices now set to "
2987 "decimal %u, hex %x, octal %o.\n"),
2988 radix, radix, radix);
2989 }
2990 }
2991
2992 /* Show both the input and output radices. */
2993
2994 static void
2995 show_radix (const char *arg, int from_tty)
2996 {
2997 if (from_tty)
2998 {
2999 if (input_radix == output_radix)
3000 {
3001 printf_filtered (_("Input and output radices set to "
3002 "decimal %u, hex %x, octal %o.\n"),
3003 input_radix, input_radix, input_radix);
3004 }
3005 else
3006 {
3007 printf_filtered (_("Input radix set to decimal "
3008 "%u, hex %x, octal %o.\n"),
3009 input_radix, input_radix, input_radix);
3010 printf_filtered (_("Output radix set to decimal "
3011 "%u, hex %x, octal %o.\n"),
3012 output_radix, output_radix, output_radix);
3013 }
3014 }
3015 }
3016
3017
3018 static void
3019 set_print (const char *arg, int from_tty)
3020 {
3021 printf_unfiltered (
3022 "\"set print\" must be followed by the name of a print subcommand.\n");
3023 help_list (setprintlist, "set print ", all_commands, gdb_stdout);
3024 }
3025
3026 static void
3027 show_print (const char *args, int from_tty)
3028 {
3029 cmd_show_list (showprintlist, from_tty, "");
3030 }
3031
3032 static void
3033 set_print_raw (const char *arg, int from_tty)
3034 {
3035 printf_unfiltered (
3036 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
3037 help_list (setprintrawlist, "set print raw ", all_commands, gdb_stdout);
3038 }
3039
3040 static void
3041 show_print_raw (const char *args, int from_tty)
3042 {
3043 cmd_show_list (showprintrawlist, from_tty, "");
3044 }
3045
3046
3047 void
3048 _initialize_valprint (void)
3049 {
3050 add_prefix_cmd ("print", no_class, set_print,
3051 _("Generic command for setting how things print."),
3052 &setprintlist, "set print ", 0, &setlist);
3053 add_alias_cmd ("p", "print", no_class, 1, &setlist);
3054 /* Prefer set print to set prompt. */
3055 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
3056
3057 add_prefix_cmd ("print", no_class, show_print,
3058 _("Generic command for showing print settings."),
3059 &showprintlist, "show print ", 0, &showlist);
3060 add_alias_cmd ("p", "print", no_class, 1, &showlist);
3061 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
3062
3063 add_prefix_cmd ("raw", no_class, set_print_raw,
3064 _("\
3065 Generic command for setting what things to print in \"raw\" mode."),
3066 &setprintrawlist, "set print raw ", 0, &setprintlist);
3067 add_prefix_cmd ("raw", no_class, show_print_raw,
3068 _("Generic command for showing \"print raw\" settings."),
3069 &showprintrawlist, "show print raw ", 0, &showprintlist);
3070
3071 add_setshow_uinteger_cmd ("elements", no_class,
3072 &user_print_options.print_max, _("\
3073 Set limit on string chars or array elements to print."), _("\
3074 Show limit on string chars or array elements to print."), _("\
3075 \"set print elements unlimited\" causes there to be no limit."),
3076 NULL,
3077 show_print_max,
3078 &setprintlist, &showprintlist);
3079
3080 add_setshow_boolean_cmd ("null-stop", no_class,
3081 &user_print_options.stop_print_at_null, _("\
3082 Set printing of char arrays to stop at first null char."), _("\
3083 Show printing of char arrays to stop at first null char."), NULL,
3084 NULL,
3085 show_stop_print_at_null,
3086 &setprintlist, &showprintlist);
3087
3088 add_setshow_uinteger_cmd ("repeats", no_class,
3089 &user_print_options.repeat_count_threshold, _("\
3090 Set threshold for repeated print elements."), _("\
3091 Show threshold for repeated print elements."), _("\
3092 \"set print repeats unlimited\" causes all elements to be individually printed."),
3093 NULL,
3094 show_repeat_count_threshold,
3095 &setprintlist, &showprintlist);
3096
3097 add_setshow_boolean_cmd ("pretty", class_support,
3098 &user_print_options.prettyformat_structs, _("\
3099 Set pretty formatting of structures."), _("\
3100 Show pretty formatting of structures."), NULL,
3101 NULL,
3102 show_prettyformat_structs,
3103 &setprintlist, &showprintlist);
3104
3105 add_setshow_boolean_cmd ("union", class_support,
3106 &user_print_options.unionprint, _("\
3107 Set printing of unions interior to structures."), _("\
3108 Show printing of unions interior to structures."), NULL,
3109 NULL,
3110 show_unionprint,
3111 &setprintlist, &showprintlist);
3112
3113 add_setshow_boolean_cmd ("array", class_support,
3114 &user_print_options.prettyformat_arrays, _("\
3115 Set pretty formatting of arrays."), _("\
3116 Show pretty formatting of arrays."), NULL,
3117 NULL,
3118 show_prettyformat_arrays,
3119 &setprintlist, &showprintlist);
3120
3121 add_setshow_boolean_cmd ("address", class_support,
3122 &user_print_options.addressprint, _("\
3123 Set printing of addresses."), _("\
3124 Show printing of addresses."), NULL,
3125 NULL,
3126 show_addressprint,
3127 &setprintlist, &showprintlist);
3128
3129 add_setshow_boolean_cmd ("symbol", class_support,
3130 &user_print_options.symbol_print, _("\
3131 Set printing of symbol names when printing pointers."), _("\
3132 Show printing of symbol names when printing pointers."),
3133 NULL, NULL,
3134 show_symbol_print,
3135 &setprintlist, &showprintlist);
3136
3137 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
3138 _("\
3139 Set default input radix for entering numbers."), _("\
3140 Show default input radix for entering numbers."), NULL,
3141 set_input_radix,
3142 show_input_radix,
3143 &setlist, &showlist);
3144
3145 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
3146 _("\
3147 Set default output radix for printing of values."), _("\
3148 Show default output radix for printing of values."), NULL,
3149 set_output_radix,
3150 show_output_radix,
3151 &setlist, &showlist);
3152
3153 /* The "set radix" and "show radix" commands are special in that
3154 they are like normal set and show commands but allow two normally
3155 independent variables to be either set or shown with a single
3156 command. So the usual deprecated_add_set_cmd() and [deleted]
3157 add_show_from_set() commands aren't really appropriate. */
3158 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3159 longer true - show can display anything. */
3160 add_cmd ("radix", class_support, set_radix, _("\
3161 Set default input and output number radices.\n\
3162 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
3163 Without an argument, sets both radices back to the default value of 10."),
3164 &setlist);
3165 add_cmd ("radix", class_support, show_radix, _("\
3166 Show the default input and output number radices.\n\
3167 Use 'show input-radix' or 'show output-radix' to independently show each."),
3168 &showlist);
3169
3170 add_setshow_boolean_cmd ("array-indexes", class_support,
3171 &user_print_options.print_array_indexes, _("\
3172 Set printing of array indexes."), _("\
3173 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
3174 &setprintlist, &showprintlist);
3175 }
gdb_btowc
#define gdb_btowc
Definition: gdb_wchar.h:107
val_print_not_allocated
void val_print_not_allocated(struct ui_file *stream)
Definition: typeprint.c:832
err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1822
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
gdb_iswdigit
#define gdb_iswdigit
Definition: gdb_wchar.h:106
show_prettyformat_structs
static void show_prettyformat_structs(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:214
TYPE_ERROR_NAME
#define TYPE_ERROR_NAME(type)
Definition: gdbtypes.h:1489
show_unionprint
static void show_unionprint(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:233
gdb_wint_t
int gdb_wint_t
Definition: gdb_wchar.h:102
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
generic_val_print_flags
static void generic_val_print_flags(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:680
obstack_grow_wstr
#define obstack_grow_wstr(OBSTACK, WSTRING)
Definition: gdb_obstack.h:51
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
demangle
int demangle
Definition: demangle.c:47
set_output_radix
static void set_output_radix(const char *args, int from_tty, struct cmd_list_element *c)
Definition: valprint.c:2932
value_print_options::repeat_count_threshold
unsigned int repeat_count_threshold
Definition: valprint.h:57
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
wchar_iterate_ok
Definition: charset.h:77
gdb_obstack.h
converted_character
Definition: valprint.c:52
target_float_to_string
std::string target_float_to_string(const gdb_byte *addr, const struct type *type, const char *format)
Definition: target-float.c:2334
value_addr
struct value * value_addr(struct value *arg1)
Definition: valops.c:1462
Val_prettyformat
Definition: defs.h:443
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
show_print_max
static void show_print_max(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:145
value_print
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1163
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
converted_character::result
enum wchar_iterate_result result
Definition: valprint.c:58
show_repeat_count_threshold
static void show_repeat_count_threshold(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:192
set_input_radix
static void set_input_radix(const char *args, int from_tty, struct cmd_list_element *c)
Definition: valprint.c:2895
xfree
void xfree(void *)
input_radix
unsigned input_radix
Definition: valprint.c:157
no_class
Definition: command.h:41
type_not_allocated
int type_not_allocated(const struct type *type)
Definition: gdbtypes.c:3714
value_entirely_optimized_out
int value_entirely_optimized_out(struct value *value)
Definition: value.c:419
class_support
Definition: command.h:42
value::embedded_offset
LONGEST embedded_offset
Definition: value.c:309
int_string
char * int_string(LONGEST val, int radix, int is_signed, int width, int use_c_format)
Definition: print-utils.c:253
CARRY_LEFT
#define CARRY_LEFT(x)
unpack_pointer
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2934
get_value_addr_contents
static const gdb_byte * get_value_addr_contents(struct value *deref_val)
Definition: valprint.c:511
cmd_list_element
Definition: cli-decode.h:46
generic_val_print_float
static void generic_val_print_float(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:816
warning
void warning(const char *fmt,...)
Definition: errors.c:26
fputc_filtered
int fputc_filtered(int c, struct ui_file *stream)
Definition: utils.c:1844
generic_val_print_decorations::array_end
const char * array_end
Definition: valprint.h:189
value_embedded_offset
LONGEST value_embedded_offset(const struct value *value)
Definition: value.c:1477
set_output_radix_1
static void set_output_radix_1(int, unsigned)
Definition: valprint.c:2938
ada-lang.h
value_at
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:933
lval_register
Definition: defs.h:385
get_formatted_print_options
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:137
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
WCHAR_BUFLEN_MAX
#define WCHAR_BUFLEN_MAX
Definition: valprint.c:48
TYPE_CODE_FLAGS
Definition: gdbtypes.h:109
val_print_unavailable
void val_print_unavailable(struct ui_file *stream)
Definition: valprint.c:368
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
print_decimal_chars
void print_decimal_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, bool is_signed, enum bfd_endian byte_order)
Definition: valprint.c:1648
charset.h
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
TYPE_CODE_INT
Definition: gdbtypes.h:111
show_stop_print_at_null
static void show_stop_print_at_null(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:202
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
TYPE_CODE_SET
Definition: gdbtypes.h:126
print_floating
void print_floating(const gdb_byte *valaddr, struct type *type, struct ui_file *stream)
Definition: valprint.c:1361
type_length_units
unsigned int type_length_units(struct type *type)
Definition: gdbtypes.c:260
show_radix
static void show_radix(const char *arg, int from_tty)
Definition: valprint.c:2995
output_radix_1
static unsigned output_radix_1
Definition: valprint.c:2929
value_lazy
int value_lazy(const struct value *value)
Definition: value.c:1383
value_print_options::print_array_indexes
int print_array_indexes
Definition: valprint.h:71
generic_val_print_complex
static void generic_val_print_complex(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:840
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
TYPE_CODE_DECFLOAT
Definition: gdbtypes.h:173
generic_val_print_enum_1
static void generic_val_print_enum_1(struct type *type, LONGEST val, struct ui_file *stream)
Definition: valprint.c:594
WCHAR_BUFLEN
#define WCHAR_BUFLEN(X)
Definition: valprint.c:45
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
show_output_radix
static void show_output_radix(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:169
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
get_no_prettyformat_print_options
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:128
VEC
#define VEC(T)
Definition: vec.h:414
cleanup
Definition: cleanups.c:38
val_print_invalid_address
void val_print_invalid_address(struct ui_file *stream)
Definition: valprint.c:374
_
#define _(String)
Definition: gdb_locale.h:35
value_contents_for_printing
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1250
ui_file
Definition: ui-file.h:26
value_bytes_available
int value_bytes_available(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:357
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
wchar_iterate_result
wchar_iterate_result
Definition: charset.h:74
value_bits_any_optimized_out
int value_bits_any_optimized_out(const struct value *value, int bit_offset, int bit_length)
Definition: value.c:366
user_print_options
struct value_print_options user_print_options
Definition: valprint.c:95
show_prettyformat_arrays
static void show_prettyformat_arrays(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:223
TYPE_FIELD_ENUMVAL
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1375
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
value_print_options::prettyformat
enum val_prettyformat prettyformat
Definition: valprint.h:28
emit_octal_digit
static void emit_octal_digit(struct ui_file *stream, bool *seen_a_one, int digit)
Definition: valprint.c:1436
wchar_iterator
Definition: charset.h:87
generic_val_print_decorations::false_name
const char * false_name
Definition: valprint.h:181
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
wchar_printable
static int wchar_printable(gdb_wchar_t w)
Definition: valprint.c:2241
maybe_negate_by_bytes
static bool maybe_negate_by_bytes(const gdb_byte *bytes, unsigned len, enum bfd_endian byte_order, gdb::byte_vector *out_vec)
Definition: valprint.c:1605
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
set_radix
static void set_radix(const char *arg, int from_tty)
Definition: valprint.c:2977
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
language_defn
Definition: language.h:132
value_lval_const
enum lval_type value_lval_const(const struct value *value)
Definition: value.c:1523
generic_val_print_memberptr
static void generic_val_print_memberptr(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:479
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
CARRY_ONE
#define CARRY_ONE
gdbarch_addressable_memory_unit_size
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:5030
generic_val_print_ref
static void generic_val_print_ref(struct type *type, int embedded_offset, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:527
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
count_next_character
static int count_next_character(wchar_iterator *iter, VEC(converted_character_d) **vec)
Definition: valprint.c:2440
TYPE_CODE_STRING
Definition: gdbtypes.h:133
TRY
#define TRY
Definition: common-exceptions.h:246
DEF_VEC_O
DEF_VEC_O(converted_character_d)
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
target-float.h
partial_memory_read
static int partial_memory_read(CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errptr)
Definition: valprint.c:2069
val_print_optimized_out
void val_print_optimized_out(const struct value *val, struct ui_file *stream)
Definition: valprint.c:353
val_print_scalar_formatted
void val_print_scalar_formatted(struct type *type, LONGEST embedded_offset, struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition: valprint.c:1240
discrete_position
int discrete_position(struct type *type, LONGEST val, LONGEST *pos)
Definition: gdbtypes.c:1100
lval_memory
Definition: defs.h:383
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
add_setshow_uinteger_cmd
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:723
value_contents_eq
bool value_contents_eq(const struct value *val1, LONGEST offset1, const struct value *val2, LONGEST offset2, LONGEST length)
Definition: value.c:874
PRINT_MAX_DEFAULT
#define PRINT_MAX_DEFAULT
Definition: valprint.c:93
LA_EMIT_CHAR
#define LA_EMIT_CHAR(ch, type, stream, quoter)
Definition: language.h:532
print_char_chars
void print_char_chars(struct ui_file *stream, struct type *type, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1848
val_print_not_associated
void val_print_not_associated(struct ui_file *stream)
Definition: typeprint.c:840
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
generic_val_print_ptr
static void generic_val_print_ptr(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:450
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
convert_between_encodings
void convert_between_encodings(const char *from, const char *to, const gdb_byte *bytes, unsigned int num_bytes, int width, struct obstack *output, enum transliterations translit)
Definition: charset.c:512
generic_printstr
void generic_printstr(struct ui_file *stream, struct type *type, const gdb_byte *string, unsigned int length, const char *encoding, int force_ellipses, int quote_char, int c_style_terminator, const struct value_print_options *options)
Definition: valprint.c:2683
MID_TWO
#define MID_TWO
value_print_options
Definition: valprint.h:25
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
value_print_options::stop_print_at_null
int stop_print_at_null
Definition: valprint.h:67
BITS_IN_OCTAL
#define BITS_IN_OCTAL
current_target
struct target_ops current_target
memory_error_message
std::string memory_error_message(enum target_xfer_status err, struct gdbarch *gdbarch, CORE_ADDR memaddr)
Definition: corefile.c:181
generic_val_print_array
static void generic_val_print_array(struct type *type, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:409
UINT_MAX
#define UINT_MAX
Definition: defs.h:473
longest_to_int
int longest_to_int(LONGEST arg)
Definition: valprint.c:1341
language_ada
Definition: defs.h:219
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
generic_val_print_enum
static void generic_val_print_enum(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:653
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
print_hex_chars
void print_hex_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order, bool zero_pad)
Definition: valprint.c:1784
output_radix
unsigned output_radix
Definition: valprint.c:167
show_print_raw
static void show_print_raw(const char *args, int from_tty)
Definition: valprint.c:3041
print_wchar
static void print_wchar(gdb_wint_t w, const gdb_byte *orig, int orig_len, int width, enum bfd_endian byte_order, struct obstack *output, int quoter, int *need_escapep)
Definition: valprint.c:2274
gdbarch_convert_from_func_ptr_addr
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: gdbarch.c:3191
show_print_array_indexes
static void show_print_array_indexes(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:181
print_unpacked_pointer
static void print_unpacked_pointer(struct type *type, struct type *elttype, CORE_ADDR address, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:387
annotate_elt_rep
void annotate_elt_rep(unsigned int repcount)
Definition: annotate.c:545
gdb_iswprint
#define gdb_iswprint
Definition: gdb_wchar.h:105
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
CARRY_OUT
#define CARRY_OUT( x)
TYPE_CODE_FLT
Definition: gdbtypes.h:116
generic_val_print_int
static void generic_val_print_int(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:764
value_print_options::prettyformat_structs
int prettyformat_structs
Definition: valprint.h:34
free_current_contents
void free_current_contents(void *ptr)
Definition: utils.c:199
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
converted_character::buf
const gdb_byte * buf
Definition: valprint.c:64
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
TYPE_CODE_UNION
Definition: gdbtypes.h:107
HIGH_ZERO
#define HIGH_ZERO
wchar_iterate_eof
Definition: charset.h:83
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
print_binary_chars
void print_binary_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order, bool zero_pad)
Definition: valprint.c:1369
type
Definition: gdbtypes.h:749
Val_no_prettyformat
Definition: defs.h:442
LCST
#define LCST(X)
Definition: gdb_wchar.h:110
language.h
annotate_array_section_begin
void annotate_array_section_begin(int idx, struct type *elttype)
Definition: annotate.c:534
byte-vector.h
gdb_WEOF
#define gdb_WEOF
Definition: gdb_wchar.h:108
VEC_index
#define VEC_index(T, V, I)
Definition: vec.h:167
coerce_ref_if_computed
struct value * coerce_ref_if_computed(const struct value *arg)
Definition: value.c:3719
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
value_print_options::summary
int summary
Definition: valprint.h:90
type_not_associated
int type_not_associated(const struct type *type)
Definition: gdbtypes.c:3726
n_spaces
char * n_spaces(int n)
Definition: utils.c:2099
_initialize_valprint
void _initialize_valprint(void)
Definition: valprint.c:3048
type
static const char * type
Definition: language.c:113
field
Definition: gdbtypes.h:517
value_from_longest
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3534
dummy
unsigned dummy
Definition: go32-nat.c:1073
show_input_radix
static void show_input_radix(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:159
value_contents_for_printing_const
const gdb_byte * value_contents_for_printing_const(const struct value *value)
Definition: value.c:1258
wchar_iterator::iterate
int iterate(enum wchar_iterate_result *out_result, gdb_wchar_t **out_chars, const gdb_byte **ptr, size_t *len)
Definition: charset.c:623
HIGH_ONE
#define HIGH_ONE
HIGH_TWO
#define HIGH_TWO
setprintlist
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:149
value_print_options::format
int format
Definition: valprint.h:64
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
show_addressprint
static void show_addressprint(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:244
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
TYPE_CODE_METHODPTR
Definition: gdbtypes.h:147
show_print
static void show_print(const char *args, int from_tty)
Definition: valprint.c:3027
xmalloc
void * xmalloc(YYSIZE_T)
print_octal_chars
void print_octal_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1448
valprint_check_validity
int valprint_check_validity(struct ui_file *stream, struct type *type, LONGEST embedded_offset, const struct value *val)
Definition: valprint.c:290
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
wchar_iterate_invalid
Definition: charset.h:79
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
val_print_scalar_type_p
int val_print_scalar_type_p(struct type *type)
Definition: valprint.c:266
builtin_type::builtin_bool
struct type * builtin_bool
Definition: gdbtypes.h:1516
annotate_elt_rep_end
void annotate_elt_rep_end(void)
Definition: annotate.c:552
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
unpack_long
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2880
TYPE_CODE_REF
Definition: gdbtypes.h:156
cmd_show_list
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:657
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
extension.h
TYPE_UNSIGNED
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:205
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
VEC_last
#define VEC_last(T, V)
Definition: vec.h:158
generic_val_print_decorations
Definition: valprint.h:169
annotate_array_section_end
void annotate_array_section_end(void)
Definition: annotate.c:566
converted_character::chars
gdb_wchar_t chars[WCHAR_BUFLEN_MAX]
Definition: valprint.c:61
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
value
Definition: value.c:169
wrap_here
void wrap_here(const char *indent)
Definition: utils.c:1596
generic_val_print_func
static void generic_val_print_func(struct type *type, int embedded_offset, CORE_ADDR address, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:700
value_bits_synthetic_pointer
int value_bits_synthetic_pointer(const struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:1465
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
TYPE_CODE_PTR
Definition: gdbtypes.h:84
generic_val_print_decorations::array_start
const char * array_start
Definition: valprint.h:188
set_print
static void set_print(const char *arg, int from_tty)
Definition: valprint.c:3019
read_string
int read_string(CORE_ADDR addr, int len, int width, unsigned int fetchlimit, enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
Definition: valprint.c:2127
generic_val_print_decorations::true_name
const char * true_name
Definition: valprint.h:180
print_spaces_filtered
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2121
value_print_options::unionprint
int unionprint
Definition: valprint.h:40
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
translit_char
Definition: charset.h:48
input_radix_1
static unsigned input_radix_1
Definition: valprint.c:2888
help_list
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1071
discard_cleanups
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:212
LOW_ONE
#define LOW_ONE
current_language
const struct language_defn * current_language
Definition: language.c:81
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
print_longest
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1303
value_fetch_lazy
void value_fetch_lazy(struct value *val)
Definition: value.c:3860
value_internal_function_name
char * value_internal_function_name(struct value *val)
Definition: value.c:2520
gdb_wchar_t
char gdb_wchar_t
Definition: gdb_wchar.h:101
SHIFT
#define SHIFT(x)
generic_val_print_decorations::void_name
const char * void_name
Definition: valprint.h:185
gdbcore.h
generic_val_print
void generic_val_print(struct type *type, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:884
value_print_options::prettyformat_arrays
int prettyformat_arrays
Definition: valprint.h:31
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
value_print_options::symbol_print
int symbol_print
Definition: valprint.h:94
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
TYPE_INDEX_TYPE
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1242
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
CARRY_ZERO
#define CARRY_ZERO
LOW_ZERO
#define LOW_ZERO
HIGH_NIBBLE
#define HIGH_NIBBLE(x)
Val_prettyformat_default
Definition: defs.h:445
generic_val_print_decorations::complex_prefix
const char * complex_prefix
Definition: valprint.h:174
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
val_print_type_code_flags
static void val_print_type_code_flags(struct type *type, const gdb_byte *valaddr, struct ui_file *stream)
Definition: valprint.c:1186
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
generic_emit_char
void generic_emit_char(int c, struct type *type, struct ui_file *stream, int quoter, const char *encoding)
Definition: valprint.c:2364
buffer
Definition: buffer.h:23
print_address_demangle
int print_address_demangle(const struct value_print_options *opts, struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream, int do_demangle)
Definition: printcmd.c:736
print_ref_address
static void print_ref_address(struct type *type, const gdb_byte *address_buffer, int embedded_offset, struct ui_file *stream)
Definition: valprint.c:491
TYPE_CODE_MEMBERPTR
Definition: gdbtypes.h:154
target.h
TYPE_CODE_INTERNAL_FUNCTION
Definition: gdbtypes.h:178
converted_character::repeat_count
int repeat_count
Definition: valprint.c:70
value.h
showprintlist
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:151
annotate_elt
void annotate_elt(void)
Definition: annotate.c:559
TYPE_STUB
#define TYPE_STUB(t)
Definition: gdbtypes.h:217
INTERMEDIATE_ENCODING
#define INTERMEDIATE_ENCODING
Definition: gdb_wchar.h:117
gdb::byte_vector
gdb::def_vector< gdb_byte > byte_vector
Definition: byte-vector.h:58
TYPE_FLAG_ENUM
#define TYPE_FLAG_ENUM(t)
Definition: gdbtypes.h:305
val_print
void val_print(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1015
LOW_NIBBLE
#define LOW_NIBBLE( x)
gdbtypes.h
typeprint.h
print_scalar_formatted
void print_scalar_formatted(const gdb_byte *, struct type *, const struct value_print_options *, int, struct ui_file *)
Definition: printcmd.c:351
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
generic_val_print_decorations::complex_infix
const char * complex_infix
Definition: valprint.h:175
MAX_WCHARS
#define MAX_WCHARS
Definition: valprint.c:41
language
language
Definition: defs.h:203
generic_val_print_bool
static void generic_val_print_bool(struct type *type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options, const struct generic_val_print_decorations *decorations)
Definition: valprint.c:729
LA_PRINT_ARRAY_INDEX
#define LA_PRINT_ARRAY_INDEX(index_value, stream, options)
Definition: language.h:537
VEC_cleanup
#define VEC_cleanup(T)
Definition: vec.h:203
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
value_print_options::print_max
unsigned int print_max
Definition: valprint.h:53
MID_ONE
#define MID_ONE
all_commands
Definition: command.h:39
generic_val_print_char
static void generic_val_print_char(struct type *type, struct type *unresolved_type, int embedded_offset, struct ui_file *stream, struct value *original_value, const struct value_print_options *options)
Definition: valprint.c:780
value_print_options::raw
int raw
Definition: valprint.h:85
value_check_printable
static int value_check_printable(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1080
LA_VALUE_PRINT
#define LA_VALUE_PRINT(val, stream, options)
Definition: language.h:524
LA_PRINT_STRING
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses, options)
Definition: language.h:529
value_print_options::output_format
int output_format
Definition: valprint.h:60
host_charset
const char * host_charset(void)
Definition: charset.c:417
ada_to_fixed_value
struct value * ada_to_fixed_value(struct value *val)
Definition: ada-lang.c:9368
converted_character::num_chars
int num_chars
Definition: valprint.c:55
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
wchar_iterate_incomplete
Definition: charset.h:81
print_converted_chars_to_obstack
static void print_converted_chars_to_obstack(struct obstack *obstack, VEC(converted_character_d) *chars, int quote_char, int width, enum bfd_endian byte_order, const struct value_print_options *options)
Definition: valprint.c:2525
HOST_CHAR_BIT
#define HOST_CHAR_BIT
Definition: host-defs.h:40
val_print_string
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2795
value::address
CORE_ADDR address
Definition: value.c:208
LA_PRINT_CHAR
#define LA_PRINT_CHAR(ch, type, stream)
Definition: language.h:527
set_input_radix_1
static void set_input_radix_1(int, unsigned)
Definition: valprint.c:2901
print_function_pointer_address
void print_function_pointer_address(const struct value_print_options *options, struct gdbarch *gdbarch, CORE_ADDR address, struct ui_file *stream)
Definition: valprint.c:1884
annotate.h
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
set_print_raw
static void set_print_raw(const char *arg, int from_tty)
Definition: valprint.c:3033
auto_obstack
Definition: gdb_obstack.h:67
QUIT
#define QUIT
Definition: defs.h:179
val_print_array_elements
void val_print_array_elements(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, unsigned int i)
Definition: valprint.c:1932
valprint.h
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
generic_val_print_decorations::complex_suffix
const char * complex_suffix
Definition: valprint.h:176
LOW_TWO
#define LOW_TWO
pack_long
void pack_long(gdb_byte *buf, struct type *type, LONGEST num)
Definition: value.c:3450
get_array_bounds
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:1056
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
append_string_as_wide
static void append_string_as_wide(const char *string, struct obstack *output)
Definition: valprint.c:2254
setprintrawlist
struct cmd_list_element * setprintrawlist
Definition: valprint.c:77
gdbcmd.h
value_entirely_unavailable
int value_entirely_unavailable(struct value *value)
Definition: value.c:413
error
void error(const char *fmt,...)
Definition: errors.c:38
maybe_print_array_index
void maybe_print_array_index(struct type *index_type, LONGEST index, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:1909
size
size_t size
Definition: go32-nat.c:242
showprintrawlist
struct cmd_list_element * showprintrawlist
Definition: valprint.c:78
show_symbol_print
static void show_symbol_print(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valprint.c:251
TARGET_XFER_E_IO
Definition: target.h:220
val_print_not_saved
void val_print_not_saved(struct ui_file *stream)
Definition: valprint.c:362
LONGEST
long long LONGEST
Definition: common-types.h:52
converted_character::buflen
size_t buflen
Definition: valprint.c:67
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
apply_ext_lang_val_pretty_printer
int apply_ext_lang_val_pretty_printer(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: extension.c:499
TYPE_CODE_COMPLEX
Definition: gdbtypes.h:167
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
parse_and_eval_long
LONGEST parse_and_eval_long(const char *exp)
Definition: eval.c:111