1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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_val_print helper for TYPE_CODE_FIXED_POINT. */
800 generic_val_print_fixed_point (struct value
*val
, struct ui_file
*stream
,
801 const struct value_print_options
*options
)
804 value_print_scalar_formatted (val
, options
, 0, stream
);
807 struct type
*type
= value_type (val
);
809 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
812 f
.read_fixed_point (gdb::make_array_view (valaddr
, TYPE_LENGTH (type
)),
813 type_byte_order (type
), type
->is_unsigned (),
814 type
->fixed_point_scaling_factor ());
816 const char *fmt
= TYPE_LENGTH (type
) < 4 ? "%.11Fg" : "%.17Fg";
817 std::string str
= gmp_string_printf (fmt
, f
.val
);
818 fprintf_filtered (stream
, "%s", str
.c_str ());
822 /* generic_value_print helper for TYPE_CODE_COMPLEX. */
825 generic_value_print_complex (struct value
*val
, struct ui_file
*stream
,
826 const struct value_print_options
*options
,
827 const struct generic_val_print_decorations
830 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
832 struct value
*real_part
= value_real_part (val
);
833 value_print_scalar_formatted (real_part
, options
, 0, stream
);
834 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
836 struct value
*imag_part
= value_imaginary_part (val
);
837 value_print_scalar_formatted (imag_part
, options
, 0, stream
);
838 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
841 /* generic_value_print helper for TYPE_CODE_MEMBERPTR. */
844 generic_value_print_memberptr
845 (struct value
*val
, struct ui_file
*stream
,
847 const struct value_print_options
*options
,
848 const struct generic_val_print_decorations
*decorations
)
850 if (!options
->format
)
852 /* Member pointers are essentially specific to C++, and so if we
853 encounter one, we should print it according to C++ rules. */
854 struct type
*type
= check_typedef (value_type (val
));
855 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
856 cp_print_class_member (valaddr
, type
, stream
, "&");
859 generic_value_print (val
, stream
, recurse
, options
, decorations
);
862 /* See valprint.h. */
865 generic_value_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
866 const struct value_print_options
*options
,
867 const struct generic_val_print_decorations
*decorations
)
869 struct type
*type
= value_type (val
);
871 type
= check_typedef (type
);
873 if (is_fixed_point_type (type
))
874 type
= type
->fixed_point_type_base_type ();
876 switch (type
->code ())
878 case TYPE_CODE_ARRAY
:
879 generic_val_print_array (val
, stream
, recurse
, options
, decorations
);
882 case TYPE_CODE_MEMBERPTR
:
883 generic_value_print_memberptr (val
, stream
, recurse
, options
,
888 generic_value_print_ptr (val
, stream
, options
);
892 case TYPE_CODE_RVALUE_REF
:
893 generic_val_print_ref (type
, 0, stream
, recurse
,
899 value_print_scalar_formatted (val
, options
, 0, stream
);
901 generic_val_print_enum (type
, 0, stream
, val
, options
);
904 case TYPE_CODE_FLAGS
:
906 value_print_scalar_formatted (val
, options
, 0, stream
);
908 val_print_type_code_flags (type
, val
, 0, stream
);
912 case TYPE_CODE_METHOD
:
914 value_print_scalar_formatted (val
, options
, 0, stream
);
916 generic_val_print_func (type
, 0, value_address (val
), stream
,
921 generic_value_print_bool (val
, stream
, options
, decorations
);
924 case TYPE_CODE_RANGE
:
926 generic_value_print_int (val
, stream
, options
);
930 generic_value_print_char (val
, stream
, options
);
934 case TYPE_CODE_DECFLOAT
:
936 value_print_scalar_formatted (val
, options
, 0, stream
);
938 generic_val_print_float (type
, stream
, val
, options
);
941 case TYPE_CODE_FIXED_POINT
:
942 generic_val_print_fixed_point (val
, stream
, options
);
946 fputs_filtered (decorations
->void_name
, stream
);
949 case TYPE_CODE_ERROR
:
950 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
953 case TYPE_CODE_UNDEF
:
954 /* This happens (without TYPE_STUB set) on systems which don't use
955 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
956 and no complete type for struct foo in that file. */
957 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
960 case TYPE_CODE_COMPLEX
:
961 generic_value_print_complex (val
, stream
, options
, decorations
);
964 case TYPE_CODE_METHODPTR
:
965 cplus_print_method_ptr (value_contents_for_printing (val
), type
,
969 case TYPE_CODE_UNION
:
970 case TYPE_CODE_STRUCT
:
972 error (_("Unhandled type code %d in symbol table."),
977 /* Helper function for val_print and common_val_print that does the
978 work. Arguments are as to val_print, but FULL_VALUE, if given, is
979 the value to be printed. */
982 do_val_print (struct value
*value
, struct ui_file
*stream
, int recurse
,
983 const struct value_print_options
*options
,
984 const struct language_defn
*language
)
987 struct value_print_options local_opts
= *options
;
988 struct type
*type
= value_type (value
);
989 struct type
*real_type
= check_typedef (type
);
991 if (local_opts
.prettyformat
== Val_prettyformat_default
)
992 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
993 ? Val_prettyformat
: Val_no_prettyformat
);
997 /* Ensure that the type is complete and not just a stub. If the type is
998 only a stub and we can't find and substitute its complete type, then
999 print appropriate string and return. */
1001 if (real_type
->is_stub ())
1003 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
1007 if (!valprint_check_validity (stream
, real_type
, 0, value
))
1012 ret
= apply_ext_lang_val_pretty_printer (value
, stream
, recurse
, options
,
1018 /* Handle summary mode. If the value is a scalar, print it;
1019 otherwise, print an ellipsis. */
1020 if (options
->summary
&& !val_print_scalar_type_p (type
))
1022 fprintf_filtered (stream
, "...");
1026 /* If this value is too deep then don't print it. */
1027 if (!val_print_scalar_or_string_type_p (type
, language
)
1028 && val_print_check_max_depth (stream
, recurse
, options
, language
))
1033 language
->value_print_inner (value
, stream
, recurse
, &local_opts
);
1035 catch (const gdb_exception_error
&except
)
1037 fprintf_styled (stream
, metadata_style
.style (),
1038 _("<error reading variable>"));
1042 /* See valprint.h. */
1045 val_print_check_max_depth (struct ui_file
*stream
, int recurse
,
1046 const struct value_print_options
*options
,
1047 const struct language_defn
*language
)
1049 if (options
->max_depth
> -1 && recurse
>= options
->max_depth
)
1051 gdb_assert (language
->struct_too_deep_ellipsis () != NULL
);
1052 fputs_filtered (language
->struct_too_deep_ellipsis (), stream
);
1059 /* Check whether the value VAL is printable. Return 1 if it is;
1060 return 0 and print an appropriate error message to STREAM according to
1061 OPTIONS if it is not. */
1064 value_check_printable (struct value
*val
, struct ui_file
*stream
,
1065 const struct value_print_options
*options
)
1069 fprintf_styled (stream
, metadata_style
.style (),
1070 _("<address of value unknown>"));
1074 if (value_entirely_optimized_out (val
))
1076 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1077 fprintf_filtered (stream
, "...");
1079 val_print_optimized_out (val
, stream
);
1083 if (value_entirely_unavailable (val
))
1085 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1086 fprintf_filtered (stream
, "...");
1088 val_print_unavailable (stream
);
1092 if (value_type (val
)->code () == TYPE_CODE_INTERNAL_FUNCTION
)
1094 fprintf_styled (stream
, metadata_style
.style (),
1095 _("<internal function %s>"),
1096 value_internal_function_name (val
));
1100 if (type_not_associated (value_type (val
)))
1102 val_print_not_associated (stream
);
1106 if (type_not_allocated (value_type (val
)))
1108 val_print_not_allocated (stream
);
1115 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
1118 This is a preferable interface to val_print, above, because it uses
1119 GDB's value mechanism. */
1122 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
1123 const struct value_print_options
*options
,
1124 const struct language_defn
*language
)
1126 if (language
->la_language
== language_ada
)
1127 /* The value might have a dynamic type, which would cause trouble
1128 below when trying to extract the value contents (since the value
1129 size is determined from the type size which is unknown). So
1130 get a fixed representation of our value. */
1131 val
= ada_to_fixed_value (val
);
1133 if (value_lazy (val
))
1134 value_fetch_lazy (val
);
1136 do_val_print (val
, stream
, recurse
, options
, language
);
1139 /* See valprint.h. */
1142 common_val_print_checked (struct value
*val
, struct ui_file
*stream
,
1144 const struct value_print_options
*options
,
1145 const struct language_defn
*language
)
1147 if (!value_check_printable (val
, stream
, options
))
1149 common_val_print (val
, stream
, recurse
, options
, language
);
1152 /* Print on stream STREAM the value VAL according to OPTIONS. The value
1153 is printed using the current_language syntax. */
1156 value_print (struct value
*val
, struct ui_file
*stream
,
1157 const struct value_print_options
*options
)
1159 scoped_value_mark free_values
;
1161 if (!value_check_printable (val
, stream
, options
))
1167 = apply_ext_lang_val_pretty_printer (val
, stream
, 0, options
,
1174 current_language
->value_print (val
, stream
, options
);
1178 val_print_type_code_flags (struct type
*type
, struct value
*original_value
,
1179 int embedded_offset
, struct ui_file
*stream
)
1181 const gdb_byte
*valaddr
= (value_contents_for_printing (original_value
)
1183 ULONGEST val
= unpack_long (type
, valaddr
);
1184 int field
, nfields
= type
->num_fields ();
1185 struct gdbarch
*gdbarch
= get_type_arch (type
);
1186 struct type
*bool_type
= builtin_type (gdbarch
)->builtin_bool
;
1188 fputs_filtered ("[", stream
);
1189 for (field
= 0; field
< nfields
; field
++)
1191 if (TYPE_FIELD_NAME (type
, field
)[0] != '\0')
1193 struct type
*field_type
= type
->field (field
).type ();
1195 if (field_type
== bool_type
1196 /* We require boolean types here to be one bit wide. This is a
1197 problematic place to notify the user of an internal error
1198 though. Instead just fall through and print the field as an
1200 && TYPE_FIELD_BITSIZE (type
, field
) == 1)
1202 if (val
& ((ULONGEST
)1 << TYPE_FIELD_BITPOS (type
, field
)))
1205 styled_string (variable_name_style
.style (),
1206 TYPE_FIELD_NAME (type
, field
)));
1210 unsigned field_len
= TYPE_FIELD_BITSIZE (type
, field
);
1212 = val
>> (TYPE_FIELD_BITPOS (type
, field
) - field_len
+ 1);
1214 if (field_len
< sizeof (ULONGEST
) * TARGET_CHAR_BIT
)
1215 field_val
&= ((ULONGEST
) 1 << field_len
) - 1;
1216 fprintf_filtered (stream
, " %ps=",
1217 styled_string (variable_name_style
.style (),
1218 TYPE_FIELD_NAME (type
, field
)));
1219 if (field_type
->code () == TYPE_CODE_ENUM
)
1220 generic_val_print_enum_1 (field_type
, field_val
, stream
);
1222 print_longest (stream
, 'd', 0, field_val
);
1226 fputs_filtered (" ]", stream
);
1229 /* See valprint.h. */
1232 value_print_scalar_formatted (struct value
*val
,
1233 const struct value_print_options
*options
,
1235 struct ui_file
*stream
)
1237 struct type
*type
= check_typedef (value_type (val
));
1239 gdb_assert (val
!= NULL
);
1241 /* If we get here with a string format, try again without it. Go
1242 all the way back to the language printers, which may call us
1244 if (options
->format
== 's')
1246 struct value_print_options opts
= *options
;
1249 common_val_print (val
, stream
, 0, &opts
, current_language
);
1253 /* value_contents_for_printing fetches all VAL's contents. They are
1254 needed to check whether VAL is optimized-out or unavailable
1256 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1258 /* A scalar object that does not have all bits available can't be
1259 printed, because all bits contribute to its representation. */
1260 if (value_bits_any_optimized_out (val
, 0,
1261 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1262 val_print_optimized_out (val
, stream
);
1263 else if (!value_bytes_available (val
, 0, TYPE_LENGTH (type
)))
1264 val_print_unavailable (stream
);
1266 print_scalar_formatted (valaddr
, type
, options
, size
, stream
);
1269 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1270 The raison d'etre of this function is to consolidate printing of
1271 LONG_LONG's into this one function. The format chars b,h,w,g are
1272 from print_scalar_formatted(). Numbers are printed using C
1275 USE_C_FORMAT means to use C format in all cases. Without it,
1276 'o' and 'x' format do not include the standard C radix prefix
1279 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1280 and was intended to request formatting according to the current
1281 language and would be used for most integers that GDB prints. The
1282 exceptional cases were things like protocols where the format of
1283 the integer is a protocol thing, not a user-visible thing). The
1284 parameter remains to preserve the information of what things might
1285 be printed with language-specific format, should we ever resurrect
1289 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1297 val
= int_string (val_long
, 10, 1, 0, 1); break;
1299 val
= int_string (val_long
, 10, 0, 0, 1); break;
1301 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1303 val
= int_string (val_long
, 16, 0, 2, 1); break;
1305 val
= int_string (val_long
, 16, 0, 4, 1); break;
1307 val
= int_string (val_long
, 16, 0, 8, 1); break;
1309 val
= int_string (val_long
, 16, 0, 16, 1); break;
1312 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1314 internal_error (__FILE__
, __LINE__
,
1315 _("failed internal consistency check"));
1317 fputs_filtered (val
, stream
);
1320 /* This used to be a macro, but I don't think it is called often enough
1321 to merit such treatment. */
1322 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1323 arguments to a function, number in a value history, register number, etc.)
1324 where the value must not be larger than can fit in an int. */
1327 longest_to_int (LONGEST arg
)
1329 /* Let the compiler do the work. */
1330 int rtnval
= (int) arg
;
1332 /* Check for overflows or underflows. */
1333 if (sizeof (LONGEST
) > sizeof (int))
1337 error (_("Value out of range."));
1343 /* Print a floating point value of floating-point type TYPE,
1344 pointed to in GDB by VALADDR, on STREAM. */
1347 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1348 struct ui_file
*stream
)
1350 std::string str
= target_float_to_string (valaddr
, type
);
1351 fputs_filtered (str
.c_str (), stream
);
1355 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1356 unsigned len
, enum bfd_endian byte_order
, bool zero_pad
)
1361 bool seen_a_one
= false;
1363 /* Declared "int" so it will be signed.
1364 This ensures that right shift will shift in zeros. */
1366 const int mask
= 0x080;
1368 if (byte_order
== BFD_ENDIAN_BIG
)
1374 /* Every byte has 8 binary characters; peel off
1375 and print from the MSB end. */
1377 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1379 if (*p
& (mask
>> i
))
1384 if (zero_pad
|| seen_a_one
|| b
== '1')
1385 fputc_filtered (b
, stream
);
1393 for (p
= valaddr
+ len
- 1;
1397 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1399 if (*p
& (mask
>> i
))
1404 if (zero_pad
|| seen_a_one
|| b
== '1')
1405 fputc_filtered (b
, stream
);
1412 /* When not zero-padding, ensure that something is printed when the
1414 if (!zero_pad
&& !seen_a_one
)
1415 fputc_filtered ('0', stream
);
1418 /* A helper for print_octal_chars that emits a single octal digit,
1419 optionally suppressing it if is zero and updating SEEN_A_ONE. */
1422 emit_octal_digit (struct ui_file
*stream
, bool *seen_a_one
, int digit
)
1424 if (*seen_a_one
|| digit
!= 0)
1425 fprintf_filtered (stream
, "%o", digit
);
1430 /* VALADDR points to an integer of LEN bytes.
1431 Print it in octal on stream or format it in buf. */
1434 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1435 unsigned len
, enum bfd_endian byte_order
)
1438 unsigned char octa1
, octa2
, octa3
, carry
;
1441 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1442 * the extra bits, which cycle every three bytes:
1444 * Byte side: 0 1 2 3
1446 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1448 * Octal side: 0 1 carry 3 4 carry ...
1450 * Cycle number: 0 1 2
1452 * But of course we are printing from the high side, so we have to
1453 * figure out where in the cycle we are so that we end up with no
1454 * left over bits at the end.
1456 #define BITS_IN_OCTAL 3
1457 #define HIGH_ZERO 0340
1458 #define LOW_ZERO 0034
1459 #define CARRY_ZERO 0003
1460 static_assert (HIGH_ZERO
+ LOW_ZERO
+ CARRY_ZERO
== 0xff,
1461 "cycle zero constants are wrong");
1462 #define HIGH_ONE 0200
1463 #define MID_ONE 0160
1464 #define LOW_ONE 0016
1465 #define CARRY_ONE 0001
1466 static_assert (HIGH_ONE
+ MID_ONE
+ LOW_ONE
+ CARRY_ONE
== 0xff,
1467 "cycle one constants are wrong");
1468 #define HIGH_TWO 0300
1469 #define MID_TWO 0070
1470 #define LOW_TWO 0007
1471 static_assert (HIGH_TWO
+ MID_TWO
+ LOW_TWO
== 0xff,
1472 "cycle two constants are wrong");
1474 /* For 32 we start in cycle 2, with two bits and one bit carry;
1475 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1477 cycle
= (len
* HOST_CHAR_BIT
) % BITS_IN_OCTAL
;
1480 fputs_filtered ("0", stream
);
1481 bool seen_a_one
= false;
1482 if (byte_order
== BFD_ENDIAN_BIG
)
1491 /* No carry in, carry out two bits. */
1493 octa1
= (HIGH_ZERO
& *p
) >> 5;
1494 octa2
= (LOW_ZERO
& *p
) >> 2;
1495 carry
= (CARRY_ZERO
& *p
);
1496 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1497 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1501 /* Carry in two bits, carry out one bit. */
1503 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1504 octa2
= (MID_ONE
& *p
) >> 4;
1505 octa3
= (LOW_ONE
& *p
) >> 1;
1506 carry
= (CARRY_ONE
& *p
);
1507 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1508 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1509 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1513 /* Carry in one bit, no carry out. */
1515 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1516 octa2
= (MID_TWO
& *p
) >> 3;
1517 octa3
= (LOW_TWO
& *p
);
1519 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1520 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1521 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1525 error (_("Internal error in octal conversion;"));
1529 cycle
= cycle
% BITS_IN_OCTAL
;
1534 for (p
= valaddr
+ len
- 1;
1541 /* Carry out, no carry in */
1543 octa1
= (HIGH_ZERO
& *p
) >> 5;
1544 octa2
= (LOW_ZERO
& *p
) >> 2;
1545 carry
= (CARRY_ZERO
& *p
);
1546 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1547 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1551 /* Carry in, carry out */
1553 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1554 octa2
= (MID_ONE
& *p
) >> 4;
1555 octa3
= (LOW_ONE
& *p
) >> 1;
1556 carry
= (CARRY_ONE
& *p
);
1557 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1558 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1559 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1563 /* Carry in, no carry out */
1565 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1566 octa2
= (MID_TWO
& *p
) >> 3;
1567 octa3
= (LOW_TWO
& *p
);
1569 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1570 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1571 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1575 error (_("Internal error in octal conversion;"));
1579 cycle
= cycle
% BITS_IN_OCTAL
;
1585 /* Possibly negate the integer represented by BYTES. It contains LEN
1586 bytes in the specified byte order. If the integer is negative,
1587 copy it into OUT_VEC, negate it, and return true. Otherwise, do
1588 nothing and return false. */
1591 maybe_negate_by_bytes (const gdb_byte
*bytes
, unsigned len
,
1592 enum bfd_endian byte_order
,
1593 gdb::byte_vector
*out_vec
)
1596 gdb_assert (len
> 0);
1597 if (byte_order
== BFD_ENDIAN_BIG
)
1598 sign_byte
= bytes
[0];
1600 sign_byte
= bytes
[len
- 1];
1601 if ((sign_byte
& 0x80) == 0)
1604 out_vec
->resize (len
);
1606 /* Compute -x == 1 + ~x. */
1607 if (byte_order
== BFD_ENDIAN_LITTLE
)
1610 for (unsigned i
= 0; i
< len
; ++i
)
1612 unsigned tem
= (0xff & ~bytes
[i
]) + carry
;
1613 (*out_vec
)[i
] = tem
& 0xff;
1620 for (unsigned i
= len
; i
> 0; --i
)
1622 unsigned tem
= (0xff & ~bytes
[i
- 1]) + carry
;
1623 (*out_vec
)[i
- 1] = tem
& 0xff;
1631 /* VALADDR points to an integer of LEN bytes.
1632 Print it in decimal on stream or format it in buf. */
1635 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1636 unsigned len
, bool is_signed
,
1637 enum bfd_endian byte_order
)
1640 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1641 #define CARRY_LEFT( x ) ((x) % TEN)
1642 #define SHIFT( x ) ((x) << 4)
1643 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1644 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1649 int i
, j
, decimal_digits
;
1653 gdb::byte_vector negated_bytes
;
1655 && maybe_negate_by_bytes (valaddr
, len
, byte_order
, &negated_bytes
))
1657 fputs_filtered ("-", stream
);
1658 valaddr
= negated_bytes
.data ();
1661 /* Base-ten number is less than twice as many digits
1662 as the base 16 number, which is 2 digits per byte. */
1664 decimal_len
= len
* 2 * 2;
1665 std::vector
<unsigned char> digits (decimal_len
, 0);
1667 /* Ok, we have an unknown number of bytes of data to be printed in
1670 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1671 * decimalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1672 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1674 * The trick is that "digits" holds a base-10 number, but sometimes
1675 * the individual digits are > 10.
1677 * Outer loop is per nibble (hex digit) of input, from MSD end to
1680 decimal_digits
= 0; /* Number of decimal digits so far */
1681 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1683 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1686 * Multiply current base-ten number by 16 in place.
1687 * Each digit was between 0 and 9, now is between
1690 for (j
= 0; j
< decimal_digits
; j
++)
1692 digits
[j
] = SHIFT (digits
[j
]);
1695 /* Take the next nibble off the input and add it to what
1696 * we've got in the LSB position. Bottom 'digit' is now
1697 * between 0 and 159.
1699 * "flip" is used to run this loop twice for each byte.
1703 /* Take top nibble. */
1705 digits
[0] += HIGH_NIBBLE (*p
);
1710 /* Take low nibble and bump our pointer "p". */
1712 digits
[0] += LOW_NIBBLE (*p
);
1713 if (byte_order
== BFD_ENDIAN_BIG
)
1720 /* Re-decimalize. We have to do this often enough
1721 * that we don't overflow, but once per nibble is
1722 * overkill. Easier this way, though. Note that the
1723 * carry is often larger than 10 (e.g. max initial
1724 * carry out of lowest nibble is 15, could bubble all
1725 * the way up greater than 10). So we have to do
1726 * the carrying beyond the last current digit.
1729 for (j
= 0; j
< decimal_len
- 1; j
++)
1733 /* "/" won't handle an unsigned char with
1734 * a value that if signed would be negative.
1735 * So extend to longword int via "dummy".
1738 carry
= CARRY_OUT (dummy
);
1739 digits
[j
] = CARRY_LEFT (dummy
);
1741 if (j
>= decimal_digits
&& carry
== 0)
1744 * All higher digits are 0 and we
1745 * no longer have a carry.
1747 * Note: "j" is 0-based, "decimal_digits" is
1750 decimal_digits
= j
+ 1;
1756 /* Ok, now "digits" is the decimal representation, with
1757 the "decimal_digits" actual digits. Print! */
1759 for (i
= decimal_digits
- 1; i
> 0 && digits
[i
] == 0; --i
)
1764 fprintf_filtered (stream
, "%1d", digits
[i
]);
1768 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1771 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1772 unsigned len
, enum bfd_endian byte_order
,
1777 fputs_filtered ("0x", stream
);
1778 if (byte_order
== BFD_ENDIAN_BIG
)
1784 /* Strip leading 0 bytes, but be sure to leave at least a
1785 single byte at the end. */
1786 for (; p
< valaddr
+ len
- 1 && !*p
; ++p
)
1790 const gdb_byte
*first
= p
;
1795 /* When not zero-padding, use a different format for the
1796 very first byte printed. */
1797 if (!zero_pad
&& p
== first
)
1798 fprintf_filtered (stream
, "%x", *p
);
1800 fprintf_filtered (stream
, "%02x", *p
);
1805 p
= valaddr
+ len
- 1;
1809 /* Strip leading 0 bytes, but be sure to leave at least a
1810 single byte at the end. */
1811 for (; p
>= valaddr
+ 1 && !*p
; --p
)
1815 const gdb_byte
*first
= p
;
1820 /* When not zero-padding, use a different format for the
1821 very first byte printed. */
1822 if (!zero_pad
&& p
== first
)
1823 fprintf_filtered (stream
, "%x", *p
);
1825 fprintf_filtered (stream
, "%02x", *p
);
1830 /* Print function pointer with inferior address ADDRESS onto stdio
1834 print_function_pointer_address (const struct value_print_options
*options
,
1835 struct gdbarch
*gdbarch
,
1837 struct ui_file
*stream
)
1840 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
1841 current_top_target ());
1843 /* If the function pointer is represented by a description, print
1844 the address of the description. */
1845 if (options
->addressprint
&& func_addr
!= address
)
1847 fputs_filtered ("@", stream
);
1848 fputs_filtered (paddress (gdbarch
, address
), stream
);
1849 fputs_filtered (": ", stream
);
1851 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
1855 /* Print on STREAM using the given OPTIONS the index for the element
1856 at INDEX of an array whose index type is INDEX_TYPE. */
1859 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1860 struct ui_file
*stream
,
1861 const struct value_print_options
*options
)
1863 if (!options
->print_array_indexes
)
1866 current_language
->print_array_index (index_type
, index
, stream
, options
);
1869 /* See valprint.h. */
1872 value_print_array_elements (struct value
*val
, struct ui_file
*stream
,
1874 const struct value_print_options
*options
,
1877 unsigned int things_printed
= 0;
1879 struct type
*elttype
, *index_type
;
1881 /* Position of the array element we are examining to see
1882 whether it is repeated. */
1884 /* Number of repetitions we have detected so far. */
1886 LONGEST low_bound
, high_bound
;
1888 struct type
*type
= check_typedef (value_type (val
));
1890 elttype
= TYPE_TARGET_TYPE (type
);
1891 eltlen
= type_length_units (check_typedef (elttype
));
1892 index_type
= type
->index_type ();
1893 if (index_type
->code () == TYPE_CODE_RANGE
)
1894 index_type
= TYPE_TARGET_TYPE (index_type
);
1896 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1898 /* The array length should normally be HIGH_BOUND - LOW_BOUND +
1899 1. But we have to be a little extra careful, because some
1900 languages such as Ada allow LOW_BOUND to be greater than
1901 HIGH_BOUND for empty arrays. In that situation, the array
1902 length is just zero, not negative! */
1903 if (low_bound
> high_bound
)
1906 len
= high_bound
- low_bound
+ 1;
1910 warning (_("unable to get bounds of array, assuming null array"));
1915 annotate_array_section_begin (i
, elttype
);
1917 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1919 scoped_value_mark free_values
;
1923 if (options
->prettyformat_arrays
)
1925 fprintf_filtered (stream
, ",\n");
1926 print_spaces_filtered (2 + 2 * recurse
, stream
);
1929 fprintf_filtered (stream
, ", ");
1931 else if (options
->prettyformat_arrays
)
1933 fprintf_filtered (stream
, "\n");
1934 print_spaces_filtered (2 + 2 * recurse
, stream
);
1936 wrap_here (n_spaces (2 + 2 * recurse
));
1937 maybe_print_array_index (index_type
, i
+ low_bound
,
1942 /* Only check for reps if repeat_count_threshold is not set to
1943 UINT_MAX (unlimited). */
1944 if (options
->repeat_count_threshold
< UINT_MAX
)
1947 && value_contents_eq (val
, i
* eltlen
,
1956 struct value
*element
= value_from_component (val
, elttype
, eltlen
* i
);
1957 common_val_print (element
, stream
, recurse
+ 1, options
,
1960 if (reps
> options
->repeat_count_threshold
)
1962 annotate_elt_rep (reps
);
1963 fprintf_filtered (stream
, " %p[<repeats %u times>%p]",
1964 metadata_style
.style ().ptr (), reps
, nullptr);
1965 annotate_elt_rep_end ();
1968 things_printed
+= options
->repeat_count_threshold
;
1976 annotate_array_section_end ();
1978 fprintf_filtered (stream
, "...");
1979 if (options
->prettyformat_arrays
)
1981 fprintf_filtered (stream
, "\n");
1982 print_spaces_filtered (2 * recurse
, stream
);
1986 /* Read LEN bytes of target memory at address MEMADDR, placing the
1987 results in GDB's memory at MYADDR. Returns a count of the bytes
1988 actually read, and optionally a target_xfer_status value in the
1989 location pointed to by ERRPTR if ERRPTR is non-null. */
1991 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1992 function be eliminated. */
1995 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
1996 int len
, int *errptr
)
1998 int nread
; /* Number of bytes actually read. */
1999 int errcode
; /* Error from last read. */
2001 /* First try a complete read. */
2002 errcode
= target_read_memory (memaddr
, myaddr
, len
);
2010 /* Loop, reading one byte at a time until we get as much as we can. */
2011 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
2013 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
2015 /* If an error, the last read was unsuccessful, so adjust count. */
2028 /* Read a string from the inferior, at ADDR, with LEN characters of
2029 WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER
2030 will be set to a newly allocated buffer containing the string, and
2031 BYTES_READ will be set to the number of bytes read. Returns 0 on
2032 success, or a target_xfer_status on failure.
2034 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2035 (including eventual NULs in the middle or end of the string).
2037 If LEN is -1, stops at the first null character (not necessarily
2038 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2039 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2042 Unless an exception is thrown, BUFFER will always be allocated, even on
2043 failure. In this case, some characters might have been read before the
2044 failure happened. Check BYTES_READ to recognize this situation. */
2047 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
2048 enum bfd_endian byte_order
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
2051 int errcode
; /* Errno returned from bad reads. */
2052 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
2053 gdb_byte
*bufptr
; /* Pointer to next available byte in
2056 /* Loop until we either have all the characters, or we encounter
2057 some error, such as bumping into the end of the address space. */
2059 buffer
->reset (nullptr);
2063 /* We want fetchlimit chars, so we might as well read them all in
2065 unsigned int fetchlen
= std::min ((unsigned) len
, fetchlimit
);
2067 buffer
->reset ((gdb_byte
*) xmalloc (fetchlen
* width
));
2068 bufptr
= buffer
->get ();
2070 nfetch
= partial_memory_read (addr
, bufptr
, fetchlen
* width
, &errcode
)
2072 addr
+= nfetch
* width
;
2073 bufptr
+= nfetch
* width
;
2077 unsigned long bufsize
= 0;
2078 unsigned int chunksize
; /* Size of each fetch, in chars. */
2079 int found_nul
; /* Non-zero if we found the nul char. */
2080 gdb_byte
*limit
; /* First location past end of fetch buffer. */
2083 /* We are looking for a NUL terminator to end the fetching, so we
2084 might as well read in blocks that are large enough to be efficient,
2085 but not so large as to be slow if fetchlimit happens to be large.
2086 So we choose the minimum of 8 and fetchlimit. We used to use 200
2087 instead of 8 but 200 is way too big for remote debugging over a
2089 chunksize
= std::min (8u, fetchlimit
);
2094 nfetch
= std::min ((unsigned long) chunksize
, fetchlimit
- bufsize
);
2096 if (*buffer
== NULL
)
2097 buffer
->reset ((gdb_byte
*) xmalloc (nfetch
* width
));
2099 buffer
->reset ((gdb_byte
*) xrealloc (buffer
->release (),
2100 (nfetch
+ bufsize
) * width
));
2102 bufptr
= buffer
->get () + bufsize
* width
;
2105 /* Read as much as we can. */
2106 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
2109 /* Scan this chunk for the null character that terminates the string
2110 to print. If found, we don't need to fetch any more. Note
2111 that bufptr is explicitly left pointing at the next character
2112 after the null character, or at the next character after the end
2115 limit
= bufptr
+ nfetch
* width
;
2116 while (bufptr
< limit
)
2120 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
2125 /* We don't care about any error which happened after
2126 the NUL terminator. */
2133 while (errcode
== 0 /* no error */
2134 && bufptr
- buffer
->get () < fetchlimit
* width
/* no overrun */
2135 && !found_nul
); /* haven't found NUL yet */
2138 { /* Length of string is really 0! */
2139 /* We always allocate *buffer. */
2140 buffer
->reset ((gdb_byte
*) xmalloc (1));
2141 bufptr
= buffer
->get ();
2145 /* bufptr and addr now point immediately beyond the last byte which we
2146 consider part of the string (including a '\0' which ends the string). */
2147 *bytes_read
= bufptr
- buffer
->get ();
2154 /* Return true if print_wchar can display W without resorting to a
2155 numeric escape, false otherwise. */
2158 wchar_printable (gdb_wchar_t w
)
2160 return (gdb_iswprint (w
)
2161 || w
== LCST ('\a') || w
== LCST ('\b')
2162 || w
== LCST ('\f') || w
== LCST ('\n')
2163 || w
== LCST ('\r') || w
== LCST ('\t')
2164 || w
== LCST ('\v'));
2167 /* A helper function that converts the contents of STRING to wide
2168 characters and then appends them to OUTPUT. */
2171 append_string_as_wide (const char *string
,
2172 struct obstack
*output
)
2174 for (; *string
; ++string
)
2176 gdb_wchar_t w
= gdb_btowc (*string
);
2177 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
2181 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2182 original (target) bytes representing the character, ORIG_LEN is the
2183 number of valid bytes. WIDTH is the number of bytes in a base
2184 characters of the type. OUTPUT is an obstack to which wide
2185 characters are emitted. QUOTER is a (narrow) character indicating
2186 the style of quotes surrounding the character to be printed.
2187 NEED_ESCAPE is an in/out flag which is used to track numeric
2188 escapes across calls. */
2191 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
2192 int orig_len
, int width
,
2193 enum bfd_endian byte_order
,
2194 struct obstack
*output
,
2195 int quoter
, int *need_escapep
)
2197 int need_escape
= *need_escapep
;
2201 /* iswprint implementation on Windows returns 1 for tab character.
2202 In order to avoid different printout on this host, we explicitly
2203 use wchar_printable function. */
2207 obstack_grow_wstr (output
, LCST ("\\a"));
2210 obstack_grow_wstr (output
, LCST ("\\b"));
2213 obstack_grow_wstr (output
, LCST ("\\f"));
2216 obstack_grow_wstr (output
, LCST ("\\n"));
2219 obstack_grow_wstr (output
, LCST ("\\r"));
2222 obstack_grow_wstr (output
, LCST ("\\t"));
2225 obstack_grow_wstr (output
, LCST ("\\v"));
2229 if (wchar_printable (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
2231 && w
!= LCST ('9'))))
2233 gdb_wchar_t wchar
= w
;
2235 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
2236 obstack_grow_wstr (output
, LCST ("\\"));
2237 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
2243 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
2248 value
= extract_unsigned_integer (&orig
[i
], width
,
2250 /* If the value fits in 3 octal digits, print it that
2251 way. Otherwise, print it as a hex escape. */
2253 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
2254 (int) (value
& 0777));
2256 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
2257 append_string_as_wide (octal
, output
);
2259 /* If we somehow have extra bytes, print them now. */
2260 while (i
< orig_len
)
2264 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
2265 append_string_as_wide (octal
, output
);
2276 /* Print the character C on STREAM as part of the contents of a
2277 literal string whose delimiter is QUOTER. ENCODING names the
2281 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2282 int quoter
, const char *encoding
)
2284 enum bfd_endian byte_order
2285 = type_byte_order (type
);
2287 int need_escape
= 0;
2289 c_buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
2290 pack_long (c_buf
, type
, c
);
2292 wchar_iterator
iter (c_buf
, TYPE_LENGTH (type
), encoding
, TYPE_LENGTH (type
));
2294 /* This holds the printable form of the wchar_t data. */
2295 auto_obstack wchar_buf
;
2301 const gdb_byte
*buf
;
2303 int print_escape
= 1;
2304 enum wchar_iterate_result result
;
2306 num_chars
= iter
.iterate (&result
, &chars
, &buf
, &buflen
);
2311 /* If all characters are printable, print them. Otherwise,
2312 we're going to have to print an escape sequence. We
2313 check all characters because we want to print the target
2314 bytes in the escape sequence, and we don't know character
2315 boundaries there. */
2319 for (i
= 0; i
< num_chars
; ++i
)
2320 if (!wchar_printable (chars
[i
]))
2328 for (i
= 0; i
< num_chars
; ++i
)
2329 print_wchar (chars
[i
], buf
, buflen
,
2330 TYPE_LENGTH (type
), byte_order
,
2331 &wchar_buf
, quoter
, &need_escape
);
2335 /* This handles the NUM_CHARS == 0 case as well. */
2337 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2338 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2341 /* The output in the host encoding. */
2342 auto_obstack output
;
2344 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2345 (gdb_byte
*) obstack_base (&wchar_buf
),
2346 obstack_object_size (&wchar_buf
),
2347 sizeof (gdb_wchar_t
), &output
, translit_char
);
2348 obstack_1grow (&output
, '\0');
2350 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2353 /* Return the repeat count of the next character/byte in ITER,
2354 storing the result in VEC. */
2357 count_next_character (wchar_iterator
*iter
,
2358 std::vector
<converted_character
> *vec
)
2360 struct converted_character
*current
;
2364 struct converted_character tmp
;
2368 = iter
->iterate (&tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2369 if (tmp
.num_chars
> 0)
2371 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2372 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2374 vec
->push_back (tmp
);
2377 current
= &vec
->back ();
2379 /* Count repeated characters or bytes. */
2380 current
->repeat_count
= 1;
2381 if (current
->num_chars
== -1)
2389 struct converted_character d
;
2396 /* Get the next character. */
2397 d
.num_chars
= iter
->iterate (&d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2399 /* If a character was successfully converted, save the character
2400 into the converted character. */
2401 if (d
.num_chars
> 0)
2403 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2404 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2407 /* Determine if the current character is the same as this
2409 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2411 /* There are two cases to consider:
2413 1) Equality of converted character (num_chars > 0)
2414 2) Equality of non-converted character (num_chars == 0) */
2415 if ((current
->num_chars
> 0
2416 && memcmp (current
->chars
, d
.chars
,
2417 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2418 || (current
->num_chars
== 0
2419 && current
->buflen
== d
.buflen
2420 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2421 ++current
->repeat_count
;
2429 /* Push this next converted character onto the result vector. */
2430 repeat
= current
->repeat_count
;
2436 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2437 character to use with string output. WIDTH is the size of the output
2438 character type. BYTE_ORDER is the target byte order. OPTIONS
2439 is the user's print options. */
2442 print_converted_chars_to_obstack (struct obstack
*obstack
,
2443 const std::vector
<converted_character
> &chars
,
2444 int quote_char
, int width
,
2445 enum bfd_endian byte_order
,
2446 const struct value_print_options
*options
)
2449 const converted_character
*elem
;
2450 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2451 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2452 int need_escape
= 0;
2454 /* Set the start state. */
2456 last
= state
= START
;
2464 /* Nothing to do. */
2471 /* We are outputting a single character
2472 (< options->repeat_count_threshold). */
2476 /* We were outputting some other type of content, so we
2477 must output and a comma and a quote. */
2479 obstack_grow_wstr (obstack
, LCST (", "));
2480 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2482 /* Output the character. */
2483 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2485 if (elem
->result
== wchar_iterate_ok
)
2486 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2487 byte_order
, obstack
, quote_char
, &need_escape
);
2489 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2490 byte_order
, obstack
, quote_char
, &need_escape
);
2499 /* We are outputting a character with a repeat count
2500 greater than options->repeat_count_threshold. */
2504 /* We were outputting a single string. Terminate the
2506 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2509 obstack_grow_wstr (obstack
, LCST (", "));
2511 /* Output the character and repeat string. */
2512 obstack_grow_wstr (obstack
, LCST ("'"));
2513 if (elem
->result
== wchar_iterate_ok
)
2514 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2515 byte_order
, obstack
, quote_char
, &need_escape
);
2517 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2518 byte_order
, obstack
, quote_char
, &need_escape
);
2519 obstack_grow_wstr (obstack
, LCST ("'"));
2520 std::string s
= string_printf (_(" <repeats %u times>"),
2521 elem
->repeat_count
);
2522 for (j
= 0; s
[j
]; ++j
)
2524 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2525 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2531 /* We are outputting an incomplete sequence. */
2534 /* If we were outputting a string of SINGLE characters,
2535 terminate the quote. */
2536 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2539 obstack_grow_wstr (obstack
, LCST (", "));
2541 /* Output the incomplete sequence string. */
2542 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
2543 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
2544 obstack
, 0, &need_escape
);
2545 obstack_grow_wstr (obstack
, LCST (">"));
2547 /* We do not attempt to output anything after this. */
2552 /* All done. If we were outputting a string of SINGLE
2553 characters, the string must be terminated. Otherwise,
2554 REPEAT and INCOMPLETE are always left properly terminated. */
2556 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2561 /* Get the next element and state. */
2563 if (state
!= FINISH
)
2565 elem
= &chars
[idx
++];
2566 switch (elem
->result
)
2568 case wchar_iterate_ok
:
2569 case wchar_iterate_invalid
:
2570 if (elem
->repeat_count
> options
->repeat_count_threshold
)
2576 case wchar_iterate_incomplete
:
2580 case wchar_iterate_eof
:
2588 /* Print the character string STRING, printing at most LENGTH
2589 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2590 the type of each character. OPTIONS holds the printing options;
2591 printing stops early if the number hits print_max; repeat counts
2592 are printed as appropriate. Print ellipses at the end if we had to
2593 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2594 QUOTE_CHAR is the character to print at each end of the string. If
2595 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2599 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2600 const gdb_byte
*string
, unsigned int length
,
2601 const char *encoding
, int force_ellipses
,
2602 int quote_char
, int c_style_terminator
,
2603 const struct value_print_options
*options
)
2605 enum bfd_endian byte_order
= type_byte_order (type
);
2607 int width
= TYPE_LENGTH (type
);
2609 struct converted_character
*last
;
2613 unsigned long current_char
= 1;
2615 for (i
= 0; current_char
; ++i
)
2618 current_char
= extract_unsigned_integer (string
+ i
* width
,
2624 /* If the string was not truncated due to `set print elements', and
2625 the last byte of it is a null, we don't print that, in
2626 traditional C style. */
2627 if (c_style_terminator
2630 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2631 width
, byte_order
) == 0))
2636 fputs_filtered ("\"\"", stream
);
2640 /* Arrange to iterate over the characters, in wchar_t form. */
2641 wchar_iterator
iter (string
, length
* width
, encoding
, width
);
2642 std::vector
<converted_character
> converted_chars
;
2644 /* Convert characters until the string is over or the maximum
2645 number of printed characters has been reached. */
2647 while (i
< options
->print_max
)
2653 /* Grab the next character and repeat count. */
2654 r
= count_next_character (&iter
, &converted_chars
);
2656 /* If less than zero, the end of the input string was reached. */
2660 /* Otherwise, add the count to the total print count and get
2661 the next character. */
2665 /* Get the last element and determine if the entire string was
2667 last
= &converted_chars
.back ();
2668 finished
= (last
->result
== wchar_iterate_eof
);
2670 /* Ensure that CONVERTED_CHARS is terminated. */
2671 last
->result
= wchar_iterate_eof
;
2673 /* WCHAR_BUF is the obstack we use to represent the string in
2675 auto_obstack wchar_buf
;
2677 /* Print the output string to the obstack. */
2678 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
2679 width
, byte_order
, options
);
2681 if (force_ellipses
|| !finished
)
2682 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2684 /* OUTPUT is where we collect `char's for printing. */
2685 auto_obstack output
;
2687 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2688 (gdb_byte
*) obstack_base (&wchar_buf
),
2689 obstack_object_size (&wchar_buf
),
2690 sizeof (gdb_wchar_t
), &output
, translit_char
);
2691 obstack_1grow (&output
, '\0');
2693 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2696 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2697 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2698 stops at the first null byte, otherwise printing proceeds (including null
2699 bytes) until either print_max or LEN characters have been printed,
2700 whichever is smaller. ENCODING is the name of the string's
2701 encoding. It can be NULL, in which case the target encoding is
2705 val_print_string (struct type
*elttype
, const char *encoding
,
2706 CORE_ADDR addr
, int len
,
2707 struct ui_file
*stream
,
2708 const struct value_print_options
*options
)
2710 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2711 int err
; /* Non-zero if we got a bad read. */
2712 int found_nul
; /* Non-zero if we found the nul char. */
2713 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2715 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
; /* Dynamically growable fetch buffer. */
2716 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2717 enum bfd_endian byte_order
= type_byte_order (elttype
);
2718 int width
= TYPE_LENGTH (elttype
);
2720 /* First we need to figure out the limit on the number of characters we are
2721 going to attempt to fetch and print. This is actually pretty simple. If
2722 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2723 LEN is -1, then the limit is print_max. This is true regardless of
2724 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2725 because finding the null byte (or available memory) is what actually
2726 limits the fetch. */
2728 fetchlimit
= (len
== -1 ? options
->print_max
: std::min ((unsigned) len
,
2729 options
->print_max
));
2731 err
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2732 &buffer
, &bytes_read
);
2736 /* We now have either successfully filled the buffer to fetchlimit,
2737 or terminated early due to an error or finding a null char when
2740 /* Determine found_nul by looking at the last character read. */
2742 if (bytes_read
>= width
)
2743 found_nul
= extract_unsigned_integer (buffer
.get () + bytes_read
- width
,
2744 width
, byte_order
) == 0;
2745 if (len
== -1 && !found_nul
)
2749 /* We didn't find a NUL terminator we were looking for. Attempt
2750 to peek at the next character. If not successful, or it is not
2751 a null byte, then force ellipsis to be printed. */
2753 peekbuf
= (gdb_byte
*) alloca (width
);
2755 if (target_read_memory (addr
, peekbuf
, width
) == 0
2756 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2759 else if ((len
>= 0 && err
!= 0) || (len
> bytes_read
/ width
))
2761 /* Getting an error when we have a requested length, or fetching less
2762 than the number of characters actually requested, always make us
2767 /* If we get an error before fetching anything, don't print a string.
2768 But if we fetch something and then get an error, print the string
2769 and then the error message. */
2770 if (err
== 0 || bytes_read
> 0)
2772 LA_PRINT_STRING (stream
, elttype
, buffer
.get (), bytes_read
/ width
,
2773 encoding
, force_ellipsis
, options
);
2778 std::string str
= memory_error_message (TARGET_XFER_E_IO
, gdbarch
, addr
);
2780 fprintf_filtered (stream
, _("<error: %ps>"),
2781 styled_string (metadata_style
.style (),
2785 return (bytes_read
/ width
);
2788 /* Handle 'show print max-depth'. */
2791 show_print_max_depth (struct ui_file
*file
, int from_tty
,
2792 struct cmd_list_element
*c
, const char *value
)
2794 fprintf_filtered (file
, _("Maximum print depth is %s.\n"), value
);
2798 /* The 'set input-radix' command writes to this auxiliary variable.
2799 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2800 it is left unchanged. */
2802 static unsigned input_radix_1
= 10;
2804 /* Validate an input or output radix setting, and make sure the user
2805 knows what they really did here. Radix setting is confusing, e.g.
2806 setting the input radix to "10" never changes it! */
2809 set_input_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2811 set_input_radix_1 (from_tty
, input_radix_1
);
2815 set_input_radix_1 (int from_tty
, unsigned radix
)
2817 /* We don't currently disallow any input radix except 0 or 1, which don't
2818 make any mathematical sense. In theory, we can deal with any input
2819 radix greater than 1, even if we don't have unique digits for every
2820 value from 0 to radix-1, but in practice we lose on large radix values.
2821 We should either fix the lossage or restrict the radix range more.
2826 input_radix_1
= input_radix
;
2827 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2830 input_radix_1
= input_radix
= radix
;
2833 printf_filtered (_("Input radix now set to "
2834 "decimal %u, hex %x, octal %o.\n"),
2835 radix
, radix
, radix
);
2839 /* The 'set output-radix' command writes to this auxiliary variable.
2840 If the requested radix is valid, OUTPUT_RADIX is updated,
2841 otherwise, it is left unchanged. */
2843 static unsigned output_radix_1
= 10;
2846 set_output_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2848 set_output_radix_1 (from_tty
, output_radix_1
);
2852 set_output_radix_1 (int from_tty
, unsigned radix
)
2854 /* Validate the radix and disallow ones that we aren't prepared to
2855 handle correctly, leaving the radix unchanged. */
2859 user_print_options
.output_format
= 'x'; /* hex */
2862 user_print_options
.output_format
= 0; /* decimal */
2865 user_print_options
.output_format
= 'o'; /* octal */
2868 output_radix_1
= output_radix
;
2869 error (_("Unsupported output radix ``decimal %u''; "
2870 "output radix unchanged."),
2873 output_radix_1
= output_radix
= radix
;
2876 printf_filtered (_("Output radix now set to "
2877 "decimal %u, hex %x, octal %o.\n"),
2878 radix
, radix
, radix
);
2882 /* Set both the input and output radix at once. Try to set the output radix
2883 first, since it has the most restrictive range. An radix that is valid as
2884 an output radix is also valid as an input radix.
2886 It may be useful to have an unusual input radix. If the user wishes to
2887 set an input radix that is not valid as an output radix, he needs to use
2888 the 'set input-radix' command. */
2891 set_radix (const char *arg
, int from_tty
)
2895 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2896 set_output_radix_1 (0, radix
);
2897 set_input_radix_1 (0, radix
);
2900 printf_filtered (_("Input and output radices now set to "
2901 "decimal %u, hex %x, octal %o.\n"),
2902 radix
, radix
, radix
);
2906 /* Show both the input and output radices. */
2909 show_radix (const char *arg
, int from_tty
)
2913 if (input_radix
== output_radix
)
2915 printf_filtered (_("Input and output radices set to "
2916 "decimal %u, hex %x, octal %o.\n"),
2917 input_radix
, input_radix
, input_radix
);
2921 printf_filtered (_("Input radix set to decimal "
2922 "%u, hex %x, octal %o.\n"),
2923 input_radix
, input_radix
, input_radix
);
2924 printf_filtered (_("Output radix set to decimal "
2925 "%u, hex %x, octal %o.\n"),
2926 output_radix
, output_radix
, output_radix
);
2932 /* Controls printing of vtbl's. */
2934 show_vtblprint (struct ui_file
*file
, int from_tty
,
2935 struct cmd_list_element
*c
, const char *value
)
2937 fprintf_filtered (file
, _("\
2938 Printing of C++ virtual function tables is %s.\n"),
2942 /* Controls looking up an object's derived type using what we find in
2945 show_objectprint (struct ui_file
*file
, int from_tty
,
2946 struct cmd_list_element
*c
,
2949 fprintf_filtered (file
, _("\
2950 Printing of object's derived type based on vtable info is %s.\n"),
2955 show_static_field_print (struct ui_file
*file
, int from_tty
,
2956 struct cmd_list_element
*c
,
2959 fprintf_filtered (file
,
2960 _("Printing of C++ static members is %s.\n"),
2966 /* A couple typedefs to make writing the options a bit more
2968 using boolean_option_def
2969 = gdb::option::boolean_option_def
<value_print_options
>;
2970 using uinteger_option_def
2971 = gdb::option::uinteger_option_def
<value_print_options
>;
2972 using zuinteger_unlimited_option_def
2973 = gdb::option::zuinteger_unlimited_option_def
<value_print_options
>;
2975 /* Definitions of options for the "print" and "compile print"
2977 static const gdb::option::option_def value_print_option_defs
[] = {
2979 boolean_option_def
{
2981 [] (value_print_options
*opt
) { return &opt
->addressprint
; },
2982 show_addressprint
, /* show_cmd_cb */
2983 N_("Set printing of addresses."),
2984 N_("Show printing of addresses."),
2985 NULL
, /* help_doc */
2988 boolean_option_def
{
2990 [] (value_print_options
*opt
) { return &opt
->prettyformat_arrays
; },
2991 show_prettyformat_arrays
, /* show_cmd_cb */
2992 N_("Set pretty formatting of arrays."),
2993 N_("Show pretty formatting of arrays."),
2994 NULL
, /* help_doc */
2997 boolean_option_def
{
2999 [] (value_print_options
*opt
) { return &opt
->print_array_indexes
; },
3000 show_print_array_indexes
, /* show_cmd_cb */
3001 N_("Set printing of array indexes."),
3002 N_("Show printing of array indexes."),
3003 NULL
, /* help_doc */
3006 uinteger_option_def
{
3008 [] (value_print_options
*opt
) { return &opt
->print_max
; },
3009 show_print_max
, /* show_cmd_cb */
3010 N_("Set limit on string chars or array elements to print."),
3011 N_("Show limit on string chars or array elements to print."),
3012 N_("\"unlimited\" causes there to be no limit."),
3015 zuinteger_unlimited_option_def
{
3017 [] (value_print_options
*opt
) { return &opt
->max_depth
; },
3018 show_print_max_depth
, /* show_cmd_cb */
3019 N_("Set maximum print depth for nested structures, unions and arrays."),
3020 N_("Show maximum print depth for nested structures, unions, and arrays."),
3021 N_("When structures, unions, or arrays are nested beyond this depth then they\n\
3022 will be replaced with either '{...}' or '(...)' depending on the language.\n\
3023 Use \"unlimited\" to print the complete structure.")
3026 boolean_option_def
{
3028 [] (value_print_options
*opt
) { return &opt
->stop_print_at_null
; },
3029 show_stop_print_at_null
, /* show_cmd_cb */
3030 N_("Set printing of char arrays to stop at first null char."),
3031 N_("Show printing of char arrays to stop at first null char."),
3032 NULL
, /* help_doc */
3035 boolean_option_def
{
3037 [] (value_print_options
*opt
) { return &opt
->objectprint
; },
3038 show_objectprint
, /* show_cmd_cb */
3039 _("Set printing of C++ virtual function tables."),
3040 _("Show printing of C++ virtual function tables."),
3041 NULL
, /* help_doc */
3044 boolean_option_def
{
3046 [] (value_print_options
*opt
) { return &opt
->prettyformat_structs
; },
3047 show_prettyformat_structs
, /* show_cmd_cb */
3048 N_("Set pretty formatting of structures."),
3049 N_("Show pretty formatting of structures."),
3050 NULL
, /* help_doc */
3053 boolean_option_def
{
3055 [] (value_print_options
*opt
) { return &opt
->raw
; },
3056 NULL
, /* show_cmd_cb */
3057 N_("Set whether to print values in raw form."),
3058 N_("Show whether to print values in raw form."),
3059 N_("If set, values are printed in raw form, bypassing any\n\
3060 pretty-printers for that value.")
3063 uinteger_option_def
{
3065 [] (value_print_options
*opt
) { return &opt
->repeat_count_threshold
; },
3066 show_repeat_count_threshold
, /* show_cmd_cb */
3067 N_("Set threshold for repeated print elements."),
3068 N_("Show threshold for repeated print elements."),
3069 N_("\"unlimited\" causes all elements to be individually printed."),
3072 boolean_option_def
{
3074 [] (value_print_options
*opt
) { return &opt
->static_field_print
; },
3075 show_static_field_print
, /* show_cmd_cb */
3076 N_("Set printing of C++ static members."),
3077 N_("Show printing of C++ static members."),
3078 NULL
, /* help_doc */
3081 boolean_option_def
{
3083 [] (value_print_options
*opt
) { return &opt
->symbol_print
; },
3084 show_symbol_print
, /* show_cmd_cb */
3085 N_("Set printing of symbol names when printing pointers."),
3086 N_("Show printing of symbol names when printing pointers."),
3087 NULL
, /* help_doc */
3090 boolean_option_def
{
3092 [] (value_print_options
*opt
) { return &opt
->unionprint
; },
3093 show_unionprint
, /* show_cmd_cb */
3094 N_("Set printing of unions interior to structures."),
3095 N_("Show printing of unions interior to structures."),
3096 NULL
, /* help_doc */
3099 boolean_option_def
{
3101 [] (value_print_options
*opt
) { return &opt
->vtblprint
; },
3102 show_vtblprint
, /* show_cmd_cb */
3103 N_("Set printing of C++ virtual function tables."),
3104 N_("Show printing of C++ virtual function tables."),
3105 NULL
, /* help_doc */
3109 /* See valprint.h. */
3111 gdb::option::option_def_group
3112 make_value_print_options_def_group (value_print_options
*opts
)
3114 return {{value_print_option_defs
}, opts
};
3117 void _initialize_valprint ();
3119 _initialize_valprint ()
3121 cmd_list_element
*cmd
;
3123 add_basic_prefix_cmd ("print", no_class
,
3124 _("Generic command for setting how things print."),
3125 &setprintlist
, "set print ", 0, &setlist
);
3126 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
3127 /* Prefer set print to set prompt. */
3128 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
3130 add_show_prefix_cmd ("print", no_class
,
3131 _("Generic command for showing print settings."),
3132 &showprintlist
, "show print ", 0, &showlist
);
3133 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
3134 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
3136 cmd
= add_basic_prefix_cmd ("raw", no_class
,
3138 Generic command for setting what things to print in \"raw\" mode."),
3139 &setprintrawlist
, "set print raw ", 0,
3141 deprecate_cmd (cmd
, nullptr);
3143 cmd
= add_show_prefix_cmd ("raw", no_class
,
3144 _("Generic command for showing \"print raw\" settings."),
3145 &showprintrawlist
, "show print raw ", 0,
3147 deprecate_cmd (cmd
, nullptr);
3149 gdb::option::add_setshow_cmds_for_options
3150 (class_support
, &user_print_options
, value_print_option_defs
,
3151 &setprintlist
, &showprintlist
);
3153 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
3155 Set default input radix for entering numbers."), _("\
3156 Show default input radix for entering numbers."), NULL
,
3159 &setlist
, &showlist
);
3161 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
3163 Set default output radix for printing of values."), _("\
3164 Show default output radix for printing of values."), NULL
,
3167 &setlist
, &showlist
);
3169 /* The "set radix" and "show radix" commands are special in that
3170 they are like normal set and show commands but allow two normally
3171 independent variables to be either set or shown with a single
3172 command. So the usual deprecated_add_set_cmd() and [deleted]
3173 add_show_from_set() commands aren't really appropriate. */
3174 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3175 longer true - show can display anything. */
3176 add_cmd ("radix", class_support
, set_radix
, _("\
3177 Set default input and output number radices.\n\
3178 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
3179 Without an argument, sets both radices back to the default value of 10."),
3181 add_cmd ("radix", class_support
, show_radix
, _("\
3182 Show the default input and output number radices.\n\
3183 Use 'show input-radix' or 'show output-radix' to independently show each."),