1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
30 #include "target-float.h"
31 #include "extension.h"
33 #include "gdb_obstack.h"
35 #include "typeprint.h"
38 #include "gdbsupport/byte-vector.h"
39 #include "cli/cli-option.h"
41 #include "cli/cli-style.h"
42 #include "count-one-bits.h"
46 /* Maximum number of wchars returned from wchar_iterate. */
49 /* A convenience macro to compute the size of a wchar_t buffer containing X
51 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
53 /* Character buffer size saved while iterating over wchars. */
54 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
56 /* A structure to encapsulate state information from iterated
57 character conversions. */
58 struct converted_character
60 /* The number of characters converted. */
63 /* The result of the conversion. See charset.h for more. */
64 enum wchar_iterate_result result
;
66 /* The (saved) converted character(s). */
67 gdb_wchar_t chars
[WCHAR_BUFLEN_MAX
];
69 /* The first converted target byte. */
72 /* The number of bytes converted. */
75 /* How many times this character(s) is repeated. */
79 /* Command lists for set/show print raw. */
80 struct cmd_list_element
*setprintrawlist
;
81 struct cmd_list_element
*showprintrawlist
;
83 /* Prototypes for local functions */
85 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
86 int len
, int *errptr
);
88 static void set_input_radix_1 (int, unsigned);
90 static void set_output_radix_1 (int, unsigned);
92 static void val_print_type_code_flags (struct type
*type
,
93 struct value
*original_value
,
95 struct ui_file
*stream
);
97 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
98 #define PRINT_MAX_DEPTH_DEFAULT 20 /* Start print_max_depth off at this value. */
100 struct value_print_options user_print_options
=
102 Val_prettyformat_default
, /* prettyformat */
103 0, /* prettyformat_arrays */
104 0, /* prettyformat_structs */
107 1, /* addressprint */
109 PRINT_MAX_DEFAULT
, /* print_max */
110 10, /* repeat_count_threshold */
111 0, /* output_format */
113 0, /* stop_print_at_null */
114 0, /* print_array_indexes */
116 1, /* static_field_print */
117 1, /* pascal_static_field_print */
120 1, /* symbol_print */
121 PRINT_MAX_DEPTH_DEFAULT
, /* max_depth */
125 /* Initialize *OPTS to be a copy of the user print options. */
127 get_user_print_options (struct value_print_options
*opts
)
129 *opts
= user_print_options
;
132 /* Initialize *OPTS to be a copy of the user print options, but with
133 pretty-formatting disabled. */
135 get_no_prettyformat_print_options (struct value_print_options
*opts
)
137 *opts
= user_print_options
;
138 opts
->prettyformat
= Val_no_prettyformat
;
141 /* Initialize *OPTS to be a copy of the user print options, but using
142 FORMAT as the formatting option. */
144 get_formatted_print_options (struct value_print_options
*opts
,
147 *opts
= user_print_options
;
148 opts
->format
= format
;
152 show_print_max (struct ui_file
*file
, int from_tty
,
153 struct cmd_list_element
*c
, const char *value
)
155 fprintf_filtered (file
,
156 _("Limit on string chars or array "
157 "elements to print is %s.\n"),
162 /* Default input and output radixes, and output format letter. */
164 unsigned input_radix
= 10;
166 show_input_radix (struct ui_file
*file
, int from_tty
,
167 struct cmd_list_element
*c
, const char *value
)
169 fprintf_filtered (file
,
170 _("Default input radix for entering numbers is %s.\n"),
174 unsigned output_radix
= 10;
176 show_output_radix (struct ui_file
*file
, int from_tty
,
177 struct cmd_list_element
*c
, const char *value
)
179 fprintf_filtered (file
,
180 _("Default output radix for printing of values is %s.\n"),
184 /* By default we print arrays without printing the index of each element in
185 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
188 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
189 struct cmd_list_element
*c
, const char *value
)
191 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
194 /* Print repeat counts if there are more than this many repetitions of an
195 element in an array. Referenced by the low level language dependent
199 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
200 struct cmd_list_element
*c
, const char *value
)
202 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
206 /* If nonzero, stops printing of char arrays at first null. */
209 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
210 struct cmd_list_element
*c
, const char *value
)
212 fprintf_filtered (file
,
213 _("Printing of char arrays to stop "
214 "at first null char is %s.\n"),
218 /* Controls pretty printing of structures. */
221 show_prettyformat_structs (struct ui_file
*file
, int from_tty
,
222 struct cmd_list_element
*c
, const char *value
)
224 fprintf_filtered (file
, _("Pretty formatting of structures is %s.\n"), value
);
227 /* Controls pretty printing of arrays. */
230 show_prettyformat_arrays (struct ui_file
*file
, int from_tty
,
231 struct cmd_list_element
*c
, const char *value
)
233 fprintf_filtered (file
, _("Pretty formatting of arrays is %s.\n"), value
);
236 /* If nonzero, causes unions inside structures or other unions to be
240 show_unionprint (struct ui_file
*file
, int from_tty
,
241 struct cmd_list_element
*c
, const char *value
)
243 fprintf_filtered (file
,
244 _("Printing of unions interior to structures is %s.\n"),
248 /* If nonzero, causes machine addresses to be printed in certain contexts. */
251 show_addressprint (struct ui_file
*file
, int from_tty
,
252 struct cmd_list_element
*c
, const char *value
)
254 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
258 show_symbol_print (struct ui_file
*file
, int from_tty
,
259 struct cmd_list_element
*c
, const char *value
)
261 fprintf_filtered (file
,
262 _("Printing of symbols when printing pointers is %s.\n"),
268 /* A helper function for val_print. When printing in "summary" mode,
269 we want to print scalar arguments, but not aggregate arguments.
270 This function distinguishes between the two. */
273 val_print_scalar_type_p (struct type
*type
)
275 type
= check_typedef (type
);
276 while (TYPE_IS_REFERENCE (type
))
278 type
= TYPE_TARGET_TYPE (type
);
279 type
= check_typedef (type
);
281 switch (type
->code ())
283 case TYPE_CODE_ARRAY
:
284 case TYPE_CODE_STRUCT
:
285 case TYPE_CODE_UNION
:
287 case TYPE_CODE_STRING
:
294 /* A helper function for val_print. When printing with limited depth we
295 want to print string and scalar arguments, but not aggregate arguments.
296 This function distinguishes between the two. */
299 val_print_scalar_or_string_type_p (struct type
*type
,
300 const struct language_defn
*language
)
302 return (val_print_scalar_type_p (type
)
303 || language
->is_string_type_p (type
));
306 /* See valprint.h. */
309 valprint_check_validity (struct ui_file
*stream
,
311 LONGEST embedded_offset
,
312 const struct value
*val
)
314 type
= check_typedef (type
);
316 if (type_not_associated (type
))
318 val_print_not_associated (stream
);
322 if (type_not_allocated (type
))
324 val_print_not_allocated (stream
);
328 if (type
->code () != TYPE_CODE_UNION
329 && type
->code () != TYPE_CODE_STRUCT
330 && type
->code () != TYPE_CODE_ARRAY
)
332 if (value_bits_any_optimized_out (val
,
333 TARGET_CHAR_BIT
* embedded_offset
,
334 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
336 val_print_optimized_out (val
, stream
);
340 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
341 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
343 const int is_ref
= type
->code () == TYPE_CODE_REF
;
344 int ref_is_addressable
= 0;
348 const struct value
*deref_val
= coerce_ref_if_computed (val
);
350 if (deref_val
!= NULL
)
351 ref_is_addressable
= value_lval_const (deref_val
) == lval_memory
;
354 if (!is_ref
|| !ref_is_addressable
)
355 fputs_styled (_("<synthetic pointer>"), metadata_style
.style (),
358 /* C++ references should be valid even if they're synthetic. */
362 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
364 val_print_unavailable (stream
);
373 val_print_optimized_out (const struct value
*val
, struct ui_file
*stream
)
375 if (val
!= NULL
&& value_lval_const (val
) == lval_register
)
376 val_print_not_saved (stream
);
378 fprintf_styled (stream
, metadata_style
.style (), _("<optimized out>"));
382 val_print_not_saved (struct ui_file
*stream
)
384 fprintf_styled (stream
, metadata_style
.style (), _("<not saved>"));
388 val_print_unavailable (struct ui_file
*stream
)
390 fprintf_styled (stream
, metadata_style
.style (), _("<unavailable>"));
394 val_print_invalid_address (struct ui_file
*stream
)
396 fprintf_styled (stream
, metadata_style
.style (), _("<invalid address>"));
399 /* Print a pointer based on the type of its target.
401 Arguments to this functions are roughly the same as those in
402 generic_val_print. A difference is that ADDRESS is the address to print,
403 with embedded_offset already added. ELTTYPE represents
404 the pointed type after check_typedef. */
407 print_unpacked_pointer (struct type
*type
, struct type
*elttype
,
408 CORE_ADDR address
, struct ui_file
*stream
,
409 const struct value_print_options
*options
)
411 struct gdbarch
*gdbarch
= get_type_arch (type
);
413 if (elttype
->code () == TYPE_CODE_FUNC
)
415 /* Try to print what function it points to. */
416 print_function_pointer_address (options
, gdbarch
, address
, stream
);
420 if (options
->symbol_print
)
421 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
422 else if (options
->addressprint
)
423 fputs_filtered (paddress (gdbarch
, address
), stream
);
426 /* generic_val_print helper for TYPE_CODE_ARRAY. */
429 generic_val_print_array (struct value
*val
,
430 struct ui_file
*stream
, int recurse
,
431 const struct value_print_options
*options
,
433 generic_val_print_decorations
*decorations
)
435 struct type
*type
= check_typedef (value_type (val
));
436 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
437 struct type
*elttype
= check_typedef (unresolved_elttype
);
439 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
441 LONGEST low_bound
, high_bound
;
443 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
444 error (_("Could not determine the array high bound"));
446 fputs_filtered (decorations
->array_start
, stream
);
447 value_print_array_elements (val
, stream
, recurse
, options
, 0);
448 fputs_filtered (decorations
->array_end
, stream
);
452 /* Array of unspecified length: treat like pointer to first elt. */
453 print_unpacked_pointer (type
, elttype
, value_address (val
),
459 /* generic_value_print helper for TYPE_CODE_PTR. */
462 generic_value_print_ptr (struct value
*val
, struct ui_file
*stream
,
463 const struct value_print_options
*options
)
466 if (options
->format
&& options
->format
!= 's')
467 value_print_scalar_formatted (val
, options
, 0, stream
);
470 struct type
*type
= check_typedef (value_type (val
));
471 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
472 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
473 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
475 print_unpacked_pointer (type
, elttype
, addr
, stream
, options
);
480 /* Print '@' followed by the address contained in ADDRESS_BUFFER. */
483 print_ref_address (struct type
*type
, const gdb_byte
*address_buffer
,
484 int embedded_offset
, struct ui_file
*stream
)
486 struct gdbarch
*gdbarch
= get_type_arch (type
);
488 if (address_buffer
!= NULL
)
491 = extract_typed_address (address_buffer
+ embedded_offset
, type
);
493 fprintf_filtered (stream
, "@");
494 fputs_filtered (paddress (gdbarch
, address
), stream
);
496 /* Else: we have a non-addressable value, such as a DW_AT_const_value. */
499 /* If VAL is addressable, return the value contents buffer of a value that
500 represents a pointer to VAL. Otherwise return NULL. */
502 static const gdb_byte
*
503 get_value_addr_contents (struct value
*deref_val
)
505 gdb_assert (deref_val
!= NULL
);
507 if (value_lval_const (deref_val
) == lval_memory
)
508 return value_contents_for_printing_const (value_addr (deref_val
));
511 /* We have a non-addressable value, such as a DW_AT_const_value. */
516 /* generic_val_print helper for TYPE_CODE_{RVALUE_,}REF. */
519 generic_val_print_ref (struct type
*type
,
520 int embedded_offset
, struct ui_file
*stream
, int recurse
,
521 struct value
*original_value
,
522 const struct value_print_options
*options
)
524 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
525 struct value
*deref_val
= NULL
;
526 const int value_is_synthetic
527 = value_bits_synthetic_pointer (original_value
,
528 TARGET_CHAR_BIT
* embedded_offset
,
529 TARGET_CHAR_BIT
* TYPE_LENGTH (type
));
530 const int must_coerce_ref
= ((options
->addressprint
&& value_is_synthetic
)
531 || options
->deref_ref
);
532 const int type_is_defined
= elttype
->code () != TYPE_CODE_UNDEF
;
533 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
535 if (must_coerce_ref
&& type_is_defined
)
537 deref_val
= coerce_ref_if_computed (original_value
);
539 if (deref_val
!= NULL
)
541 /* More complicated computed references are not supported. */
542 gdb_assert (embedded_offset
== 0);
545 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
546 unpack_pointer (type
, valaddr
+ embedded_offset
));
548 /* Else, original_value isn't a synthetic reference or we don't have to print
549 the reference's contents.
551 Notice that for references to TYPE_CODE_STRUCT, 'set print object on' will
552 cause original_value to be a not_lval instead of an lval_computed,
553 which will make value_bits_synthetic_pointer return false.
554 This happens because if options->objectprint is true, c_value_print will
555 overwrite original_value's contents with the result of coercing
556 the reference through value_addr, and then set its type back to
557 TYPE_CODE_REF. In that case we don't have to coerce the reference again;
558 we can simply treat it as non-synthetic and move on. */
560 if (options
->addressprint
)
562 const gdb_byte
*address
= (value_is_synthetic
&& type_is_defined
563 ? get_value_addr_contents (deref_val
)
566 print_ref_address (type
, address
, embedded_offset
, stream
);
568 if (options
->deref_ref
)
569 fputs_filtered (": ", stream
);
572 if (options
->deref_ref
)
575 common_val_print (deref_val
, stream
, recurse
, options
,
578 fputs_filtered ("???", stream
);
582 /* Helper function for generic_val_print_enum.
583 This is also used to print enums in TYPE_CODE_FLAGS values. */
586 generic_val_print_enum_1 (struct type
*type
, LONGEST val
,
587 struct ui_file
*stream
)
592 len
= type
->num_fields ();
593 for (i
= 0; i
< len
; i
++)
596 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
603 fputs_styled (TYPE_FIELD_NAME (type
, i
), variable_name_style
.style (),
606 else if (TYPE_FLAG_ENUM (type
))
610 /* We have a "flag" enum, so we try to decompose it into pieces as
611 appropriate. The enum may have multiple enumerators representing
612 the same bit, in which case we choose to only print the first one
614 for (i
= 0; i
< len
; ++i
)
618 ULONGEST enumval
= TYPE_FIELD_ENUMVAL (type
, i
);
619 int nbits
= count_one_bits_ll (enumval
);
621 gdb_assert (nbits
== 0 || nbits
== 1);
623 if ((val
& enumval
) != 0)
627 fputs_filtered ("(", stream
);
631 fputs_filtered (" | ", stream
);
633 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
634 fputs_styled (TYPE_FIELD_NAME (type
, i
),
635 variable_name_style
.style (), stream
);
641 /* There are leftover bits, print them. */
643 fputs_filtered ("(", stream
);
645 fputs_filtered (" | ", stream
);
647 fputs_filtered ("unknown: 0x", stream
);
648 print_longest (stream
, 'x', 0, val
);
649 fputs_filtered (")", stream
);
653 /* Nothing has been printed and the value is 0, the enum value must
655 fputs_filtered ("0", stream
);
659 /* Something has been printed, close the parenthesis. */
660 fputs_filtered (")", stream
);
664 print_longest (stream
, 'd', 0, val
);
667 /* generic_val_print helper for TYPE_CODE_ENUM. */
670 generic_val_print_enum (struct type
*type
,
671 int embedded_offset
, struct ui_file
*stream
,
672 struct value
*original_value
,
673 const struct value_print_options
*options
)
676 struct gdbarch
*gdbarch
= get_type_arch (type
);
677 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
679 gdb_assert (!options
->format
);
681 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
683 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
685 generic_val_print_enum_1 (type
, val
, stream
);
688 /* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
691 generic_val_print_func (struct type
*type
,
692 int embedded_offset
, CORE_ADDR address
,
693 struct ui_file
*stream
,
694 struct value
*original_value
,
695 const struct value_print_options
*options
)
697 struct gdbarch
*gdbarch
= get_type_arch (type
);
699 gdb_assert (!options
->format
);
701 /* FIXME, we should consider, at least for ANSI C language,
702 eliminating the distinction made between FUNCs and POINTERs to
704 fprintf_filtered (stream
, "{");
705 type_print (type
, "", stream
, -1);
706 fprintf_filtered (stream
, "} ");
707 /* Try to print what function it points to, and its address. */
708 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
711 /* generic_value_print helper for TYPE_CODE_BOOL. */
714 generic_value_print_bool
715 (struct value
*value
, struct ui_file
*stream
,
716 const struct value_print_options
*options
,
717 const struct generic_val_print_decorations
*decorations
)
719 if (options
->format
|| options
->output_format
)
721 struct value_print_options opts
= *options
;
722 opts
.format
= (options
->format
? options
->format
723 : options
->output_format
);
724 value_print_scalar_formatted (value
, &opts
, 0, stream
);
728 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
729 struct type
*type
= check_typedef (value_type (value
));
730 LONGEST val
= unpack_long (type
, valaddr
);
732 fputs_filtered (decorations
->false_name
, stream
);
734 fputs_filtered (decorations
->true_name
, stream
);
736 print_longest (stream
, 'd', 0, val
);
740 /* generic_value_print helper for TYPE_CODE_INT. */
743 generic_value_print_int (struct value
*val
, struct ui_file
*stream
,
744 const struct value_print_options
*options
)
746 struct value_print_options opts
= *options
;
748 opts
.format
= (options
->format
? options
->format
749 : options
->output_format
);
750 value_print_scalar_formatted (val
, &opts
, 0, stream
);
753 /* generic_value_print helper for TYPE_CODE_CHAR. */
756 generic_value_print_char (struct value
*value
, struct ui_file
*stream
,
757 const struct value_print_options
*options
)
759 if (options
->format
|| options
->output_format
)
761 struct value_print_options opts
= *options
;
763 opts
.format
= (options
->format
? options
->format
764 : options
->output_format
);
765 value_print_scalar_formatted (value
, &opts
, 0, stream
);
769 struct type
*unresolved_type
= value_type (value
);
770 struct type
*type
= check_typedef (unresolved_type
);
771 const gdb_byte
*valaddr
= value_contents_for_printing (value
);
773 LONGEST val
= unpack_long (type
, valaddr
);
774 if (type
->is_unsigned ())
775 fprintf_filtered (stream
, "%u", (unsigned int) val
);
777 fprintf_filtered (stream
, "%d", (int) val
);
778 fputs_filtered (" ", stream
);
779 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
783 /* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */
786 generic_val_print_float (struct type
*type
, struct ui_file
*stream
,
787 struct value
*original_value
,
788 const struct value_print_options
*options
)
790 gdb_assert (!options
->format
);
792 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
794 print_floating (valaddr
, type
, stream
);
797 /* generic_value_print helper for TYPE_CODE_COMPLEX. */
800 generic_value_print_complex (struct value
*val
, struct ui_file
*stream
,
801 const struct value_print_options
*options
,
802 const struct generic_val_print_decorations
805 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
807 struct value
*real_part
= value_real_part (val
);
808 value_print_scalar_formatted (real_part
, options
, 0, stream
);
809 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
811 struct value
*imag_part
= value_imaginary_part (val
);
812 value_print_scalar_formatted (imag_part
, options
, 0, stream
);
813 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
816 /* generic_value_print helper for TYPE_CODE_MEMBERPTR. */
819 generic_value_print_memberptr
820 (struct value
*val
, struct ui_file
*stream
,
822 const struct value_print_options
*options
,
823 const struct generic_val_print_decorations
*decorations
)
825 if (!options
->format
)
827 /* Member pointers are essentially specific to C++, and so if we
828 encounter one, we should print it according to C++ rules. */
829 struct type
*type
= check_typedef (value_type (val
));
830 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
831 cp_print_class_member (valaddr
, type
, stream
, "&");
834 generic_value_print (val
, stream
, recurse
, options
, decorations
);
837 /* See valprint.h. */
840 generic_value_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
841 const struct value_print_options
*options
,
842 const struct generic_val_print_decorations
*decorations
)
844 struct type
*type
= value_type (val
);
846 type
= check_typedef (type
);
847 switch (type
->code ())
849 case TYPE_CODE_ARRAY
:
850 generic_val_print_array (val
, stream
, recurse
, options
, decorations
);
853 case TYPE_CODE_MEMBERPTR
:
854 generic_value_print_memberptr (val
, stream
, recurse
, options
,
859 generic_value_print_ptr (val
, stream
, options
);
863 case TYPE_CODE_RVALUE_REF
:
864 generic_val_print_ref (type
, 0, stream
, recurse
,
870 value_print_scalar_formatted (val
, options
, 0, stream
);
872 generic_val_print_enum (type
, 0, stream
, val
, options
);
875 case TYPE_CODE_FLAGS
:
877 value_print_scalar_formatted (val
, options
, 0, stream
);
879 val_print_type_code_flags (type
, val
, 0, stream
);
883 case TYPE_CODE_METHOD
:
885 value_print_scalar_formatted (val
, options
, 0, stream
);
887 generic_val_print_func (type
, 0, value_address (val
), stream
,
892 generic_value_print_bool (val
, stream
, options
, decorations
);
895 case TYPE_CODE_RANGE
:
897 generic_value_print_int (val
, stream
, options
);
901 generic_value_print_char (val
, stream
, options
);
905 case TYPE_CODE_DECFLOAT
:
907 value_print_scalar_formatted (val
, options
, 0, stream
);
909 generic_val_print_float (type
, stream
, val
, options
);
913 fputs_filtered (decorations
->void_name
, stream
);
916 case TYPE_CODE_ERROR
:
917 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
920 case TYPE_CODE_UNDEF
:
921 /* This happens (without TYPE_STUB set) on systems which don't use
922 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
923 and no complete type for struct foo in that file. */
924 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
927 case TYPE_CODE_COMPLEX
:
928 generic_value_print_complex (val
, stream
, options
, decorations
);
931 case TYPE_CODE_METHODPTR
:
932 cplus_print_method_ptr (value_contents_for_printing (val
), type
,
936 case TYPE_CODE_UNION
:
937 case TYPE_CODE_STRUCT
:
939 error (_("Unhandled type code %d in symbol table."),
944 /* Helper function for val_print and common_val_print that does the
945 work. Arguments are as to val_print, but FULL_VALUE, if given, is
946 the value to be printed. */
949 do_val_print (struct value
*value
, struct ui_file
*stream
, int recurse
,
950 const struct value_print_options
*options
,
951 const struct language_defn
*language
)
954 struct value_print_options local_opts
= *options
;
955 struct type
*type
= value_type (value
);
956 struct type
*real_type
= check_typedef (type
);
958 if (local_opts
.prettyformat
== Val_prettyformat_default
)
959 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
960 ? Val_prettyformat
: Val_no_prettyformat
);
964 /* Ensure that the type is complete and not just a stub. If the type is
965 only a stub and we can't find and substitute its complete type, then
966 print appropriate string and return. */
968 if (real_type
->is_stub ())
970 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
974 if (!valprint_check_validity (stream
, real_type
, 0, value
))
979 ret
= apply_ext_lang_val_pretty_printer (value
, stream
, recurse
, options
,
985 /* Handle summary mode. If the value is a scalar, print it;
986 otherwise, print an ellipsis. */
987 if (options
->summary
&& !val_print_scalar_type_p (type
))
989 fprintf_filtered (stream
, "...");
993 /* If this value is too deep then don't print it. */
994 if (!val_print_scalar_or_string_type_p (type
, language
)
995 && val_print_check_max_depth (stream
, recurse
, options
, language
))
1000 language
->value_print_inner (value
, stream
, recurse
, &local_opts
);
1002 catch (const gdb_exception_error
&except
)
1004 fprintf_styled (stream
, metadata_style
.style (),
1005 _("<error reading variable>"));
1009 /* See valprint.h. */
1012 val_print_check_max_depth (struct ui_file
*stream
, int recurse
,
1013 const struct value_print_options
*options
,
1014 const struct language_defn
*language
)
1016 if (options
->max_depth
> -1 && recurse
>= options
->max_depth
)
1018 gdb_assert (language
->struct_too_deep_ellipsis () != NULL
);
1019 fputs_filtered (language
->struct_too_deep_ellipsis (), stream
);
1026 /* Check whether the value VAL is printable. Return 1 if it is;
1027 return 0 and print an appropriate error message to STREAM according to
1028 OPTIONS if it is not. */
1031 value_check_printable (struct value
*val
, struct ui_file
*stream
,
1032 const struct value_print_options
*options
)
1036 fprintf_styled (stream
, metadata_style
.style (),
1037 _("<address of value unknown>"));
1041 if (value_entirely_optimized_out (val
))
1043 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1044 fprintf_filtered (stream
, "...");
1046 val_print_optimized_out (val
, stream
);
1050 if (value_entirely_unavailable (val
))
1052 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1053 fprintf_filtered (stream
, "...");
1055 val_print_unavailable (stream
);
1059 if (value_type (val
)->code () == TYPE_CODE_INTERNAL_FUNCTION
)
1061 fprintf_styled (stream
, metadata_style
.style (),
1062 _("<internal function %s>"),
1063 value_internal_function_name (val
));
1067 if (type_not_associated (value_type (val
)))
1069 val_print_not_associated (stream
);
1073 if (type_not_allocated (value_type (val
)))
1075 val_print_not_allocated (stream
);
1082 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
1085 This is a preferable interface to val_print, above, because it uses
1086 GDB's value mechanism. */
1089 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
1090 const struct value_print_options
*options
,
1091 const struct language_defn
*language
)
1093 if (language
->la_language
== language_ada
)
1094 /* The value might have a dynamic type, which would cause trouble
1095 below when trying to extract the value contents (since the value
1096 size is determined from the type size which is unknown). So
1097 get a fixed representation of our value. */
1098 val
= ada_to_fixed_value (val
);
1100 if (value_lazy (val
))
1101 value_fetch_lazy (val
);
1103 do_val_print (val
, stream
, recurse
, options
, language
);
1106 /* See valprint.h. */
1109 common_val_print_checked (struct value
*val
, struct ui_file
*stream
,
1111 const struct value_print_options
*options
,
1112 const struct language_defn
*language
)
1114 if (!value_check_printable (val
, stream
, options
))
1116 common_val_print (val
, stream
, recurse
, options
, language
);
1119 /* Print on stream STREAM the value VAL according to OPTIONS. The value
1120 is printed using the current_language syntax. */
1123 value_print (struct value
*val
, struct ui_file
*stream
,
1124 const struct value_print_options
*options
)
1126 scoped_value_mark free_values
;
1128 if (!value_check_printable (val
, stream
, options
))
1134 = apply_ext_lang_val_pretty_printer (val
, stream
, 0, options
,
1141 current_language
->value_print (val
, stream
, options
);
1145 val_print_type_code_flags (struct type
*type
, struct value
*original_value
,
1146 int embedded_offset
, struct ui_file
*stream
)
1148 const gdb_byte
*valaddr
= (value_contents_for_printing (original_value
)
1150 ULONGEST val
= unpack_long (type
, valaddr
);
1151 int field
, nfields
= type
->num_fields ();
1152 struct gdbarch
*gdbarch
= get_type_arch (type
);
1153 struct type
*bool_type
= builtin_type (gdbarch
)->builtin_bool
;
1155 fputs_filtered ("[", stream
);
1156 for (field
= 0; field
< nfields
; field
++)
1158 if (TYPE_FIELD_NAME (type
, field
)[0] != '\0')
1160 struct type
*field_type
= type
->field (field
).type ();
1162 if (field_type
== bool_type
1163 /* We require boolean types here to be one bit wide. This is a
1164 problematic place to notify the user of an internal error
1165 though. Instead just fall through and print the field as an
1167 && TYPE_FIELD_BITSIZE (type
, field
) == 1)
1169 if (val
& ((ULONGEST
)1 << TYPE_FIELD_BITPOS (type
, field
)))
1172 styled_string (variable_name_style
.style (),
1173 TYPE_FIELD_NAME (type
, field
)));
1177 unsigned field_len
= TYPE_FIELD_BITSIZE (type
, field
);
1179 = val
>> (TYPE_FIELD_BITPOS (type
, field
) - field_len
+ 1);
1181 if (field_len
< sizeof (ULONGEST
) * TARGET_CHAR_BIT
)
1182 field_val
&= ((ULONGEST
) 1 << field_len
) - 1;
1183 fprintf_filtered (stream
, " %ps=",
1184 styled_string (variable_name_style
.style (),
1185 TYPE_FIELD_NAME (type
, field
)));
1186 if (field_type
->code () == TYPE_CODE_ENUM
)
1187 generic_val_print_enum_1 (field_type
, field_val
, stream
);
1189 print_longest (stream
, 'd', 0, field_val
);
1193 fputs_filtered (" ]", stream
);
1196 /* See valprint.h. */
1199 value_print_scalar_formatted (struct value
*val
,
1200 const struct value_print_options
*options
,
1202 struct ui_file
*stream
)
1204 struct type
*type
= check_typedef (value_type (val
));
1206 gdb_assert (val
!= NULL
);
1208 /* If we get here with a string format, try again without it. Go
1209 all the way back to the language printers, which may call us
1211 if (options
->format
== 's')
1213 struct value_print_options opts
= *options
;
1216 common_val_print (val
, stream
, 0, &opts
, current_language
);
1220 /* value_contents_for_printing fetches all VAL's contents. They are
1221 needed to check whether VAL is optimized-out or unavailable
1223 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1225 /* A scalar object that does not have all bits available can't be
1226 printed, because all bits contribute to its representation. */
1227 if (value_bits_any_optimized_out (val
, 0,
1228 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1229 val_print_optimized_out (val
, stream
);
1230 else if (!value_bytes_available (val
, 0, TYPE_LENGTH (type
)))
1231 val_print_unavailable (stream
);
1233 print_scalar_formatted (valaddr
, type
, options
, size
, stream
);
1236 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1237 The raison d'etre of this function is to consolidate printing of
1238 LONG_LONG's into this one function. The format chars b,h,w,g are
1239 from print_scalar_formatted(). Numbers are printed using C
1242 USE_C_FORMAT means to use C format in all cases. Without it,
1243 'o' and 'x' format do not include the standard C radix prefix
1246 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1247 and was intended to request formatting according to the current
1248 language and would be used for most integers that GDB prints. The
1249 exceptional cases were things like protocols where the format of
1250 the integer is a protocol thing, not a user-visible thing). The
1251 parameter remains to preserve the information of what things might
1252 be printed with language-specific format, should we ever resurrect
1256 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1264 val
= int_string (val_long
, 10, 1, 0, 1); break;
1266 val
= int_string (val_long
, 10, 0, 0, 1); break;
1268 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1270 val
= int_string (val_long
, 16, 0, 2, 1); break;
1272 val
= int_string (val_long
, 16, 0, 4, 1); break;
1274 val
= int_string (val_long
, 16, 0, 8, 1); break;
1276 val
= int_string (val_long
, 16, 0, 16, 1); break;
1279 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1281 internal_error (__FILE__
, __LINE__
,
1282 _("failed internal consistency check"));
1284 fputs_filtered (val
, stream
);
1287 /* This used to be a macro, but I don't think it is called often enough
1288 to merit such treatment. */
1289 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1290 arguments to a function, number in a value history, register number, etc.)
1291 where the value must not be larger than can fit in an int. */
1294 longest_to_int (LONGEST arg
)
1296 /* Let the compiler do the work. */
1297 int rtnval
= (int) arg
;
1299 /* Check for overflows or underflows. */
1300 if (sizeof (LONGEST
) > sizeof (int))
1304 error (_("Value out of range."));
1310 /* Print a floating point value of floating-point type TYPE,
1311 pointed to in GDB by VALADDR, on STREAM. */
1314 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1315 struct ui_file
*stream
)
1317 std::string str
= target_float_to_string (valaddr
, type
);
1318 fputs_filtered (str
.c_str (), stream
);
1322 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1323 unsigned len
, enum bfd_endian byte_order
, bool zero_pad
)
1328 bool seen_a_one
= false;
1330 /* Declared "int" so it will be signed.
1331 This ensures that right shift will shift in zeros. */
1333 const int mask
= 0x080;
1335 if (byte_order
== BFD_ENDIAN_BIG
)
1341 /* Every byte has 8 binary characters; peel off
1342 and print from the MSB end. */
1344 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1346 if (*p
& (mask
>> i
))
1351 if (zero_pad
|| seen_a_one
|| b
== '1')
1352 fputc_filtered (b
, stream
);
1360 for (p
= valaddr
+ len
- 1;
1364 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1366 if (*p
& (mask
>> i
))
1371 if (zero_pad
|| seen_a_one
|| b
== '1')
1372 fputc_filtered (b
, stream
);
1379 /* When not zero-padding, ensure that something is printed when the
1381 if (!zero_pad
&& !seen_a_one
)
1382 fputc_filtered ('0', stream
);
1385 /* A helper for print_octal_chars that emits a single octal digit,
1386 optionally suppressing it if is zero and updating SEEN_A_ONE. */
1389 emit_octal_digit (struct ui_file
*stream
, bool *seen_a_one
, int digit
)
1391 if (*seen_a_one
|| digit
!= 0)
1392 fprintf_filtered (stream
, "%o", digit
);
1397 /* VALADDR points to an integer of LEN bytes.
1398 Print it in octal on stream or format it in buf. */
1401 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1402 unsigned len
, enum bfd_endian byte_order
)
1405 unsigned char octa1
, octa2
, octa3
, carry
;
1408 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1409 * the extra bits, which cycle every three bytes:
1411 * Byte side: 0 1 2 3
1413 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1415 * Octal side: 0 1 carry 3 4 carry ...
1417 * Cycle number: 0 1 2
1419 * But of course we are printing from the high side, so we have to
1420 * figure out where in the cycle we are so that we end up with no
1421 * left over bits at the end.
1423 #define BITS_IN_OCTAL 3
1424 #define HIGH_ZERO 0340
1425 #define LOW_ZERO 0034
1426 #define CARRY_ZERO 0003
1427 static_assert (HIGH_ZERO
+ LOW_ZERO
+ CARRY_ZERO
== 0xff,
1428 "cycle zero constants are wrong");
1429 #define HIGH_ONE 0200
1430 #define MID_ONE 0160
1431 #define LOW_ONE 0016
1432 #define CARRY_ONE 0001
1433 static_assert (HIGH_ONE
+ MID_ONE
+ LOW_ONE
+ CARRY_ONE
== 0xff,
1434 "cycle one constants are wrong");
1435 #define HIGH_TWO 0300
1436 #define MID_TWO 0070
1437 #define LOW_TWO 0007
1438 static_assert (HIGH_TWO
+ MID_TWO
+ LOW_TWO
== 0xff,
1439 "cycle two constants are wrong");
1441 /* For 32 we start in cycle 2, with two bits and one bit carry;
1442 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1444 cycle
= (len
* HOST_CHAR_BIT
) % BITS_IN_OCTAL
;
1447 fputs_filtered ("0", stream
);
1448 bool seen_a_one
= false;
1449 if (byte_order
== BFD_ENDIAN_BIG
)
1458 /* No carry in, carry out two bits. */
1460 octa1
= (HIGH_ZERO
& *p
) >> 5;
1461 octa2
= (LOW_ZERO
& *p
) >> 2;
1462 carry
= (CARRY_ZERO
& *p
);
1463 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1464 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1468 /* Carry in two bits, carry out one bit. */
1470 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1471 octa2
= (MID_ONE
& *p
) >> 4;
1472 octa3
= (LOW_ONE
& *p
) >> 1;
1473 carry
= (CARRY_ONE
& *p
);
1474 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1475 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1476 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1480 /* Carry in one bit, no carry out. */
1482 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1483 octa2
= (MID_TWO
& *p
) >> 3;
1484 octa3
= (LOW_TWO
& *p
);
1486 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1487 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1488 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1492 error (_("Internal error in octal conversion;"));
1496 cycle
= cycle
% BITS_IN_OCTAL
;
1501 for (p
= valaddr
+ len
- 1;
1508 /* Carry out, no carry in */
1510 octa1
= (HIGH_ZERO
& *p
) >> 5;
1511 octa2
= (LOW_ZERO
& *p
) >> 2;
1512 carry
= (CARRY_ZERO
& *p
);
1513 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1514 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1518 /* Carry in, carry out */
1520 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1521 octa2
= (MID_ONE
& *p
) >> 4;
1522 octa3
= (LOW_ONE
& *p
) >> 1;
1523 carry
= (CARRY_ONE
& *p
);
1524 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1525 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1526 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1530 /* Carry in, no carry out */
1532 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1533 octa2
= (MID_TWO
& *p
) >> 3;
1534 octa3
= (LOW_TWO
& *p
);
1536 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1537 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1538 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1542 error (_("Internal error in octal conversion;"));
1546 cycle
= cycle
% BITS_IN_OCTAL
;
1552 /* Possibly negate the integer represented by BYTES. It contains LEN
1553 bytes in the specified byte order. If the integer is negative,
1554 copy it into OUT_VEC, negate it, and return true. Otherwise, do
1555 nothing and return false. */
1558 maybe_negate_by_bytes (const gdb_byte
*bytes
, unsigned len
,
1559 enum bfd_endian byte_order
,
1560 gdb::byte_vector
*out_vec
)
1563 gdb_assert (len
> 0);
1564 if (byte_order
== BFD_ENDIAN_BIG
)
1565 sign_byte
= bytes
[0];
1567 sign_byte
= bytes
[len
- 1];
1568 if ((sign_byte
& 0x80) == 0)
1571 out_vec
->resize (len
);
1573 /* Compute -x == 1 + ~x. */
1574 if (byte_order
== BFD_ENDIAN_LITTLE
)
1577 for (unsigned i
= 0; i
< len
; ++i
)
1579 unsigned tem
= (0xff & ~bytes
[i
]) + carry
;
1580 (*out_vec
)[i
] = tem
& 0xff;
1587 for (unsigned i
= len
; i
> 0; --i
)
1589 unsigned tem
= (0xff & ~bytes
[i
- 1]) + carry
;
1590 (*out_vec
)[i
- 1] = tem
& 0xff;
1598 /* VALADDR points to an integer of LEN bytes.
1599 Print it in decimal on stream or format it in buf. */
1602 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1603 unsigned len
, bool is_signed
,
1604 enum bfd_endian byte_order
)
1607 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1608 #define CARRY_LEFT( x ) ((x) % TEN)
1609 #define SHIFT( x ) ((x) << 4)
1610 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1611 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1616 int i
, j
, decimal_digits
;
1620 gdb::byte_vector negated_bytes
;
1622 && maybe_negate_by_bytes (valaddr
, len
, byte_order
, &negated_bytes
))
1624 fputs_filtered ("-", stream
);
1625 valaddr
= negated_bytes
.data ();
1628 /* Base-ten number is less than twice as many digits
1629 as the base 16 number, which is 2 digits per byte. */
1631 decimal_len
= len
* 2 * 2;
1632 std::vector
<unsigned char> digits (decimal_len
, 0);
1634 /* Ok, we have an unknown number of bytes of data to be printed in
1637 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1638 * decimalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1639 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1641 * The trick is that "digits" holds a base-10 number, but sometimes
1642 * the individual digits are > 10.
1644 * Outer loop is per nibble (hex digit) of input, from MSD end to
1647 decimal_digits
= 0; /* Number of decimal digits so far */
1648 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1650 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1653 * Multiply current base-ten number by 16 in place.
1654 * Each digit was between 0 and 9, now is between
1657 for (j
= 0; j
< decimal_digits
; j
++)
1659 digits
[j
] = SHIFT (digits
[j
]);
1662 /* Take the next nibble off the input and add it to what
1663 * we've got in the LSB position. Bottom 'digit' is now
1664 * between 0 and 159.
1666 * "flip" is used to run this loop twice for each byte.
1670 /* Take top nibble. */
1672 digits
[0] += HIGH_NIBBLE (*p
);
1677 /* Take low nibble and bump our pointer "p". */
1679 digits
[0] += LOW_NIBBLE (*p
);
1680 if (byte_order
== BFD_ENDIAN_BIG
)
1687 /* Re-decimalize. We have to do this often enough
1688 * that we don't overflow, but once per nibble is
1689 * overkill. Easier this way, though. Note that the
1690 * carry is often larger than 10 (e.g. max initial
1691 * carry out of lowest nibble is 15, could bubble all
1692 * the way up greater than 10). So we have to do
1693 * the carrying beyond the last current digit.
1696 for (j
= 0; j
< decimal_len
- 1; j
++)
1700 /* "/" won't handle an unsigned char with
1701 * a value that if signed would be negative.
1702 * So extend to longword int via "dummy".
1705 carry
= CARRY_OUT (dummy
);
1706 digits
[j
] = CARRY_LEFT (dummy
);
1708 if (j
>= decimal_digits
&& carry
== 0)
1711 * All higher digits are 0 and we
1712 * no longer have a carry.
1714 * Note: "j" is 0-based, "decimal_digits" is
1717 decimal_digits
= j
+ 1;
1723 /* Ok, now "digits" is the decimal representation, with
1724 the "decimal_digits" actual digits. Print! */
1726 for (i
= decimal_digits
- 1; i
> 0 && digits
[i
] == 0; --i
)
1731 fprintf_filtered (stream
, "%1d", digits
[i
]);
1735 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1738 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1739 unsigned len
, enum bfd_endian byte_order
,
1744 fputs_filtered ("0x", stream
);
1745 if (byte_order
== BFD_ENDIAN_BIG
)
1751 /* Strip leading 0 bytes, but be sure to leave at least a
1752 single byte at the end. */
1753 for (; p
< valaddr
+ len
- 1 && !*p
; ++p
)
1757 const gdb_byte
*first
= p
;
1762 /* When not zero-padding, use a different format for the
1763 very first byte printed. */
1764 if (!zero_pad
&& p
== first
)
1765 fprintf_filtered (stream
, "%x", *p
);
1767 fprintf_filtered (stream
, "%02x", *p
);
1772 p
= valaddr
+ len
- 1;
1776 /* Strip leading 0 bytes, but be sure to leave at least a
1777 single byte at the end. */
1778 for (; p
>= valaddr
+ 1 && !*p
; --p
)
1782 const gdb_byte
*first
= p
;
1787 /* When not zero-padding, use a different format for the
1788 very first byte printed. */
1789 if (!zero_pad
&& p
== first
)
1790 fprintf_filtered (stream
, "%x", *p
);
1792 fprintf_filtered (stream
, "%02x", *p
);
1797 /* VALADDR points to a char integer of LEN bytes.
1798 Print it out in appropriate language form on stream.
1799 Omit any leading zero chars. */
1802 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1803 const gdb_byte
*valaddr
,
1804 unsigned len
, enum bfd_endian byte_order
)
1808 if (byte_order
== BFD_ENDIAN_BIG
)
1811 while (p
< valaddr
+ len
- 1 && *p
== 0)
1814 while (p
< valaddr
+ len
)
1816 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1822 p
= valaddr
+ len
- 1;
1823 while (p
> valaddr
&& *p
== 0)
1826 while (p
>= valaddr
)
1828 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1834 /* Print function pointer with inferior address ADDRESS onto stdio
1838 print_function_pointer_address (const struct value_print_options
*options
,
1839 struct gdbarch
*gdbarch
,
1841 struct ui_file
*stream
)
1844 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
1845 current_top_target ());
1847 /* If the function pointer is represented by a description, print
1848 the address of the description. */
1849 if (options
->addressprint
&& func_addr
!= address
)
1851 fputs_filtered ("@", stream
);
1852 fputs_filtered (paddress (gdbarch
, address
), stream
);
1853 fputs_filtered (": ", stream
);
1855 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
1859 /* Print on STREAM using the given OPTIONS the index for the element
1860 at INDEX of an array whose index type is INDEX_TYPE. */
1863 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1864 struct ui_file
*stream
,
1865 const struct value_print_options
*options
)
1867 if (!options
->print_array_indexes
)
1870 LA_PRINT_ARRAY_INDEX (index_type
, index
, stream
, options
);
1873 /* See valprint.h. */
1876 value_print_array_elements (struct value
*val
, struct ui_file
*stream
,
1878 const struct value_print_options
*options
,
1881 unsigned int things_printed
= 0;
1883 struct type
*elttype
, *index_type
;
1885 /* Position of the array element we are examining to see
1886 whether it is repeated. */
1888 /* Number of repetitions we have detected so far. */
1890 LONGEST low_bound
, high_bound
;
1892 struct type
*type
= check_typedef (value_type (val
));
1894 elttype
= TYPE_TARGET_TYPE (type
);
1895 eltlen
= type_length_units (check_typedef (elttype
));
1896 index_type
= type
->index_type ();
1897 if (index_type
->code () == TYPE_CODE_RANGE
)
1898 index_type
= TYPE_TARGET_TYPE (index_type
);
1900 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1902 /* The array length should normally be HIGH_BOUND - LOW_BOUND +
1903 1. But we have to be a little extra careful, because some
1904 languages such as Ada allow LOW_BOUND to be greater than
1905 HIGH_BOUND for empty arrays. In that situation, the array
1906 length is just zero, not negative! */
1907 if (low_bound
> high_bound
)
1910 len
= high_bound
- low_bound
+ 1;
1914 warning (_("unable to get bounds of array, assuming null array"));
1919 annotate_array_section_begin (i
, elttype
);
1921 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1923 scoped_value_mark free_values
;
1927 if (options
->prettyformat_arrays
)
1929 fprintf_filtered (stream
, ",\n");
1930 print_spaces_filtered (2 + 2 * recurse
, stream
);
1933 fprintf_filtered (stream
, ", ");
1935 else if (options
->prettyformat_arrays
)
1937 fprintf_filtered (stream
, "\n");
1938 print_spaces_filtered (2 + 2 * recurse
, stream
);
1940 wrap_here (n_spaces (2 + 2 * recurse
));
1941 maybe_print_array_index (index_type
, i
+ low_bound
,
1946 /* Only check for reps if repeat_count_threshold is not set to
1947 UINT_MAX (unlimited). */
1948 if (options
->repeat_count_threshold
< UINT_MAX
)
1951 && value_contents_eq (val
, i
* eltlen
,
1960 struct value
*element
= value_from_component (val
, elttype
, eltlen
* i
);
1961 common_val_print (element
, stream
, recurse
+ 1, options
,
1964 if (reps
> options
->repeat_count_threshold
)
1966 annotate_elt_rep (reps
);
1967 fprintf_filtered (stream
, " %p[<repeats %u times>%p]",
1968 metadata_style
.style ().ptr (), reps
, nullptr);
1969 annotate_elt_rep_end ();
1972 things_printed
+= options
->repeat_count_threshold
;
1980 annotate_array_section_end ();
1982 fprintf_filtered (stream
, "...");
1983 if (options
->prettyformat_arrays
)
1985 fprintf_filtered (stream
, "\n");
1986 print_spaces_filtered (2 * recurse
, stream
);
1990 /* Read LEN bytes of target memory at address MEMADDR, placing the
1991 results in GDB's memory at MYADDR. Returns a count of the bytes
1992 actually read, and optionally a target_xfer_status value in the
1993 location pointed to by ERRPTR if ERRPTR is non-null. */
1995 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1996 function be eliminated. */
1999 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
2000 int len
, int *errptr
)
2002 int nread
; /* Number of bytes actually read. */
2003 int errcode
; /* Error from last read. */
2005 /* First try a complete read. */
2006 errcode
= target_read_memory (memaddr
, myaddr
, len
);
2014 /* Loop, reading one byte at a time until we get as much as we can. */
2015 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
2017 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
2019 /* If an error, the last read was unsuccessful, so adjust count. */
2032 /* Read a string from the inferior, at ADDR, with LEN characters of
2033 WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER
2034 will be set to a newly allocated buffer containing the string, and
2035 BYTES_READ will be set to the number of bytes read. Returns 0 on
2036 success, or a target_xfer_status on failure.
2038 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2039 (including eventual NULs in the middle or end of the string).
2041 If LEN is -1, stops at the first null character (not necessarily
2042 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2043 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2046 Unless an exception is thrown, BUFFER will always be allocated, even on
2047 failure. In this case, some characters might have been read before the
2048 failure happened. Check BYTES_READ to recognize this situation. */
2051 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
2052 enum bfd_endian byte_order
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
2055 int errcode
; /* Errno returned from bad reads. */
2056 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
2057 gdb_byte
*bufptr
; /* Pointer to next available byte in
2060 /* Loop until we either have all the characters, or we encounter
2061 some error, such as bumping into the end of the address space. */
2063 buffer
->reset (nullptr);
2067 /* We want fetchlimit chars, so we might as well read them all in
2069 unsigned int fetchlen
= std::min ((unsigned) len
, fetchlimit
);
2071 buffer
->reset ((gdb_byte
*) xmalloc (fetchlen
* width
));
2072 bufptr
= buffer
->get ();
2074 nfetch
= partial_memory_read (addr
, bufptr
, fetchlen
* width
, &errcode
)
2076 addr
+= nfetch
* width
;
2077 bufptr
+= nfetch
* width
;
2081 unsigned long bufsize
= 0;
2082 unsigned int chunksize
; /* Size of each fetch, in chars. */
2083 int found_nul
; /* Non-zero if we found the nul char. */
2084 gdb_byte
*limit
; /* First location past end of fetch buffer. */
2087 /* We are looking for a NUL terminator to end the fetching, so we
2088 might as well read in blocks that are large enough to be efficient,
2089 but not so large as to be slow if fetchlimit happens to be large.
2090 So we choose the minimum of 8 and fetchlimit. We used to use 200
2091 instead of 8 but 200 is way too big for remote debugging over a
2093 chunksize
= std::min (8u, fetchlimit
);
2098 nfetch
= std::min ((unsigned long) chunksize
, fetchlimit
- bufsize
);
2100 if (*buffer
== NULL
)
2101 buffer
->reset ((gdb_byte
*) xmalloc (nfetch
* width
));
2103 buffer
->reset ((gdb_byte
*) xrealloc (buffer
->release (),
2104 (nfetch
+ bufsize
) * width
));
2106 bufptr
= buffer
->get () + bufsize
* width
;
2109 /* Read as much as we can. */
2110 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
2113 /* Scan this chunk for the null character that terminates the string
2114 to print. If found, we don't need to fetch any more. Note
2115 that bufptr is explicitly left pointing at the next character
2116 after the null character, or at the next character after the end
2119 limit
= bufptr
+ nfetch
* width
;
2120 while (bufptr
< limit
)
2124 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
2129 /* We don't care about any error which happened after
2130 the NUL terminator. */
2137 while (errcode
== 0 /* no error */
2138 && bufptr
- buffer
->get () < fetchlimit
* width
/* no overrun */
2139 && !found_nul
); /* haven't found NUL yet */
2142 { /* Length of string is really 0! */
2143 /* We always allocate *buffer. */
2144 buffer
->reset ((gdb_byte
*) xmalloc (1));
2145 bufptr
= buffer
->get ();
2149 /* bufptr and addr now point immediately beyond the last byte which we
2150 consider part of the string (including a '\0' which ends the string). */
2151 *bytes_read
= bufptr
- buffer
->get ();
2158 /* Return true if print_wchar can display W without resorting to a
2159 numeric escape, false otherwise. */
2162 wchar_printable (gdb_wchar_t w
)
2164 return (gdb_iswprint (w
)
2165 || w
== LCST ('\a') || w
== LCST ('\b')
2166 || w
== LCST ('\f') || w
== LCST ('\n')
2167 || w
== LCST ('\r') || w
== LCST ('\t')
2168 || w
== LCST ('\v'));
2171 /* A helper function that converts the contents of STRING to wide
2172 characters and then appends them to OUTPUT. */
2175 append_string_as_wide (const char *string
,
2176 struct obstack
*output
)
2178 for (; *string
; ++string
)
2180 gdb_wchar_t w
= gdb_btowc (*string
);
2181 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
2185 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2186 original (target) bytes representing the character, ORIG_LEN is the
2187 number of valid bytes. WIDTH is the number of bytes in a base
2188 characters of the type. OUTPUT is an obstack to which wide
2189 characters are emitted. QUOTER is a (narrow) character indicating
2190 the style of quotes surrounding the character to be printed.
2191 NEED_ESCAPE is an in/out flag which is used to track numeric
2192 escapes across calls. */
2195 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
2196 int orig_len
, int width
,
2197 enum bfd_endian byte_order
,
2198 struct obstack
*output
,
2199 int quoter
, int *need_escapep
)
2201 int need_escape
= *need_escapep
;
2205 /* iswprint implementation on Windows returns 1 for tab character.
2206 In order to avoid different printout on this host, we explicitly
2207 use wchar_printable function. */
2211 obstack_grow_wstr (output
, LCST ("\\a"));
2214 obstack_grow_wstr (output
, LCST ("\\b"));
2217 obstack_grow_wstr (output
, LCST ("\\f"));
2220 obstack_grow_wstr (output
, LCST ("\\n"));
2223 obstack_grow_wstr (output
, LCST ("\\r"));
2226 obstack_grow_wstr (output
, LCST ("\\t"));
2229 obstack_grow_wstr (output
, LCST ("\\v"));
2233 if (wchar_printable (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
2235 && w
!= LCST ('9'))))
2237 gdb_wchar_t wchar
= w
;
2239 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
2240 obstack_grow_wstr (output
, LCST ("\\"));
2241 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
2247 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
2252 value
= extract_unsigned_integer (&orig
[i
], width
,
2254 /* If the value fits in 3 octal digits, print it that
2255 way. Otherwise, print it as a hex escape. */
2257 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
2258 (int) (value
& 0777));
2260 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
2261 append_string_as_wide (octal
, output
);
2263 /* If we somehow have extra bytes, print them now. */
2264 while (i
< orig_len
)
2268 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
2269 append_string_as_wide (octal
, output
);
2280 /* Print the character C on STREAM as part of the contents of a
2281 literal string whose delimiter is QUOTER. ENCODING names the
2285 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2286 int quoter
, const char *encoding
)
2288 enum bfd_endian byte_order
2289 = type_byte_order (type
);
2291 int need_escape
= 0;
2293 c_buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
2294 pack_long (c_buf
, type
, c
);
2296 wchar_iterator
iter (c_buf
, TYPE_LENGTH (type
), encoding
, TYPE_LENGTH (type
));
2298 /* This holds the printable form of the wchar_t data. */
2299 auto_obstack wchar_buf
;
2305 const gdb_byte
*buf
;
2307 int print_escape
= 1;
2308 enum wchar_iterate_result result
;
2310 num_chars
= iter
.iterate (&result
, &chars
, &buf
, &buflen
);
2315 /* If all characters are printable, print them. Otherwise,
2316 we're going to have to print an escape sequence. We
2317 check all characters because we want to print the target
2318 bytes in the escape sequence, and we don't know character
2319 boundaries there. */
2323 for (i
= 0; i
< num_chars
; ++i
)
2324 if (!wchar_printable (chars
[i
]))
2332 for (i
= 0; i
< num_chars
; ++i
)
2333 print_wchar (chars
[i
], buf
, buflen
,
2334 TYPE_LENGTH (type
), byte_order
,
2335 &wchar_buf
, quoter
, &need_escape
);
2339 /* This handles the NUM_CHARS == 0 case as well. */
2341 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2342 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2345 /* The output in the host encoding. */
2346 auto_obstack output
;
2348 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2349 (gdb_byte
*) obstack_base (&wchar_buf
),
2350 obstack_object_size (&wchar_buf
),
2351 sizeof (gdb_wchar_t
), &output
, translit_char
);
2352 obstack_1grow (&output
, '\0');
2354 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2357 /* Return the repeat count of the next character/byte in ITER,
2358 storing the result in VEC. */
2361 count_next_character (wchar_iterator
*iter
,
2362 std::vector
<converted_character
> *vec
)
2364 struct converted_character
*current
;
2368 struct converted_character tmp
;
2372 = iter
->iterate (&tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2373 if (tmp
.num_chars
> 0)
2375 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2376 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2378 vec
->push_back (tmp
);
2381 current
= &vec
->back ();
2383 /* Count repeated characters or bytes. */
2384 current
->repeat_count
= 1;
2385 if (current
->num_chars
== -1)
2393 struct converted_character d
;
2400 /* Get the next character. */
2401 d
.num_chars
= iter
->iterate (&d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2403 /* If a character was successfully converted, save the character
2404 into the converted character. */
2405 if (d
.num_chars
> 0)
2407 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2408 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2411 /* Determine if the current character is the same as this
2413 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2415 /* There are two cases to consider:
2417 1) Equality of converted character (num_chars > 0)
2418 2) Equality of non-converted character (num_chars == 0) */
2419 if ((current
->num_chars
> 0
2420 && memcmp (current
->chars
, d
.chars
,
2421 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2422 || (current
->num_chars
== 0
2423 && current
->buflen
== d
.buflen
2424 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2425 ++current
->repeat_count
;
2433 /* Push this next converted character onto the result vector. */
2434 repeat
= current
->repeat_count
;
2440 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2441 character to use with string output. WIDTH is the size of the output
2442 character type. BYTE_ORDER is the target byte order. OPTIONS
2443 is the user's print options. */
2446 print_converted_chars_to_obstack (struct obstack
*obstack
,
2447 const std::vector
<converted_character
> &chars
,
2448 int quote_char
, int width
,
2449 enum bfd_endian byte_order
,
2450 const struct value_print_options
*options
)
2453 const converted_character
*elem
;
2454 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2455 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2456 int need_escape
= 0;
2458 /* Set the start state. */
2460 last
= state
= START
;
2468 /* Nothing to do. */
2475 /* We are outputting a single character
2476 (< options->repeat_count_threshold). */
2480 /* We were outputting some other type of content, so we
2481 must output and a comma and a quote. */
2483 obstack_grow_wstr (obstack
, LCST (", "));
2484 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2486 /* Output the character. */
2487 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2489 if (elem
->result
== wchar_iterate_ok
)
2490 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2491 byte_order
, obstack
, quote_char
, &need_escape
);
2493 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2494 byte_order
, obstack
, quote_char
, &need_escape
);
2503 /* We are outputting a character with a repeat count
2504 greater than options->repeat_count_threshold. */
2508 /* We were outputting a single string. Terminate the
2510 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2513 obstack_grow_wstr (obstack
, LCST (", "));
2515 /* Output the character and repeat string. */
2516 obstack_grow_wstr (obstack
, LCST ("'"));
2517 if (elem
->result
== wchar_iterate_ok
)
2518 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2519 byte_order
, obstack
, quote_char
, &need_escape
);
2521 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2522 byte_order
, obstack
, quote_char
, &need_escape
);
2523 obstack_grow_wstr (obstack
, LCST ("'"));
2524 std::string s
= string_printf (_(" <repeats %u times>"),
2525 elem
->repeat_count
);
2526 for (j
= 0; s
[j
]; ++j
)
2528 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2529 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2535 /* We are outputting an incomplete sequence. */
2538 /* If we were outputting a string of SINGLE characters,
2539 terminate the quote. */
2540 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2543 obstack_grow_wstr (obstack
, LCST (", "));
2545 /* Output the incomplete sequence string. */
2546 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
2547 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
2548 obstack
, 0, &need_escape
);
2549 obstack_grow_wstr (obstack
, LCST (">"));
2551 /* We do not attempt to output anything after this. */
2556 /* All done. If we were outputting a string of SINGLE
2557 characters, the string must be terminated. Otherwise,
2558 REPEAT and INCOMPLETE are always left properly terminated. */
2560 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2565 /* Get the next element and state. */
2567 if (state
!= FINISH
)
2569 elem
= &chars
[idx
++];
2570 switch (elem
->result
)
2572 case wchar_iterate_ok
:
2573 case wchar_iterate_invalid
:
2574 if (elem
->repeat_count
> options
->repeat_count_threshold
)
2580 case wchar_iterate_incomplete
:
2584 case wchar_iterate_eof
:
2592 /* Print the character string STRING, printing at most LENGTH
2593 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2594 the type of each character. OPTIONS holds the printing options;
2595 printing stops early if the number hits print_max; repeat counts
2596 are printed as appropriate. Print ellipses at the end if we had to
2597 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2598 QUOTE_CHAR is the character to print at each end of the string. If
2599 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2603 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2604 const gdb_byte
*string
, unsigned int length
,
2605 const char *encoding
, int force_ellipses
,
2606 int quote_char
, int c_style_terminator
,
2607 const struct value_print_options
*options
)
2609 enum bfd_endian byte_order
= type_byte_order (type
);
2611 int width
= TYPE_LENGTH (type
);
2613 struct converted_character
*last
;
2617 unsigned long current_char
= 1;
2619 for (i
= 0; current_char
; ++i
)
2622 current_char
= extract_unsigned_integer (string
+ i
* width
,
2628 /* If the string was not truncated due to `set print elements', and
2629 the last byte of it is a null, we don't print that, in
2630 traditional C style. */
2631 if (c_style_terminator
2634 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2635 width
, byte_order
) == 0))
2640 fputs_filtered ("\"\"", stream
);
2644 /* Arrange to iterate over the characters, in wchar_t form. */
2645 wchar_iterator
iter (string
, length
* width
, encoding
, width
);
2646 std::vector
<converted_character
> converted_chars
;
2648 /* Convert characters until the string is over or the maximum
2649 number of printed characters has been reached. */
2651 while (i
< options
->print_max
)
2657 /* Grab the next character and repeat count. */
2658 r
= count_next_character (&iter
, &converted_chars
);
2660 /* If less than zero, the end of the input string was reached. */
2664 /* Otherwise, add the count to the total print count and get
2665 the next character. */
2669 /* Get the last element and determine if the entire string was
2671 last
= &converted_chars
.back ();
2672 finished
= (last
->result
== wchar_iterate_eof
);
2674 /* Ensure that CONVERTED_CHARS is terminated. */
2675 last
->result
= wchar_iterate_eof
;
2677 /* WCHAR_BUF is the obstack we use to represent the string in
2679 auto_obstack wchar_buf
;
2681 /* Print the output string to the obstack. */
2682 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
2683 width
, byte_order
, options
);
2685 if (force_ellipses
|| !finished
)
2686 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2688 /* OUTPUT is where we collect `char's for printing. */
2689 auto_obstack output
;
2691 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2692 (gdb_byte
*) obstack_base (&wchar_buf
),
2693 obstack_object_size (&wchar_buf
),
2694 sizeof (gdb_wchar_t
), &output
, translit_char
);
2695 obstack_1grow (&output
, '\0');
2697 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2700 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2701 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2702 stops at the first null byte, otherwise printing proceeds (including null
2703 bytes) until either print_max or LEN characters have been printed,
2704 whichever is smaller. ENCODING is the name of the string's
2705 encoding. It can be NULL, in which case the target encoding is
2709 val_print_string (struct type
*elttype
, const char *encoding
,
2710 CORE_ADDR addr
, int len
,
2711 struct ui_file
*stream
,
2712 const struct value_print_options
*options
)
2714 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2715 int err
; /* Non-zero if we got a bad read. */
2716 int found_nul
; /* Non-zero if we found the nul char. */
2717 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2719 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
; /* Dynamically growable fetch buffer. */
2720 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2721 enum bfd_endian byte_order
= type_byte_order (elttype
);
2722 int width
= TYPE_LENGTH (elttype
);
2724 /* First we need to figure out the limit on the number of characters we are
2725 going to attempt to fetch and print. This is actually pretty simple. If
2726 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2727 LEN is -1, then the limit is print_max. This is true regardless of
2728 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2729 because finding the null byte (or available memory) is what actually
2730 limits the fetch. */
2732 fetchlimit
= (len
== -1 ? options
->print_max
: std::min ((unsigned) len
,
2733 options
->print_max
));
2735 err
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2736 &buffer
, &bytes_read
);
2740 /* We now have either successfully filled the buffer to fetchlimit,
2741 or terminated early due to an error or finding a null char when
2744 /* Determine found_nul by looking at the last character read. */
2746 if (bytes_read
>= width
)
2747 found_nul
= extract_unsigned_integer (buffer
.get () + bytes_read
- width
,
2748 width
, byte_order
) == 0;
2749 if (len
== -1 && !found_nul
)
2753 /* We didn't find a NUL terminator we were looking for. Attempt
2754 to peek at the next character. If not successful, or it is not
2755 a null byte, then force ellipsis to be printed. */
2757 peekbuf
= (gdb_byte
*) alloca (width
);
2759 if (target_read_memory (addr
, peekbuf
, width
) == 0
2760 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2763 else if ((len
>= 0 && err
!= 0) || (len
> bytes_read
/ width
))
2765 /* Getting an error when we have a requested length, or fetching less
2766 than the number of characters actually requested, always make us
2771 /* If we get an error before fetching anything, don't print a string.
2772 But if we fetch something and then get an error, print the string
2773 and then the error message. */
2774 if (err
== 0 || bytes_read
> 0)
2776 LA_PRINT_STRING (stream
, elttype
, buffer
.get (), bytes_read
/ width
,
2777 encoding
, force_ellipsis
, options
);
2782 std::string str
= memory_error_message (TARGET_XFER_E_IO
, gdbarch
, addr
);
2784 fprintf_filtered (stream
, _("<error: %ps>"),
2785 styled_string (metadata_style
.style (),
2789 return (bytes_read
/ width
);
2792 /* Handle 'show print max-depth'. */
2795 show_print_max_depth (struct ui_file
*file
, int from_tty
,
2796 struct cmd_list_element
*c
, const char *value
)
2798 fprintf_filtered (file
, _("Maximum print depth is %s.\n"), value
);
2802 /* The 'set input-radix' command writes to this auxiliary variable.
2803 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2804 it is left unchanged. */
2806 static unsigned input_radix_1
= 10;
2808 /* Validate an input or output radix setting, and make sure the user
2809 knows what they really did here. Radix setting is confusing, e.g.
2810 setting the input radix to "10" never changes it! */
2813 set_input_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2815 set_input_radix_1 (from_tty
, input_radix_1
);
2819 set_input_radix_1 (int from_tty
, unsigned radix
)
2821 /* We don't currently disallow any input radix except 0 or 1, which don't
2822 make any mathematical sense. In theory, we can deal with any input
2823 radix greater than 1, even if we don't have unique digits for every
2824 value from 0 to radix-1, but in practice we lose on large radix values.
2825 We should either fix the lossage or restrict the radix range more.
2830 input_radix_1
= input_radix
;
2831 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2834 input_radix_1
= input_radix
= radix
;
2837 printf_filtered (_("Input radix now set to "
2838 "decimal %u, hex %x, octal %o.\n"),
2839 radix
, radix
, radix
);
2843 /* The 'set output-radix' command writes to this auxiliary variable.
2844 If the requested radix is valid, OUTPUT_RADIX is updated,
2845 otherwise, it is left unchanged. */
2847 static unsigned output_radix_1
= 10;
2850 set_output_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2852 set_output_radix_1 (from_tty
, output_radix_1
);
2856 set_output_radix_1 (int from_tty
, unsigned radix
)
2858 /* Validate the radix and disallow ones that we aren't prepared to
2859 handle correctly, leaving the radix unchanged. */
2863 user_print_options
.output_format
= 'x'; /* hex */
2866 user_print_options
.output_format
= 0; /* decimal */
2869 user_print_options
.output_format
= 'o'; /* octal */
2872 output_radix_1
= output_radix
;
2873 error (_("Unsupported output radix ``decimal %u''; "
2874 "output radix unchanged."),
2877 output_radix_1
= output_radix
= radix
;
2880 printf_filtered (_("Output radix now set to "
2881 "decimal %u, hex %x, octal %o.\n"),
2882 radix
, radix
, radix
);
2886 /* Set both the input and output radix at once. Try to set the output radix
2887 first, since it has the most restrictive range. An radix that is valid as
2888 an output radix is also valid as an input radix.
2890 It may be useful to have an unusual input radix. If the user wishes to
2891 set an input radix that is not valid as an output radix, he needs to use
2892 the 'set input-radix' command. */
2895 set_radix (const char *arg
, int from_tty
)
2899 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2900 set_output_radix_1 (0, radix
);
2901 set_input_radix_1 (0, radix
);
2904 printf_filtered (_("Input and output radices now set to "
2905 "decimal %u, hex %x, octal %o.\n"),
2906 radix
, radix
, radix
);
2910 /* Show both the input and output radices. */
2913 show_radix (const char *arg
, int from_tty
)
2917 if (input_radix
== output_radix
)
2919 printf_filtered (_("Input and output radices set to "
2920 "decimal %u, hex %x, octal %o.\n"),
2921 input_radix
, input_radix
, input_radix
);
2925 printf_filtered (_("Input radix set to decimal "
2926 "%u, hex %x, octal %o.\n"),
2927 input_radix
, input_radix
, input_radix
);
2928 printf_filtered (_("Output radix set to decimal "
2929 "%u, hex %x, octal %o.\n"),
2930 output_radix
, output_radix
, output_radix
);
2936 /* Controls printing of vtbl's. */
2938 show_vtblprint (struct ui_file
*file
, int from_tty
,
2939 struct cmd_list_element
*c
, const char *value
)
2941 fprintf_filtered (file
, _("\
2942 Printing of C++ virtual function tables is %s.\n"),
2946 /* Controls looking up an object's derived type using what we find in
2949 show_objectprint (struct ui_file
*file
, int from_tty
,
2950 struct cmd_list_element
*c
,
2953 fprintf_filtered (file
, _("\
2954 Printing of object's derived type based on vtable info is %s.\n"),
2959 show_static_field_print (struct ui_file
*file
, int from_tty
,
2960 struct cmd_list_element
*c
,
2963 fprintf_filtered (file
,
2964 _("Printing of C++ static members is %s.\n"),
2970 /* A couple typedefs to make writing the options a bit more
2972 using boolean_option_def
2973 = gdb::option::boolean_option_def
<value_print_options
>;
2974 using uinteger_option_def
2975 = gdb::option::uinteger_option_def
<value_print_options
>;
2976 using zuinteger_unlimited_option_def
2977 = gdb::option::zuinteger_unlimited_option_def
<value_print_options
>;
2979 /* Definitions of options for the "print" and "compile print"
2981 static const gdb::option::option_def value_print_option_defs
[] = {
2983 boolean_option_def
{
2985 [] (value_print_options
*opt
) { return &opt
->addressprint
; },
2986 show_addressprint
, /* show_cmd_cb */
2987 N_("Set printing of addresses."),
2988 N_("Show printing of addresses."),
2989 NULL
, /* help_doc */
2992 boolean_option_def
{
2994 [] (value_print_options
*opt
) { return &opt
->prettyformat_arrays
; },
2995 show_prettyformat_arrays
, /* show_cmd_cb */
2996 N_("Set pretty formatting of arrays."),
2997 N_("Show pretty formatting of arrays."),
2998 NULL
, /* help_doc */
3001 boolean_option_def
{
3003 [] (value_print_options
*opt
) { return &opt
->print_array_indexes
; },
3004 show_print_array_indexes
, /* show_cmd_cb */
3005 N_("Set printing of array indexes."),
3006 N_("Show printing of array indexes."),
3007 NULL
, /* help_doc */
3010 uinteger_option_def
{
3012 [] (value_print_options
*opt
) { return &opt
->print_max
; },
3013 show_print_max
, /* show_cmd_cb */
3014 N_("Set limit on string chars or array elements to print."),
3015 N_("Show limit on string chars or array elements to print."),
3016 N_("\"unlimited\" causes there to be no limit."),
3019 zuinteger_unlimited_option_def
{
3021 [] (value_print_options
*opt
) { return &opt
->max_depth
; },
3022 show_print_max_depth
, /* show_cmd_cb */
3023 N_("Set maximum print depth for nested structures, unions and arrays."),
3024 N_("Show maximum print depth for nested structures, unions, and arrays."),
3025 N_("When structures, unions, or arrays are nested beyond this depth then they\n\
3026 will be replaced with either '{...}' or '(...)' depending on the language.\n\
3027 Use \"unlimited\" to print the complete structure.")
3030 boolean_option_def
{
3032 [] (value_print_options
*opt
) { return &opt
->stop_print_at_null
; },
3033 show_stop_print_at_null
, /* show_cmd_cb */
3034 N_("Set printing of char arrays to stop at first null char."),
3035 N_("Show printing of char arrays to stop at first null char."),
3036 NULL
, /* help_doc */
3039 boolean_option_def
{
3041 [] (value_print_options
*opt
) { return &opt
->objectprint
; },
3042 show_objectprint
, /* show_cmd_cb */
3043 _("Set printing of C++ virtual function tables."),
3044 _("Show printing of C++ virtual function tables."),
3045 NULL
, /* help_doc */
3048 boolean_option_def
{
3050 [] (value_print_options
*opt
) { return &opt
->prettyformat_structs
; },
3051 show_prettyformat_structs
, /* show_cmd_cb */
3052 N_("Set pretty formatting of structures."),
3053 N_("Show pretty formatting of structures."),
3054 NULL
, /* help_doc */
3057 boolean_option_def
{
3059 [] (value_print_options
*opt
) { return &opt
->raw
; },
3060 NULL
, /* show_cmd_cb */
3061 N_("Set whether to print values in raw form."),
3062 N_("Show whether to print values in raw form."),
3063 N_("If set, values are printed in raw form, bypassing any\n\
3064 pretty-printers for that value.")
3067 uinteger_option_def
{
3069 [] (value_print_options
*opt
) { return &opt
->repeat_count_threshold
; },
3070 show_repeat_count_threshold
, /* show_cmd_cb */
3071 N_("Set threshold for repeated print elements."),
3072 N_("Show threshold for repeated print elements."),
3073 N_("\"unlimited\" causes all elements to be individually printed."),
3076 boolean_option_def
{
3078 [] (value_print_options
*opt
) { return &opt
->static_field_print
; },
3079 show_static_field_print
, /* show_cmd_cb */
3080 N_("Set printing of C++ static members."),
3081 N_("Show printing of C++ static members."),
3082 NULL
, /* help_doc */
3085 boolean_option_def
{
3087 [] (value_print_options
*opt
) { return &opt
->symbol_print
; },
3088 show_symbol_print
, /* show_cmd_cb */
3089 N_("Set printing of symbol names when printing pointers."),
3090 N_("Show printing of symbol names when printing pointers."),
3091 NULL
, /* help_doc */
3094 boolean_option_def
{
3096 [] (value_print_options
*opt
) { return &opt
->unionprint
; },
3097 show_unionprint
, /* show_cmd_cb */
3098 N_("Set printing of unions interior to structures."),
3099 N_("Show printing of unions interior to structures."),
3100 NULL
, /* help_doc */
3103 boolean_option_def
{
3105 [] (value_print_options
*opt
) { return &opt
->vtblprint
; },
3106 show_vtblprint
, /* show_cmd_cb */
3107 N_("Set printing of C++ virtual function tables."),
3108 N_("Show printing of C++ virtual function tables."),
3109 NULL
, /* help_doc */
3113 /* See valprint.h. */
3115 gdb::option::option_def_group
3116 make_value_print_options_def_group (value_print_options
*opts
)
3118 return {{value_print_option_defs
}, opts
};
3121 void _initialize_valprint ();
3123 _initialize_valprint ()
3125 cmd_list_element
*cmd
;
3127 add_basic_prefix_cmd ("print", no_class
,
3128 _("Generic command for setting how things print."),
3129 &setprintlist
, "set print ", 0, &setlist
);
3130 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
3131 /* Prefer set print to set prompt. */
3132 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
3134 add_show_prefix_cmd ("print", no_class
,
3135 _("Generic command for showing print settings."),
3136 &showprintlist
, "show print ", 0, &showlist
);
3137 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
3138 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
3140 cmd
= add_basic_prefix_cmd ("raw", no_class
,
3142 Generic command for setting what things to print in \"raw\" mode."),
3143 &setprintrawlist
, "set print raw ", 0,
3145 deprecate_cmd (cmd
, nullptr);
3147 cmd
= add_show_prefix_cmd ("raw", no_class
,
3148 _("Generic command for showing \"print raw\" settings."),
3149 &showprintrawlist
, "show print raw ", 0,
3151 deprecate_cmd (cmd
, nullptr);
3153 gdb::option::add_setshow_cmds_for_options
3154 (class_support
, &user_print_options
, value_print_option_defs
,
3155 &setprintlist
, &showprintlist
);
3157 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
3159 Set default input radix for entering numbers."), _("\
3160 Show default input radix for entering numbers."), NULL
,
3163 &setlist
, &showlist
);
3165 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
3167 Set default output radix for printing of values."), _("\
3168 Show default output radix for printing of values."), NULL
,
3171 &setlist
, &showlist
);
3173 /* The "set radix" and "show radix" commands are special in that
3174 they are like normal set and show commands but allow two normally
3175 independent variables to be either set or shown with a single
3176 command. So the usual deprecated_add_set_cmd() and [deleted]
3177 add_show_from_set() commands aren't really appropriate. */
3178 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3179 longer true - show can display anything. */
3180 add_cmd ("radix", class_support
, set_radix
, _("\
3181 Set default input and output number radices.\n\
3182 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
3183 Without an argument, sets both radices back to the default value of 10."),
3185 add_cmd ("radix", class_support
, show_radix
, _("\
3186 Show the default input and output number radices.\n\
3187 Use 'show input-radix' or 'show output-radix' to independently show each."),