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"
44 /* Maximum number of wchars returned from wchar_iterate. */
47 /* A convenience macro to compute the size of a wchar_t buffer containing X
49 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
51 /* Character buffer size saved while iterating over wchars. */
52 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
54 /* A structure to encapsulate state information from iterated
55 character conversions. */
56 struct converted_character
58 /* The number of characters converted. */
61 /* The result of the conversion. See charset.h for more. */
62 enum wchar_iterate_result result
;
64 /* The (saved) converted character(s). */
65 gdb_wchar_t chars
[WCHAR_BUFLEN_MAX
];
67 /* The first converted target byte. */
70 /* The number of bytes converted. */
73 /* How many times this character(s) is repeated. */
77 /* Command lists for set/show print raw. */
78 struct cmd_list_element
*setprintrawlist
;
79 struct cmd_list_element
*showprintrawlist
;
81 /* Prototypes for local functions */
83 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
84 int len
, int *errptr
);
86 static void set_input_radix_1 (int, unsigned);
88 static void set_output_radix_1 (int, unsigned);
90 static void val_print_type_code_flags (struct type
*type
,
91 struct value
*original_value
,
93 struct ui_file
*stream
);
95 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
96 #define PRINT_MAX_DEPTH_DEFAULT 20 /* Start print_max_depth off at this value. */
98 struct value_print_options user_print_options
=
100 Val_prettyformat_default
, /* prettyformat */
101 0, /* prettyformat_arrays */
102 0, /* prettyformat_structs */
105 1, /* addressprint */
107 PRINT_MAX_DEFAULT
, /* print_max */
108 10, /* repeat_count_threshold */
109 0, /* output_format */
111 0, /* stop_print_at_null */
112 0, /* print_array_indexes */
114 1, /* static_field_print */
115 1, /* pascal_static_field_print */
118 1, /* symbol_print */
119 PRINT_MAX_DEPTH_DEFAULT
, /* max_depth */
123 /* Initialize *OPTS to be a copy of the user print options. */
125 get_user_print_options (struct value_print_options
*opts
)
127 *opts
= user_print_options
;
130 /* Initialize *OPTS to be a copy of the user print options, but with
131 pretty-formatting disabled. */
133 get_no_prettyformat_print_options (struct value_print_options
*opts
)
135 *opts
= user_print_options
;
136 opts
->prettyformat
= Val_no_prettyformat
;
139 /* Initialize *OPTS to be a copy of the user print options, but using
140 FORMAT as the formatting option. */
142 get_formatted_print_options (struct value_print_options
*opts
,
145 *opts
= user_print_options
;
146 opts
->format
= format
;
150 show_print_max (struct ui_file
*file
, int from_tty
,
151 struct cmd_list_element
*c
, const char *value
)
153 fprintf_filtered (file
,
154 _("Limit on string chars or array "
155 "elements to print is %s.\n"),
160 /* Default input and output radixes, and output format letter. */
162 unsigned input_radix
= 10;
164 show_input_radix (struct ui_file
*file
, int from_tty
,
165 struct cmd_list_element
*c
, const char *value
)
167 fprintf_filtered (file
,
168 _("Default input radix for entering numbers is %s.\n"),
172 unsigned output_radix
= 10;
174 show_output_radix (struct ui_file
*file
, int from_tty
,
175 struct cmd_list_element
*c
, const char *value
)
177 fprintf_filtered (file
,
178 _("Default output radix for printing of values is %s.\n"),
182 /* By default we print arrays without printing the index of each element in
183 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
186 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
187 struct cmd_list_element
*c
, const char *value
)
189 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
192 /* Print repeat counts if there are more than this many repetitions of an
193 element in an array. Referenced by the low level language dependent
197 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
198 struct cmd_list_element
*c
, const char *value
)
200 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
204 /* If nonzero, stops printing of char arrays at first null. */
207 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
208 struct cmd_list_element
*c
, const char *value
)
210 fprintf_filtered (file
,
211 _("Printing of char arrays to stop "
212 "at first null char is %s.\n"),
216 /* Controls pretty printing of structures. */
219 show_prettyformat_structs (struct ui_file
*file
, int from_tty
,
220 struct cmd_list_element
*c
, const char *value
)
222 fprintf_filtered (file
, _("Pretty formatting of structures is %s.\n"), value
);
225 /* Controls pretty printing of arrays. */
228 show_prettyformat_arrays (struct ui_file
*file
, int from_tty
,
229 struct cmd_list_element
*c
, const char *value
)
231 fprintf_filtered (file
, _("Pretty formatting of arrays is %s.\n"), value
);
234 /* If nonzero, causes unions inside structures or other unions to be
238 show_unionprint (struct ui_file
*file
, int from_tty
,
239 struct cmd_list_element
*c
, const char *value
)
241 fprintf_filtered (file
,
242 _("Printing of unions interior to structures is %s.\n"),
246 /* If nonzero, causes machine addresses to be printed in certain contexts. */
249 show_addressprint (struct ui_file
*file
, int from_tty
,
250 struct cmd_list_element
*c
, const char *value
)
252 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
256 show_symbol_print (struct ui_file
*file
, int from_tty
,
257 struct cmd_list_element
*c
, const char *value
)
259 fprintf_filtered (file
,
260 _("Printing of symbols when printing pointers is %s.\n"),
266 /* A helper function for val_print. When printing in "summary" mode,
267 we want to print scalar arguments, but not aggregate arguments.
268 This function distinguishes between the two. */
271 val_print_scalar_type_p (struct type
*type
)
273 type
= check_typedef (type
);
274 while (TYPE_IS_REFERENCE (type
))
276 type
= TYPE_TARGET_TYPE (type
);
277 type
= check_typedef (type
);
279 switch (TYPE_CODE (type
))
281 case TYPE_CODE_ARRAY
:
282 case TYPE_CODE_STRUCT
:
283 case TYPE_CODE_UNION
:
285 case TYPE_CODE_STRING
:
292 /* A helper function for val_print. When printing with limited depth we
293 want to print string and scalar arguments, but not aggregate arguments.
294 This function distinguishes between the two. */
297 val_print_scalar_or_string_type_p (struct type
*type
,
298 const struct language_defn
*language
)
300 return (val_print_scalar_type_p (type
)
301 || language
->la_is_string_type_p (type
));
304 /* See its definition in value.h. */
307 valprint_check_validity (struct ui_file
*stream
,
309 LONGEST embedded_offset
,
310 const struct value
*val
)
312 type
= check_typedef (type
);
314 if (type_not_associated (type
))
316 val_print_not_associated (stream
);
320 if (type_not_allocated (type
))
322 val_print_not_allocated (stream
);
326 if (TYPE_CODE (type
) != TYPE_CODE_UNION
327 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
328 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
330 if (value_bits_any_optimized_out (val
,
331 TARGET_CHAR_BIT
* embedded_offset
,
332 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
334 val_print_optimized_out (val
, stream
);
338 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
339 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
341 const int is_ref
= TYPE_CODE (type
) == TYPE_CODE_REF
;
342 int ref_is_addressable
= 0;
346 const struct value
*deref_val
= coerce_ref_if_computed (val
);
348 if (deref_val
!= NULL
)
349 ref_is_addressable
= value_lval_const (deref_val
) == lval_memory
;
352 if (!is_ref
|| !ref_is_addressable
)
353 fputs_styled (_("<synthetic pointer>"), metadata_style
.style (),
356 /* C++ references should be valid even if they're synthetic. */
360 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
362 val_print_unavailable (stream
);
371 val_print_optimized_out (const struct value
*val
, struct ui_file
*stream
)
373 if (val
!= NULL
&& value_lval_const (val
) == lval_register
)
374 val_print_not_saved (stream
);
376 fprintf_styled (stream
, metadata_style
.style (), _("<optimized out>"));
380 val_print_not_saved (struct ui_file
*stream
)
382 fprintf_styled (stream
, metadata_style
.style (), _("<not saved>"));
386 val_print_unavailable (struct ui_file
*stream
)
388 fprintf_styled (stream
, metadata_style
.style (), _("<unavailable>"));
392 val_print_invalid_address (struct ui_file
*stream
)
394 fprintf_styled (stream
, metadata_style
.style (), _("<invalid address>"));
397 /* Print a pointer based on the type of its target.
399 Arguments to this functions are roughly the same as those in
400 generic_val_print. A difference is that ADDRESS is the address to print,
401 with embedded_offset already added. ELTTYPE represents
402 the pointed type after check_typedef. */
405 print_unpacked_pointer (struct type
*type
, struct type
*elttype
,
406 CORE_ADDR address
, struct ui_file
*stream
,
407 const struct value_print_options
*options
)
409 struct gdbarch
*gdbarch
= get_type_arch (type
);
411 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
413 /* Try to print what function it points to. */
414 print_function_pointer_address (options
, gdbarch
, address
, stream
);
418 if (options
->symbol_print
)
419 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
420 else if (options
->addressprint
)
421 fputs_filtered (paddress (gdbarch
, address
), stream
);
424 /* generic_val_print helper for TYPE_CODE_ARRAY. */
427 generic_val_print_array (struct type
*type
,
428 int embedded_offset
, CORE_ADDR address
,
429 struct ui_file
*stream
, int recurse
,
430 struct value
*original_value
,
431 const struct value_print_options
*options
,
433 generic_val_print_decorations
*decorations
)
435 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
436 struct type
*elttype
= check_typedef (unresolved_elttype
);
438 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
440 LONGEST low_bound
, high_bound
;
442 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
443 error (_("Could not determine the array high bound"));
445 if (options
->prettyformat_arrays
)
447 print_spaces_filtered (2 + 2 * recurse
, stream
);
450 fputs_filtered (decorations
->array_start
, stream
);
451 val_print_array_elements (type
, embedded_offset
,
453 recurse
, original_value
, options
, 0);
454 fputs_filtered (decorations
->array_end
, stream
);
458 /* Array of unspecified length: treat like pointer to first elt. */
459 print_unpacked_pointer (type
, elttype
, address
+ embedded_offset
, stream
,
465 /* generic_val_print helper for TYPE_CODE_PTR. */
468 generic_val_print_ptr (struct type
*type
,
469 int embedded_offset
, struct ui_file
*stream
,
470 struct value
*original_value
,
471 const struct value_print_options
*options
)
473 struct gdbarch
*gdbarch
= get_type_arch (type
);
474 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
476 if (options
->format
&& options
->format
!= 's')
478 val_print_scalar_formatted (type
, embedded_offset
,
479 original_value
, options
, 0, stream
);
483 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE(type
);
484 struct type
*elttype
= check_typedef (unresolved_elttype
);
485 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
486 CORE_ADDR addr
= unpack_pointer (type
,
487 valaddr
+ embedded_offset
* unit_size
);
489 print_unpacked_pointer (type
, elttype
, addr
, stream
, options
);
493 /* generic_value_print helper for TYPE_CODE_PTR. */
496 generic_value_print_ptr (struct value
*val
, struct ui_file
*stream
,
497 const struct value_print_options
*options
)
500 if (options
->format
&& options
->format
!= 's')
501 value_print_scalar_formatted (val
, options
, 0, stream
);
504 struct type
*type
= check_typedef (value_type (val
));
505 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
506 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
507 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
509 print_unpacked_pointer (type
, elttype
, addr
, stream
, options
);
514 /* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
517 generic_val_print_memberptr (struct type
*type
,
518 int embedded_offset
, struct ui_file
*stream
,
519 struct value
*original_value
,
520 const struct value_print_options
*options
)
522 val_print_scalar_formatted (type
, embedded_offset
,
523 original_value
, options
, 0, stream
);
526 /* Print '@' followed by the address contained in ADDRESS_BUFFER. */
529 print_ref_address (struct type
*type
, const gdb_byte
*address_buffer
,
530 int embedded_offset
, struct ui_file
*stream
)
532 struct gdbarch
*gdbarch
= get_type_arch (type
);
534 if (address_buffer
!= NULL
)
537 = extract_typed_address (address_buffer
+ embedded_offset
, type
);
539 fprintf_filtered (stream
, "@");
540 fputs_filtered (paddress (gdbarch
, address
), stream
);
542 /* Else: we have a non-addressable value, such as a DW_AT_const_value. */
545 /* If VAL is addressable, return the value contents buffer of a value that
546 represents a pointer to VAL. Otherwise return NULL. */
548 static const gdb_byte
*
549 get_value_addr_contents (struct value
*deref_val
)
551 gdb_assert (deref_val
!= NULL
);
553 if (value_lval_const (deref_val
) == lval_memory
)
554 return value_contents_for_printing_const (value_addr (deref_val
));
557 /* We have a non-addressable value, such as a DW_AT_const_value. */
562 /* generic_val_print helper for TYPE_CODE_{RVALUE_,}REF. */
565 generic_val_print_ref (struct type
*type
,
566 int embedded_offset
, struct ui_file
*stream
, int recurse
,
567 struct value
*original_value
,
568 const struct value_print_options
*options
)
570 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
571 struct value
*deref_val
= NULL
;
572 const int value_is_synthetic
573 = value_bits_synthetic_pointer (original_value
,
574 TARGET_CHAR_BIT
* embedded_offset
,
575 TARGET_CHAR_BIT
* TYPE_LENGTH (type
));
576 const int must_coerce_ref
= ((options
->addressprint
&& value_is_synthetic
)
577 || options
->deref_ref
);
578 const int type_is_defined
= TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
;
579 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
581 if (must_coerce_ref
&& type_is_defined
)
583 deref_val
= coerce_ref_if_computed (original_value
);
585 if (deref_val
!= NULL
)
587 /* More complicated computed references are not supported. */
588 gdb_assert (embedded_offset
== 0);
591 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
592 unpack_pointer (type
, valaddr
+ embedded_offset
));
594 /* Else, original_value isn't a synthetic reference or we don't have to print
595 the reference's contents.
597 Notice that for references to TYPE_CODE_STRUCT, 'set print object on' will
598 cause original_value to be a not_lval instead of an lval_computed,
599 which will make value_bits_synthetic_pointer return false.
600 This happens because if options->objectprint is true, c_value_print will
601 overwrite original_value's contents with the result of coercing
602 the reference through value_addr, and then set its type back to
603 TYPE_CODE_REF. In that case we don't have to coerce the reference again;
604 we can simply treat it as non-synthetic and move on. */
606 if (options
->addressprint
)
608 const gdb_byte
*address
= (value_is_synthetic
&& type_is_defined
609 ? get_value_addr_contents (deref_val
)
612 print_ref_address (type
, address
, embedded_offset
, stream
);
614 if (options
->deref_ref
)
615 fputs_filtered (": ", stream
);
618 if (options
->deref_ref
)
621 common_val_print (deref_val
, stream
, recurse
, options
,
624 fputs_filtered ("???", stream
);
628 /* Helper function for generic_val_print_enum.
629 This is also used to print enums in TYPE_CODE_FLAGS values. */
632 generic_val_print_enum_1 (struct type
*type
, LONGEST val
,
633 struct ui_file
*stream
)
638 len
= TYPE_NFIELDS (type
);
639 for (i
= 0; i
< len
; i
++)
642 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
649 fputs_styled (TYPE_FIELD_NAME (type
, i
), variable_name_style
.style (),
652 else if (TYPE_FLAG_ENUM (type
))
656 /* We have a "flag" enum, so we try to decompose it into pieces as
657 appropriate. The enum may have multiple enumerators representing
658 the same bit, in which case we choose to only print the first one
660 for (i
= 0; i
< len
; ++i
)
664 ULONGEST enumval
= TYPE_FIELD_ENUMVAL (type
, i
);
665 int nbits
= count_one_bits_ll (enumval
);
667 gdb_assert (nbits
== 0 || nbits
== 1);
669 if ((val
& enumval
) != 0)
673 fputs_filtered ("(", stream
);
677 fputs_filtered (" | ", stream
);
679 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
680 fputs_styled (TYPE_FIELD_NAME (type
, i
),
681 variable_name_style
.style (), stream
);
687 /* There are leftover bits, print them. */
689 fputs_filtered ("(", stream
);
691 fputs_filtered (" | ", stream
);
693 fputs_filtered ("unknown: 0x", stream
);
694 print_longest (stream
, 'x', 0, val
);
695 fputs_filtered (")", stream
);
699 /* Nothing has been printed and the value is 0, the enum value must
701 fputs_filtered ("0", stream
);
705 /* Something has been printed, close the parenthesis. */
706 fputs_filtered (")", stream
);
710 print_longest (stream
, 'd', 0, val
);
713 /* generic_val_print helper for TYPE_CODE_ENUM. */
716 generic_val_print_enum (struct type
*type
,
717 int embedded_offset
, struct ui_file
*stream
,
718 struct value
*original_value
,
719 const struct value_print_options
*options
)
722 struct gdbarch
*gdbarch
= get_type_arch (type
);
723 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
725 gdb_assert (!options
->format
);
727 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
729 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
731 generic_val_print_enum_1 (type
, val
, stream
);
734 /* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
737 generic_val_print_func (struct type
*type
,
738 int embedded_offset
, CORE_ADDR address
,
739 struct ui_file
*stream
,
740 struct value
*original_value
,
741 const struct value_print_options
*options
)
743 struct gdbarch
*gdbarch
= get_type_arch (type
);
747 val_print_scalar_formatted (type
, embedded_offset
,
748 original_value
, options
, 0, stream
);
752 /* FIXME, we should consider, at least for ANSI C language,
753 eliminating the distinction made between FUNCs and POINTERs
755 fprintf_filtered (stream
, "{");
756 type_print (type
, "", stream
, -1);
757 fprintf_filtered (stream
, "} ");
758 /* Try to print what function it points to, and its address. */
759 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
763 /* generic_val_print helper for TYPE_CODE_BOOL. */
766 generic_val_print_bool (struct type
*type
,
767 int embedded_offset
, struct ui_file
*stream
,
768 struct value
*original_value
,
769 const struct value_print_options
*options
,
770 const struct generic_val_print_decorations
*decorations
)
773 struct gdbarch
*gdbarch
= get_type_arch (type
);
774 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
776 if (options
->format
|| options
->output_format
)
778 struct value_print_options opts
= *options
;
779 opts
.format
= (options
->format
? options
->format
780 : options
->output_format
);
781 val_print_scalar_formatted (type
, embedded_offset
,
782 original_value
, &opts
, 0, stream
);
786 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
788 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
790 fputs_filtered (decorations
->false_name
, stream
);
792 fputs_filtered (decorations
->true_name
, stream
);
794 print_longest (stream
, 'd', 0, val
);
798 /* generic_val_print helper for TYPE_CODE_INT. */
801 generic_val_print_int (struct type
*type
,
802 int embedded_offset
, struct ui_file
*stream
,
803 struct value
*original_value
,
804 const struct value_print_options
*options
)
806 struct value_print_options opts
= *options
;
808 opts
.format
= (options
->format
? options
->format
809 : options
->output_format
);
810 val_print_scalar_formatted (type
, embedded_offset
,
811 original_value
, &opts
, 0, stream
);
814 /* generic_val_print helper for TYPE_CODE_CHAR. */
817 generic_val_print_char (struct type
*type
, struct type
*unresolved_type
,
819 struct ui_file
*stream
,
820 struct value
*original_value
,
821 const struct value_print_options
*options
)
824 struct gdbarch
*gdbarch
= get_type_arch (type
);
825 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
827 if (options
->format
|| options
->output_format
)
829 struct value_print_options opts
= *options
;
831 opts
.format
= (options
->format
? options
->format
832 : options
->output_format
);
833 val_print_scalar_formatted (type
, embedded_offset
,
834 original_value
, &opts
, 0, stream
);
838 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
840 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
841 if (TYPE_UNSIGNED (type
))
842 fprintf_filtered (stream
, "%u", (unsigned int) val
);
844 fprintf_filtered (stream
, "%d", (int) val
);
845 fputs_filtered (" ", stream
);
846 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
850 /* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */
853 generic_val_print_float (struct type
*type
,
854 int embedded_offset
, struct ui_file
*stream
,
855 struct value
*original_value
,
856 const struct value_print_options
*options
)
858 struct gdbarch
*gdbarch
= get_type_arch (type
);
859 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
863 val_print_scalar_formatted (type
, embedded_offset
,
864 original_value
, options
, 0, stream
);
868 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
870 print_floating (valaddr
+ embedded_offset
* unit_size
, type
, stream
);
874 /* generic_val_print helper for TYPE_CODE_COMPLEX. */
877 generic_val_print_complex (struct type
*type
,
878 int embedded_offset
, struct ui_file
*stream
,
879 struct value
*original_value
,
880 const struct value_print_options
*options
,
881 const struct generic_val_print_decorations
884 struct gdbarch
*gdbarch
= get_type_arch (type
);
885 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
886 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
888 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
890 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
891 embedded_offset
, original_value
, options
, 0,
894 print_floating (valaddr
+ embedded_offset
* unit_size
,
895 TYPE_TARGET_TYPE (type
), stream
);
896 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
898 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
900 + type_length_units (TYPE_TARGET_TYPE (type
)),
901 original_value
, options
, 0, stream
);
903 print_floating (valaddr
+ embedded_offset
* unit_size
904 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
905 TYPE_TARGET_TYPE (type
), stream
);
906 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
909 /* A generic val_print that is suitable for use by language
910 implementations of the la_val_print method. This function can
911 handle most type codes, though not all, notably exception
912 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
915 Most arguments are as to val_print.
917 The additional DECORATIONS argument can be used to customize the
918 output in some small, language-specific ways. */
921 generic_val_print (struct type
*type
,
922 int embedded_offset
, CORE_ADDR address
,
923 struct ui_file
*stream
, int recurse
,
924 struct value
*original_value
,
925 const struct value_print_options
*options
,
926 const struct generic_val_print_decorations
*decorations
)
928 struct type
*unresolved_type
= type
;
930 type
= check_typedef (type
);
931 switch (TYPE_CODE (type
))
933 case TYPE_CODE_ARRAY
:
934 generic_val_print_array (type
, embedded_offset
, address
, stream
,
935 recurse
, original_value
, options
, decorations
);
938 case TYPE_CODE_MEMBERPTR
:
939 generic_val_print_memberptr (type
, embedded_offset
, stream
,
940 original_value
, options
);
944 generic_val_print_ptr (type
, embedded_offset
, stream
,
945 original_value
, options
);
949 case TYPE_CODE_RVALUE_REF
:
950 generic_val_print_ref (type
, embedded_offset
, stream
, recurse
,
951 original_value
, options
);
956 val_print_scalar_formatted (type
, embedded_offset
,
957 original_value
, options
, 0, stream
);
959 generic_val_print_enum (type
, embedded_offset
, stream
,
960 original_value
, options
);
963 case TYPE_CODE_FLAGS
:
965 val_print_scalar_formatted (type
, embedded_offset
,
966 original_value
, options
, 0, stream
);
968 val_print_type_code_flags (type
, original_value
, embedded_offset
,
973 case TYPE_CODE_METHOD
:
974 generic_val_print_func (type
, embedded_offset
, address
, stream
,
975 original_value
, options
);
979 generic_val_print_bool (type
, embedded_offset
, stream
,
980 original_value
, options
, decorations
);
983 case TYPE_CODE_RANGE
:
984 /* FIXME: create_static_range_type does not set the unsigned bit in a
985 range type (I think it probably should copy it from the
986 target type), so we won't print values which are too large to
987 fit in a signed integer correctly. */
988 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
989 print with the target type, though, because the size of our
990 type and the target type might differ). */
995 generic_val_print_int (type
, embedded_offset
, stream
,
996 original_value
, options
);
1000 generic_val_print_char (type
, unresolved_type
, embedded_offset
,
1001 stream
, original_value
, options
);
1005 case TYPE_CODE_DECFLOAT
:
1006 generic_val_print_float (type
, embedded_offset
, stream
,
1007 original_value
, options
);
1010 case TYPE_CODE_VOID
:
1011 fputs_filtered (decorations
->void_name
, stream
);
1014 case TYPE_CODE_ERROR
:
1015 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1018 case TYPE_CODE_UNDEF
:
1019 /* This happens (without TYPE_STUB set) on systems which don't use
1020 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1021 and no complete type for struct foo in that file. */
1022 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
1025 case TYPE_CODE_COMPLEX
:
1026 generic_val_print_complex (type
, embedded_offset
, stream
,
1027 original_value
, options
, decorations
);
1030 case TYPE_CODE_UNION
:
1031 case TYPE_CODE_STRUCT
:
1032 case TYPE_CODE_METHODPTR
:
1034 error (_("Unhandled type code %d in symbol table."),
1039 /* See valprint.h. */
1042 generic_value_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
1043 const struct value_print_options
*options
,
1044 const struct generic_val_print_decorations
*decorations
)
1046 struct type
*type
= value_type (val
);
1047 struct type
*unresolved_type
= type
;
1049 type
= check_typedef (type
);
1050 switch (TYPE_CODE (type
))
1052 case TYPE_CODE_ARRAY
:
1053 generic_val_print_array (type
, 0, value_address (val
), stream
,
1054 recurse
, val
, options
, decorations
);
1057 case TYPE_CODE_MEMBERPTR
:
1058 value_print_scalar_formatted (val
, options
, 0, stream
);
1062 generic_value_print_ptr (val
, stream
, options
);
1066 case TYPE_CODE_RVALUE_REF
:
1067 generic_val_print_ref (type
, 0, stream
, recurse
,
1071 case TYPE_CODE_ENUM
:
1072 if (options
->format
)
1073 value_print_scalar_formatted (val
, options
, 0, stream
);
1075 generic_val_print_enum (type
, 0, stream
, val
, options
);
1078 case TYPE_CODE_FLAGS
:
1079 if (options
->format
)
1080 value_print_scalar_formatted (val
, options
, 0, stream
);
1082 val_print_type_code_flags (type
, val
, 0, stream
);
1085 case TYPE_CODE_FUNC
:
1086 case TYPE_CODE_METHOD
:
1087 generic_val_print_func (type
, 0, value_address (val
), stream
,
1091 case TYPE_CODE_BOOL
:
1092 generic_val_print_bool (type
, 0, stream
,
1093 val
, options
, decorations
);
1096 case TYPE_CODE_RANGE
:
1097 /* FIXME: create_static_range_type does not set the unsigned bit in a
1098 range type (I think it probably should copy it from the
1099 target type), so we won't print values which are too large to
1100 fit in a signed integer correctly. */
1101 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
1102 print with the target type, though, because the size of our
1103 type and the target type might differ). */
1108 generic_val_print_int (type
, 0, stream
,
1112 case TYPE_CODE_CHAR
:
1113 generic_val_print_char (type
, unresolved_type
, 0,
1114 stream
, val
, options
);
1118 case TYPE_CODE_DECFLOAT
:
1119 generic_val_print_float (type
, 0, stream
,
1123 case TYPE_CODE_VOID
:
1124 fputs_filtered (decorations
->void_name
, stream
);
1127 case TYPE_CODE_ERROR
:
1128 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1131 case TYPE_CODE_UNDEF
:
1132 /* This happens (without TYPE_STUB set) on systems which don't use
1133 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1134 and no complete type for struct foo in that file. */
1135 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
1138 case TYPE_CODE_COMPLEX
:
1139 generic_val_print_complex (type
, 0, stream
,
1140 val
, options
, decorations
);
1143 case TYPE_CODE_UNION
:
1144 case TYPE_CODE_STRUCT
:
1145 case TYPE_CODE_METHODPTR
:
1147 error (_("Unhandled type code %d in symbol table."),
1152 /* Helper function for val_print and common_val_print that does the
1153 work. Arguments are as to val_print, but FULL_VALUE, if given, is
1154 the value to be printed. */
1157 do_val_print (struct value
*full_value
,
1158 struct type
*type
, LONGEST embedded_offset
,
1159 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
1161 const struct value_print_options
*options
,
1162 const struct language_defn
*language
)
1165 struct value_print_options local_opts
= *options
;
1166 struct type
*real_type
= check_typedef (type
);
1168 if (local_opts
.prettyformat
== Val_prettyformat_default
)
1169 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
1170 ? Val_prettyformat
: Val_no_prettyformat
);
1174 /* Ensure that the type is complete and not just a stub. If the type is
1175 only a stub and we can't find and substitute its complete type, then
1176 print appropriate string and return. */
1178 if (TYPE_STUB (real_type
))
1180 fprintf_styled (stream
, metadata_style
.style (), _("<incomplete type>"));
1184 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
1189 ret
= apply_ext_lang_val_pretty_printer (type
, embedded_offset
,
1190 address
, stream
, recurse
,
1191 val
, options
, language
);
1196 /* Handle summary mode. If the value is a scalar, print it;
1197 otherwise, print an ellipsis. */
1198 if (options
->summary
&& !val_print_scalar_type_p (type
))
1200 fprintf_filtered (stream
, "...");
1204 /* If this value is too deep then don't print it. */
1205 if (!val_print_scalar_or_string_type_p (type
, language
)
1206 && val_print_check_max_depth (stream
, recurse
, options
, language
))
1211 if (full_value
!= nullptr && language
->la_value_print_inner
!= nullptr)
1212 language
->la_value_print_inner (full_value
, stream
, recurse
,
1215 language
->la_val_print (type
, embedded_offset
, address
,
1216 stream
, recurse
, val
,
1219 catch (const gdb_exception_error
&except
)
1221 fprintf_styled (stream
, metadata_style
.style (),
1222 _("<error reading variable>"));
1226 /* Print using the given LANGUAGE the data of type TYPE located at
1227 VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came
1228 from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto
1229 stdio stream STREAM according to OPTIONS. VAL is the whole object
1230 that came from ADDRESS.
1232 The language printers will pass down an adjusted EMBEDDED_OFFSET to
1233 further helper subroutines as subfields of TYPE are printed. In
1234 such cases, VAL is passed down unadjusted, so
1235 that VAL can be queried for metadata about the contents data being
1236 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
1237 buffer. For example: "has this field been optimized out", or "I'm
1238 printing an object while inspecting a traceframe; has this
1239 particular piece of data been collected?".
1241 RECURSE indicates the amount of indentation to supply before
1242 continuation lines; this amount is roughly twice the value of
1246 val_print (struct type
*type
, LONGEST embedded_offset
,
1247 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
1249 const struct value_print_options
*options
,
1250 const struct language_defn
*language
)
1252 do_val_print (nullptr, type
, embedded_offset
, address
, stream
,
1253 recurse
, val
, options
, language
);
1256 /* See valprint.h. */
1259 val_print_check_max_depth (struct ui_file
*stream
, int recurse
,
1260 const struct value_print_options
*options
,
1261 const struct language_defn
*language
)
1263 if (options
->max_depth
> -1 && recurse
>= options
->max_depth
)
1265 gdb_assert (language
->la_struct_too_deep_ellipsis
!= NULL
);
1266 fputs_filtered (language
->la_struct_too_deep_ellipsis
, stream
);
1273 /* Check whether the value VAL is printable. Return 1 if it is;
1274 return 0 and print an appropriate error message to STREAM according to
1275 OPTIONS if it is not. */
1278 value_check_printable (struct value
*val
, struct ui_file
*stream
,
1279 const struct value_print_options
*options
)
1283 fprintf_styled (stream
, metadata_style
.style (),
1284 _("<address of value unknown>"));
1288 if (value_entirely_optimized_out (val
))
1290 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1291 fprintf_filtered (stream
, "...");
1293 val_print_optimized_out (val
, stream
);
1297 if (value_entirely_unavailable (val
))
1299 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1300 fprintf_filtered (stream
, "...");
1302 val_print_unavailable (stream
);
1306 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
1308 fprintf_styled (stream
, metadata_style
.style (),
1309 _("<internal function %s>"),
1310 value_internal_function_name (val
));
1314 if (type_not_associated (value_type (val
)))
1316 val_print_not_associated (stream
);
1320 if (type_not_allocated (value_type (val
)))
1322 val_print_not_allocated (stream
);
1329 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
1332 This is a preferable interface to val_print, above, because it uses
1333 GDB's value mechanism. */
1336 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
1337 const struct value_print_options
*options
,
1338 const struct language_defn
*language
)
1340 if (!value_check_printable (val
, stream
, options
))
1343 if (language
->la_language
== language_ada
)
1344 /* The value might have a dynamic type, which would cause trouble
1345 below when trying to extract the value contents (since the value
1346 size is determined from the type size which is unknown). So
1347 get a fixed representation of our value. */
1348 val
= ada_to_fixed_value (val
);
1350 if (value_lazy (val
))
1351 value_fetch_lazy (val
);
1353 do_val_print (val
, value_type (val
),
1354 value_embedded_offset (val
), value_address (val
),
1356 val
, options
, language
);
1359 /* See valprint.h. */
1362 common_val_print_checked (struct value
*val
, struct ui_file
*stream
,
1364 const struct value_print_options
*options
,
1365 const struct language_defn
*language
)
1367 if (!value_check_printable (val
, stream
, options
))
1369 common_val_print (val
, stream
, recurse
, options
, language
);
1372 /* Print on stream STREAM the value VAL according to OPTIONS. The value
1373 is printed using the current_language syntax. */
1376 value_print (struct value
*val
, struct ui_file
*stream
,
1377 const struct value_print_options
*options
)
1379 scoped_value_mark free_values
;
1381 if (!value_check_printable (val
, stream
, options
))
1387 = apply_ext_lang_val_pretty_printer (value_type (val
),
1388 value_embedded_offset (val
),
1389 value_address (val
),
1391 val
, options
, current_language
);
1397 LA_VALUE_PRINT (val
, stream
, options
);
1401 val_print_type_code_flags (struct type
*type
, struct value
*original_value
,
1402 int embedded_offset
, struct ui_file
*stream
)
1404 const gdb_byte
*valaddr
= (value_contents_for_printing (original_value
)
1406 ULONGEST val
= unpack_long (type
, valaddr
);
1407 int field
, nfields
= TYPE_NFIELDS (type
);
1408 struct gdbarch
*gdbarch
= get_type_arch (type
);
1409 struct type
*bool_type
= builtin_type (gdbarch
)->builtin_bool
;
1411 fputs_filtered ("[", stream
);
1412 for (field
= 0; field
< nfields
; field
++)
1414 if (TYPE_FIELD_NAME (type
, field
)[0] != '\0')
1416 struct type
*field_type
= TYPE_FIELD_TYPE (type
, field
);
1418 if (field_type
== bool_type
1419 /* We require boolean types here to be one bit wide. This is a
1420 problematic place to notify the user of an internal error
1421 though. Instead just fall through and print the field as an
1423 && TYPE_FIELD_BITSIZE (type
, field
) == 1)
1425 if (val
& ((ULONGEST
)1 << TYPE_FIELD_BITPOS (type
, field
)))
1428 styled_string (variable_name_style
.style (),
1429 TYPE_FIELD_NAME (type
, field
)));
1433 unsigned field_len
= TYPE_FIELD_BITSIZE (type
, field
);
1435 = val
>> (TYPE_FIELD_BITPOS (type
, field
) - field_len
+ 1);
1437 if (field_len
< sizeof (ULONGEST
) * TARGET_CHAR_BIT
)
1438 field_val
&= ((ULONGEST
) 1 << field_len
) - 1;
1439 fprintf_filtered (stream
, " %ps=",
1440 styled_string (variable_name_style
.style (),
1441 TYPE_FIELD_NAME (type
, field
)));
1442 if (TYPE_CODE (field_type
) == TYPE_CODE_ENUM
)
1443 generic_val_print_enum_1 (field_type
, field_val
, stream
);
1445 print_longest (stream
, 'd', 0, field_val
);
1449 fputs_filtered (" ]", stream
);
1452 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
1453 according to OPTIONS and SIZE on STREAM. Format i is not supported
1456 This is how the elements of an array or structure are printed
1460 val_print_scalar_formatted (struct type
*type
,
1461 LONGEST embedded_offset
,
1463 const struct value_print_options
*options
,
1465 struct ui_file
*stream
)
1467 struct gdbarch
*arch
= get_type_arch (type
);
1468 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
1470 gdb_assert (val
!= NULL
);
1472 /* If we get here with a string format, try again without it. Go
1473 all the way back to the language printers, which may call us
1475 if (options
->format
== 's')
1477 struct value_print_options opts
= *options
;
1480 val_print (type
, embedded_offset
, 0, stream
, 0, val
, &opts
,
1485 /* value_contents_for_printing fetches all VAL's contents. They are
1486 needed to check whether VAL is optimized-out or unavailable
1488 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1490 /* A scalar object that does not have all bits available can't be
1491 printed, because all bits contribute to its representation. */
1492 if (value_bits_any_optimized_out (val
,
1493 TARGET_CHAR_BIT
* embedded_offset
,
1494 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1495 val_print_optimized_out (val
, stream
);
1496 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
1497 val_print_unavailable (stream
);
1499 print_scalar_formatted (valaddr
+ embedded_offset
* unit_size
, type
,
1500 options
, size
, stream
);
1503 /* See valprint.h. */
1506 value_print_scalar_formatted (struct value
*val
,
1507 const struct value_print_options
*options
,
1509 struct ui_file
*stream
)
1511 struct type
*type
= check_typedef (value_type (val
));
1513 gdb_assert (val
!= NULL
);
1515 /* If we get here with a string format, try again without it. Go
1516 all the way back to the language printers, which may call us
1518 if (options
->format
== 's')
1520 struct value_print_options opts
= *options
;
1523 common_val_print (val
, stream
, 0, &opts
, current_language
);
1527 /* value_contents_for_printing fetches all VAL's contents. They are
1528 needed to check whether VAL is optimized-out or unavailable
1530 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1532 /* A scalar object that does not have all bits available can't be
1533 printed, because all bits contribute to its representation. */
1534 if (value_bits_any_optimized_out (val
, 0,
1535 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1536 val_print_optimized_out (val
, stream
);
1537 else if (!value_bytes_available (val
, 0, TYPE_LENGTH (type
)))
1538 val_print_unavailable (stream
);
1540 print_scalar_formatted (valaddr
, type
, options
, size
, stream
);
1543 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1544 The raison d'etre of this function is to consolidate printing of
1545 LONG_LONG's into this one function. The format chars b,h,w,g are
1546 from print_scalar_formatted(). Numbers are printed using C
1549 USE_C_FORMAT means to use C format in all cases. Without it,
1550 'o' and 'x' format do not include the standard C radix prefix
1553 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1554 and was intended to request formatting according to the current
1555 language and would be used for most integers that GDB prints. The
1556 exceptional cases were things like protocols where the format of
1557 the integer is a protocol thing, not a user-visible thing). The
1558 parameter remains to preserve the information of what things might
1559 be printed with language-specific format, should we ever resurrect
1563 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1571 val
= int_string (val_long
, 10, 1, 0, 1); break;
1573 val
= int_string (val_long
, 10, 0, 0, 1); break;
1575 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1577 val
= int_string (val_long
, 16, 0, 2, 1); break;
1579 val
= int_string (val_long
, 16, 0, 4, 1); break;
1581 val
= int_string (val_long
, 16, 0, 8, 1); break;
1583 val
= int_string (val_long
, 16, 0, 16, 1); break;
1586 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1588 internal_error (__FILE__
, __LINE__
,
1589 _("failed internal consistency check"));
1591 fputs_filtered (val
, stream
);
1594 /* This used to be a macro, but I don't think it is called often enough
1595 to merit such treatment. */
1596 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1597 arguments to a function, number in a value history, register number, etc.)
1598 where the value must not be larger than can fit in an int. */
1601 longest_to_int (LONGEST arg
)
1603 /* Let the compiler do the work. */
1604 int rtnval
= (int) arg
;
1606 /* Check for overflows or underflows. */
1607 if (sizeof (LONGEST
) > sizeof (int))
1611 error (_("Value out of range."));
1617 /* Print a floating point value of floating-point type TYPE,
1618 pointed to in GDB by VALADDR, on STREAM. */
1621 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1622 struct ui_file
*stream
)
1624 std::string str
= target_float_to_string (valaddr
, type
);
1625 fputs_filtered (str
.c_str (), stream
);
1629 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1630 unsigned len
, enum bfd_endian byte_order
, bool zero_pad
)
1635 bool seen_a_one
= false;
1637 /* Declared "int" so it will be signed.
1638 This ensures that right shift will shift in zeros. */
1640 const int mask
= 0x080;
1642 if (byte_order
== BFD_ENDIAN_BIG
)
1648 /* Every byte has 8 binary characters; peel off
1649 and print from the MSB end. */
1651 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1653 if (*p
& (mask
>> i
))
1658 if (zero_pad
|| seen_a_one
|| b
== '1')
1659 fputc_filtered (b
, stream
);
1667 for (p
= valaddr
+ len
- 1;
1671 for (i
= 0; i
< (HOST_CHAR_BIT
* sizeof (*p
)); i
++)
1673 if (*p
& (mask
>> i
))
1678 if (zero_pad
|| seen_a_one
|| b
== '1')
1679 fputc_filtered (b
, stream
);
1686 /* When not zero-padding, ensure that something is printed when the
1688 if (!zero_pad
&& !seen_a_one
)
1689 fputc_filtered ('0', stream
);
1692 /* A helper for print_octal_chars that emits a single octal digit,
1693 optionally suppressing it if is zero and updating SEEN_A_ONE. */
1696 emit_octal_digit (struct ui_file
*stream
, bool *seen_a_one
, int digit
)
1698 if (*seen_a_one
|| digit
!= 0)
1699 fprintf_filtered (stream
, "%o", digit
);
1704 /* VALADDR points to an integer of LEN bytes.
1705 Print it in octal on stream or format it in buf. */
1708 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1709 unsigned len
, enum bfd_endian byte_order
)
1712 unsigned char octa1
, octa2
, octa3
, carry
;
1715 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1716 * the extra bits, which cycle every three bytes:
1718 * Byte side: 0 1 2 3
1720 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1722 * Octal side: 0 1 carry 3 4 carry ...
1724 * Cycle number: 0 1 2
1726 * But of course we are printing from the high side, so we have to
1727 * figure out where in the cycle we are so that we end up with no
1728 * left over bits at the end.
1730 #define BITS_IN_OCTAL 3
1731 #define HIGH_ZERO 0340
1732 #define LOW_ZERO 0034
1733 #define CARRY_ZERO 0003
1734 static_assert (HIGH_ZERO
+ LOW_ZERO
+ CARRY_ZERO
== 0xff,
1735 "cycle zero constants are wrong");
1736 #define HIGH_ONE 0200
1737 #define MID_ONE 0160
1738 #define LOW_ONE 0016
1739 #define CARRY_ONE 0001
1740 static_assert (HIGH_ONE
+ MID_ONE
+ LOW_ONE
+ CARRY_ONE
== 0xff,
1741 "cycle one constants are wrong");
1742 #define HIGH_TWO 0300
1743 #define MID_TWO 0070
1744 #define LOW_TWO 0007
1745 static_assert (HIGH_TWO
+ MID_TWO
+ LOW_TWO
== 0xff,
1746 "cycle two constants are wrong");
1748 /* For 32 we start in cycle 2, with two bits and one bit carry;
1749 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1751 cycle
= (len
* HOST_CHAR_BIT
) % BITS_IN_OCTAL
;
1754 fputs_filtered ("0", stream
);
1755 bool seen_a_one
= false;
1756 if (byte_order
== BFD_ENDIAN_BIG
)
1765 /* No carry in, carry out two bits. */
1767 octa1
= (HIGH_ZERO
& *p
) >> 5;
1768 octa2
= (LOW_ZERO
& *p
) >> 2;
1769 carry
= (CARRY_ZERO
& *p
);
1770 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1771 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1775 /* Carry in two bits, carry out one bit. */
1777 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1778 octa2
= (MID_ONE
& *p
) >> 4;
1779 octa3
= (LOW_ONE
& *p
) >> 1;
1780 carry
= (CARRY_ONE
& *p
);
1781 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1782 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1783 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1787 /* Carry in one bit, no carry out. */
1789 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1790 octa2
= (MID_TWO
& *p
) >> 3;
1791 octa3
= (LOW_TWO
& *p
);
1793 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1794 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1795 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1799 error (_("Internal error in octal conversion;"));
1803 cycle
= cycle
% BITS_IN_OCTAL
;
1808 for (p
= valaddr
+ len
- 1;
1815 /* Carry out, no carry in */
1817 octa1
= (HIGH_ZERO
& *p
) >> 5;
1818 octa2
= (LOW_ZERO
& *p
) >> 2;
1819 carry
= (CARRY_ZERO
& *p
);
1820 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1821 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1825 /* Carry in, carry out */
1827 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1828 octa2
= (MID_ONE
& *p
) >> 4;
1829 octa3
= (LOW_ONE
& *p
) >> 1;
1830 carry
= (CARRY_ONE
& *p
);
1831 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1832 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1833 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1837 /* Carry in, no carry out */
1839 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1840 octa2
= (MID_TWO
& *p
) >> 3;
1841 octa3
= (LOW_TWO
& *p
);
1843 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1844 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1845 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1849 error (_("Internal error in octal conversion;"));
1853 cycle
= cycle
% BITS_IN_OCTAL
;
1859 /* Possibly negate the integer represented by BYTES. It contains LEN
1860 bytes in the specified byte order. If the integer is negative,
1861 copy it into OUT_VEC, negate it, and return true. Otherwise, do
1862 nothing and return false. */
1865 maybe_negate_by_bytes (const gdb_byte
*bytes
, unsigned len
,
1866 enum bfd_endian byte_order
,
1867 gdb::byte_vector
*out_vec
)
1870 gdb_assert (len
> 0);
1871 if (byte_order
== BFD_ENDIAN_BIG
)
1872 sign_byte
= bytes
[0];
1874 sign_byte
= bytes
[len
- 1];
1875 if ((sign_byte
& 0x80) == 0)
1878 out_vec
->resize (len
);
1880 /* Compute -x == 1 + ~x. */
1881 if (byte_order
== BFD_ENDIAN_LITTLE
)
1884 for (unsigned i
= 0; i
< len
; ++i
)
1886 unsigned tem
= (0xff & ~bytes
[i
]) + carry
;
1887 (*out_vec
)[i
] = tem
& 0xff;
1894 for (unsigned i
= len
; i
> 0; --i
)
1896 unsigned tem
= (0xff & ~bytes
[i
- 1]) + carry
;
1897 (*out_vec
)[i
- 1] = tem
& 0xff;
1905 /* VALADDR points to an integer of LEN bytes.
1906 Print it in decimal on stream or format it in buf. */
1909 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1910 unsigned len
, bool is_signed
,
1911 enum bfd_endian byte_order
)
1914 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1915 #define CARRY_LEFT( x ) ((x) % TEN)
1916 #define SHIFT( x ) ((x) << 4)
1917 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1918 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1923 int i
, j
, decimal_digits
;
1927 gdb::byte_vector negated_bytes
;
1929 && maybe_negate_by_bytes (valaddr
, len
, byte_order
, &negated_bytes
))
1931 fputs_filtered ("-", stream
);
1932 valaddr
= negated_bytes
.data ();
1935 /* Base-ten number is less than twice as many digits
1936 as the base 16 number, which is 2 digits per byte. */
1938 decimal_len
= len
* 2 * 2;
1939 std::vector
<unsigned char> digits (decimal_len
, 0);
1941 /* Ok, we have an unknown number of bytes of data to be printed in
1944 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1945 * decimalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1946 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1948 * The trick is that "digits" holds a base-10 number, but sometimes
1949 * the individual digits are > 10.
1951 * Outer loop is per nibble (hex digit) of input, from MSD end to
1954 decimal_digits
= 0; /* Number of decimal digits so far */
1955 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1957 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1960 * Multiply current base-ten number by 16 in place.
1961 * Each digit was between 0 and 9, now is between
1964 for (j
= 0; j
< decimal_digits
; j
++)
1966 digits
[j
] = SHIFT (digits
[j
]);
1969 /* Take the next nibble off the input and add it to what
1970 * we've got in the LSB position. Bottom 'digit' is now
1971 * between 0 and 159.
1973 * "flip" is used to run this loop twice for each byte.
1977 /* Take top nibble. */
1979 digits
[0] += HIGH_NIBBLE (*p
);
1984 /* Take low nibble and bump our pointer "p". */
1986 digits
[0] += LOW_NIBBLE (*p
);
1987 if (byte_order
== BFD_ENDIAN_BIG
)
1994 /* Re-decimalize. We have to do this often enough
1995 * that we don't overflow, but once per nibble is
1996 * overkill. Easier this way, though. Note that the
1997 * carry is often larger than 10 (e.g. max initial
1998 * carry out of lowest nibble is 15, could bubble all
1999 * the way up greater than 10). So we have to do
2000 * the carrying beyond the last current digit.
2003 for (j
= 0; j
< decimal_len
- 1; j
++)
2007 /* "/" won't handle an unsigned char with
2008 * a value that if signed would be negative.
2009 * So extend to longword int via "dummy".
2012 carry
= CARRY_OUT (dummy
);
2013 digits
[j
] = CARRY_LEFT (dummy
);
2015 if (j
>= decimal_digits
&& carry
== 0)
2018 * All higher digits are 0 and we
2019 * no longer have a carry.
2021 * Note: "j" is 0-based, "decimal_digits" is
2024 decimal_digits
= j
+ 1;
2030 /* Ok, now "digits" is the decimal representation, with
2031 the "decimal_digits" actual digits. Print! */
2033 for (i
= decimal_digits
- 1; i
> 0 && digits
[i
] == 0; --i
)
2038 fprintf_filtered (stream
, "%1d", digits
[i
]);
2042 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
2045 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
2046 unsigned len
, enum bfd_endian byte_order
,
2051 fputs_filtered ("0x", stream
);
2052 if (byte_order
== BFD_ENDIAN_BIG
)
2058 /* Strip leading 0 bytes, but be sure to leave at least a
2059 single byte at the end. */
2060 for (; p
< valaddr
+ len
- 1 && !*p
; ++p
)
2064 const gdb_byte
*first
= p
;
2069 /* When not zero-padding, use a different format for the
2070 very first byte printed. */
2071 if (!zero_pad
&& p
== first
)
2072 fprintf_filtered (stream
, "%x", *p
);
2074 fprintf_filtered (stream
, "%02x", *p
);
2079 p
= valaddr
+ len
- 1;
2083 /* Strip leading 0 bytes, but be sure to leave at least a
2084 single byte at the end. */
2085 for (; p
>= valaddr
+ 1 && !*p
; --p
)
2089 const gdb_byte
*first
= p
;
2094 /* When not zero-padding, use a different format for the
2095 very first byte printed. */
2096 if (!zero_pad
&& p
== first
)
2097 fprintf_filtered (stream
, "%x", *p
);
2099 fprintf_filtered (stream
, "%02x", *p
);
2104 /* VALADDR points to a char integer of LEN bytes.
2105 Print it out in appropriate language form on stream.
2106 Omit any leading zero chars. */
2109 print_char_chars (struct ui_file
*stream
, struct type
*type
,
2110 const gdb_byte
*valaddr
,
2111 unsigned len
, enum bfd_endian byte_order
)
2115 if (byte_order
== BFD_ENDIAN_BIG
)
2118 while (p
< valaddr
+ len
- 1 && *p
== 0)
2121 while (p
< valaddr
+ len
)
2123 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
2129 p
= valaddr
+ len
- 1;
2130 while (p
> valaddr
&& *p
== 0)
2133 while (p
>= valaddr
)
2135 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
2141 /* Print function pointer with inferior address ADDRESS onto stdio
2145 print_function_pointer_address (const struct value_print_options
*options
,
2146 struct gdbarch
*gdbarch
,
2148 struct ui_file
*stream
)
2151 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
2152 current_top_target ());
2154 /* If the function pointer is represented by a description, print
2155 the address of the description. */
2156 if (options
->addressprint
&& func_addr
!= address
)
2158 fputs_filtered ("@", stream
);
2159 fputs_filtered (paddress (gdbarch
, address
), stream
);
2160 fputs_filtered (": ", stream
);
2162 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
2166 /* Print on STREAM using the given OPTIONS the index for the element
2167 at INDEX of an array whose index type is INDEX_TYPE. */
2170 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
2171 struct ui_file
*stream
,
2172 const struct value_print_options
*options
)
2174 struct value
*index_value
;
2176 if (!options
->print_array_indexes
)
2179 index_value
= value_from_longest (index_type
, index
);
2181 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
2184 /* Called by various <lang>_val_print routines to print elements of an
2185 array in the form "<elem1>, <elem2>, <elem3>, ...".
2187 (FIXME?) Assumes array element separator is a comma, which is correct
2188 for all languages currently handled.
2189 (FIXME?) Some languages have a notation for repeated array elements,
2190 perhaps we should try to use that notation when appropriate. */
2193 val_print_array_elements (struct type
*type
,
2194 LONGEST embedded_offset
,
2195 CORE_ADDR address
, struct ui_file
*stream
,
2198 const struct value_print_options
*options
,
2201 unsigned int things_printed
= 0;
2203 struct type
*elttype
, *index_type
, *base_index_type
;
2205 /* Position of the array element we are examining to see
2206 whether it is repeated. */
2208 /* Number of repetitions we have detected so far. */
2210 LONGEST low_bound
, high_bound
;
2211 LONGEST low_pos
, high_pos
;
2213 elttype
= TYPE_TARGET_TYPE (type
);
2214 eltlen
= type_length_units (check_typedef (elttype
));
2215 index_type
= TYPE_INDEX_TYPE (type
);
2217 if (get_array_bounds (type
, &low_bound
, &high_bound
))
2219 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
2220 base_index_type
= TYPE_TARGET_TYPE (index_type
);
2222 base_index_type
= index_type
;
2224 /* Non-contiguous enumerations types can by used as index types
2225 in some languages (e.g. Ada). In this case, the array length
2226 shall be computed from the positions of the first and last
2227 literal in the enumeration type, and not from the values
2228 of these literals. */
2229 if (!discrete_position (base_index_type
, low_bound
, &low_pos
)
2230 || !discrete_position (base_index_type
, high_bound
, &high_pos
))
2232 warning (_("unable to get positions in array, use bounds instead"));
2233 low_pos
= low_bound
;
2234 high_pos
= high_bound
;
2237 /* The array length should normally be HIGH_POS - LOW_POS + 1.
2238 But we have to be a little extra careful, because some languages
2239 such as Ada allow LOW_POS to be greater than HIGH_POS for
2240 empty arrays. In that situation, the array length is just zero,
2242 if (low_pos
> high_pos
)
2245 len
= high_pos
- low_pos
+ 1;
2249 warning (_("unable to get bounds of array, assuming null array"));
2254 annotate_array_section_begin (i
, elttype
);
2256 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
2260 if (options
->prettyformat_arrays
)
2262 fprintf_filtered (stream
, ",\n");
2263 print_spaces_filtered (2 + 2 * recurse
, stream
);
2267 fprintf_filtered (stream
, ", ");
2270 wrap_here (n_spaces (2 + 2 * recurse
));
2271 maybe_print_array_index (index_type
, i
+ low_bound
,
2276 /* Only check for reps if repeat_count_threshold is not set to
2277 UINT_MAX (unlimited). */
2278 if (options
->repeat_count_threshold
< UINT_MAX
)
2281 && value_contents_eq (val
,
2282 embedded_offset
+ i
* eltlen
,
2293 if (reps
> options
->repeat_count_threshold
)
2295 val_print (elttype
, embedded_offset
+ i
* eltlen
,
2296 address
, stream
, recurse
+ 1, val
, options
,
2298 annotate_elt_rep (reps
);
2299 fprintf_filtered (stream
, " %p[<repeats %u times>%p]",
2300 metadata_style
.style ().ptr (), reps
, nullptr);
2301 annotate_elt_rep_end ();
2304 things_printed
+= options
->repeat_count_threshold
;
2308 val_print (elttype
, embedded_offset
+ i
* eltlen
,
2310 stream
, recurse
+ 1, val
, options
, current_language
);
2315 annotate_array_section_end ();
2318 fprintf_filtered (stream
, "...");
2322 /* See valprint.h. */
2325 value_print_array_elements (struct value
*val
, struct ui_file
*stream
,
2327 const struct value_print_options
*options
,
2330 unsigned int things_printed
= 0;
2332 struct type
*elttype
, *index_type
, *base_index_type
;
2334 /* Position of the array element we are examining to see
2335 whether it is repeated. */
2337 /* Number of repetitions we have detected so far. */
2339 LONGEST low_bound
, high_bound
;
2340 LONGEST low_pos
, high_pos
;
2342 struct type
*type
= check_typedef (value_type (val
));
2344 elttype
= TYPE_TARGET_TYPE (type
);
2345 eltlen
= type_length_units (check_typedef (elttype
));
2346 index_type
= TYPE_INDEX_TYPE (type
);
2348 if (get_array_bounds (type
, &low_bound
, &high_bound
))
2350 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
2351 base_index_type
= TYPE_TARGET_TYPE (index_type
);
2353 base_index_type
= index_type
;
2355 /* Non-contiguous enumerations types can by used as index types
2356 in some languages (e.g. Ada). In this case, the array length
2357 shall be computed from the positions of the first and last
2358 literal in the enumeration type, and not from the values
2359 of these literals. */
2360 if (!discrete_position (base_index_type
, low_bound
, &low_pos
)
2361 || !discrete_position (base_index_type
, high_bound
, &high_pos
))
2363 warning (_("unable to get positions in array, use bounds instead"));
2364 low_pos
= low_bound
;
2365 high_pos
= high_bound
;
2368 /* The array length should normally be HIGH_POS - LOW_POS + 1.
2369 But we have to be a little extra careful, because some languages
2370 such as Ada allow LOW_POS to be greater than HIGH_POS for
2371 empty arrays. In that situation, the array length is just zero,
2373 if (low_pos
> high_pos
)
2376 len
= high_pos
- low_pos
+ 1;
2380 warning (_("unable to get bounds of array, assuming null array"));
2385 annotate_array_section_begin (i
, elttype
);
2387 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
2389 scoped_value_mark free_values
;
2393 if (options
->prettyformat_arrays
)
2395 fprintf_filtered (stream
, ",\n");
2396 print_spaces_filtered (2 + 2 * recurse
, stream
);
2399 fprintf_filtered (stream
, ", ");
2401 wrap_here (n_spaces (2 + 2 * recurse
));
2402 maybe_print_array_index (index_type
, i
+ low_bound
,
2407 /* Only check for reps if repeat_count_threshold is not set to
2408 UINT_MAX (unlimited). */
2409 if (options
->repeat_count_threshold
< UINT_MAX
)
2412 && value_contents_eq (val
, i
* eltlen
,
2421 struct value
*element
= value_from_component (val
, elttype
, eltlen
* i
);
2422 common_val_print (element
, stream
, recurse
+ 1, options
,
2425 if (reps
> options
->repeat_count_threshold
)
2427 annotate_elt_rep (reps
);
2428 fprintf_filtered (stream
, " %p[<repeats %u times>%p]",
2429 metadata_style
.style ().ptr (), reps
, nullptr);
2430 annotate_elt_rep_end ();
2433 things_printed
+= options
->repeat_count_threshold
;
2441 annotate_array_section_end ();
2443 fprintf_filtered (stream
, "...");
2446 /* Read LEN bytes of target memory at address MEMADDR, placing the
2447 results in GDB's memory at MYADDR. Returns a count of the bytes
2448 actually read, and optionally a target_xfer_status value in the
2449 location pointed to by ERRPTR if ERRPTR is non-null. */
2451 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
2452 function be eliminated. */
2455 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
2456 int len
, int *errptr
)
2458 int nread
; /* Number of bytes actually read. */
2459 int errcode
; /* Error from last read. */
2461 /* First try a complete read. */
2462 errcode
= target_read_memory (memaddr
, myaddr
, len
);
2470 /* Loop, reading one byte at a time until we get as much as we can. */
2471 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
2473 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
2475 /* If an error, the last read was unsuccessful, so adjust count. */
2488 /* Read a string from the inferior, at ADDR, with LEN characters of
2489 WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER
2490 will be set to a newly allocated buffer containing the string, and
2491 BYTES_READ will be set to the number of bytes read. Returns 0 on
2492 success, or a target_xfer_status on failure.
2494 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2495 (including eventual NULs in the middle or end of the string).
2497 If LEN is -1, stops at the first null character (not necessarily
2498 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2499 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2502 Unless an exception is thrown, BUFFER will always be allocated, even on
2503 failure. In this case, some characters might have been read before the
2504 failure happened. Check BYTES_READ to recognize this situation.
2506 Note: There was a FIXME asking to make this code use target_read_string,
2507 but this function is more general (can read past null characters, up to
2508 given LEN). Besides, it is used much more often than target_read_string
2509 so it is more tested. Perhaps callers of target_read_string should use
2510 this function instead? */
2513 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
2514 enum bfd_endian byte_order
, gdb::unique_xmalloc_ptr
<gdb_byte
> *buffer
,
2517 int errcode
; /* Errno returned from bad reads. */
2518 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
2519 gdb_byte
*bufptr
; /* Pointer to next available byte in
2522 /* Loop until we either have all the characters, or we encounter
2523 some error, such as bumping into the end of the address space. */
2525 buffer
->reset (nullptr);
2529 /* We want fetchlimit chars, so we might as well read them all in
2531 unsigned int fetchlen
= std::min ((unsigned) len
, fetchlimit
);
2533 buffer
->reset ((gdb_byte
*) xmalloc (fetchlen
* width
));
2534 bufptr
= buffer
->get ();
2536 nfetch
= partial_memory_read (addr
, bufptr
, fetchlen
* width
, &errcode
)
2538 addr
+= nfetch
* width
;
2539 bufptr
+= nfetch
* width
;
2543 unsigned long bufsize
= 0;
2544 unsigned int chunksize
; /* Size of each fetch, in chars. */
2545 int found_nul
; /* Non-zero if we found the nul char. */
2546 gdb_byte
*limit
; /* First location past end of fetch buffer. */
2549 /* We are looking for a NUL terminator to end the fetching, so we
2550 might as well read in blocks that are large enough to be efficient,
2551 but not so large as to be slow if fetchlimit happens to be large.
2552 So we choose the minimum of 8 and fetchlimit. We used to use 200
2553 instead of 8 but 200 is way too big for remote debugging over a
2555 chunksize
= std::min (8u, fetchlimit
);
2560 nfetch
= std::min ((unsigned long) chunksize
, fetchlimit
- bufsize
);
2562 if (*buffer
== NULL
)
2563 buffer
->reset ((gdb_byte
*) xmalloc (nfetch
* width
));
2565 buffer
->reset ((gdb_byte
*) xrealloc (buffer
->release (),
2566 (nfetch
+ bufsize
) * width
));
2568 bufptr
= buffer
->get () + bufsize
* width
;
2571 /* Read as much as we can. */
2572 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
2575 /* Scan this chunk for the null character that terminates the string
2576 to print. If found, we don't need to fetch any more. Note
2577 that bufptr is explicitly left pointing at the next character
2578 after the null character, or at the next character after the end
2581 limit
= bufptr
+ nfetch
* width
;
2582 while (bufptr
< limit
)
2586 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
2591 /* We don't care about any error which happened after
2592 the NUL terminator. */
2599 while (errcode
== 0 /* no error */
2600 && bufptr
- buffer
->get () < fetchlimit
* width
/* no overrun */
2601 && !found_nul
); /* haven't found NUL yet */
2604 { /* Length of string is really 0! */
2605 /* We always allocate *buffer. */
2606 buffer
->reset ((gdb_byte
*) xmalloc (1));
2607 bufptr
= buffer
->get ();
2611 /* bufptr and addr now point immediately beyond the last byte which we
2612 consider part of the string (including a '\0' which ends the string). */
2613 *bytes_read
= bufptr
- buffer
->get ();
2620 /* Return true if print_wchar can display W without resorting to a
2621 numeric escape, false otherwise. */
2624 wchar_printable (gdb_wchar_t w
)
2626 return (gdb_iswprint (w
)
2627 || w
== LCST ('\a') || w
== LCST ('\b')
2628 || w
== LCST ('\f') || w
== LCST ('\n')
2629 || w
== LCST ('\r') || w
== LCST ('\t')
2630 || w
== LCST ('\v'));
2633 /* A helper function that converts the contents of STRING to wide
2634 characters and then appends them to OUTPUT. */
2637 append_string_as_wide (const char *string
,
2638 struct obstack
*output
)
2640 for (; *string
; ++string
)
2642 gdb_wchar_t w
= gdb_btowc (*string
);
2643 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
2647 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2648 original (target) bytes representing the character, ORIG_LEN is the
2649 number of valid bytes. WIDTH is the number of bytes in a base
2650 characters of the type. OUTPUT is an obstack to which wide
2651 characters are emitted. QUOTER is a (narrow) character indicating
2652 the style of quotes surrounding the character to be printed.
2653 NEED_ESCAPE is an in/out flag which is used to track numeric
2654 escapes across calls. */
2657 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
2658 int orig_len
, int width
,
2659 enum bfd_endian byte_order
,
2660 struct obstack
*output
,
2661 int quoter
, int *need_escapep
)
2663 int need_escape
= *need_escapep
;
2667 /* iswprint implementation on Windows returns 1 for tab character.
2668 In order to avoid different printout on this host, we explicitly
2669 use wchar_printable function. */
2673 obstack_grow_wstr (output
, LCST ("\\a"));
2676 obstack_grow_wstr (output
, LCST ("\\b"));
2679 obstack_grow_wstr (output
, LCST ("\\f"));
2682 obstack_grow_wstr (output
, LCST ("\\n"));
2685 obstack_grow_wstr (output
, LCST ("\\r"));
2688 obstack_grow_wstr (output
, LCST ("\\t"));
2691 obstack_grow_wstr (output
, LCST ("\\v"));
2695 if (wchar_printable (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
2697 && w
!= LCST ('9'))))
2699 gdb_wchar_t wchar
= w
;
2701 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
2702 obstack_grow_wstr (output
, LCST ("\\"));
2703 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
2709 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
2714 value
= extract_unsigned_integer (&orig
[i
], width
,
2716 /* If the value fits in 3 octal digits, print it that
2717 way. Otherwise, print it as a hex escape. */
2719 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
2720 (int) (value
& 0777));
2722 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
2723 append_string_as_wide (octal
, output
);
2725 /* If we somehow have extra bytes, print them now. */
2726 while (i
< orig_len
)
2730 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
2731 append_string_as_wide (octal
, output
);
2742 /* Print the character C on STREAM as part of the contents of a
2743 literal string whose delimiter is QUOTER. ENCODING names the
2747 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2748 int quoter
, const char *encoding
)
2750 enum bfd_endian byte_order
2751 = type_byte_order (type
);
2753 int need_escape
= 0;
2755 c_buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
2756 pack_long (c_buf
, type
, c
);
2758 wchar_iterator
iter (c_buf
, TYPE_LENGTH (type
), encoding
, TYPE_LENGTH (type
));
2760 /* This holds the printable form of the wchar_t data. */
2761 auto_obstack wchar_buf
;
2767 const gdb_byte
*buf
;
2769 int print_escape
= 1;
2770 enum wchar_iterate_result result
;
2772 num_chars
= iter
.iterate (&result
, &chars
, &buf
, &buflen
);
2777 /* If all characters are printable, print them. Otherwise,
2778 we're going to have to print an escape sequence. We
2779 check all characters because we want to print the target
2780 bytes in the escape sequence, and we don't know character
2781 boundaries there. */
2785 for (i
= 0; i
< num_chars
; ++i
)
2786 if (!wchar_printable (chars
[i
]))
2794 for (i
= 0; i
< num_chars
; ++i
)
2795 print_wchar (chars
[i
], buf
, buflen
,
2796 TYPE_LENGTH (type
), byte_order
,
2797 &wchar_buf
, quoter
, &need_escape
);
2801 /* This handles the NUM_CHARS == 0 case as well. */
2803 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2804 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2807 /* The output in the host encoding. */
2808 auto_obstack output
;
2810 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2811 (gdb_byte
*) obstack_base (&wchar_buf
),
2812 obstack_object_size (&wchar_buf
),
2813 sizeof (gdb_wchar_t
), &output
, translit_char
);
2814 obstack_1grow (&output
, '\0');
2816 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2819 /* Return the repeat count of the next character/byte in ITER,
2820 storing the result in VEC. */
2823 count_next_character (wchar_iterator
*iter
,
2824 std::vector
<converted_character
> *vec
)
2826 struct converted_character
*current
;
2830 struct converted_character tmp
;
2834 = iter
->iterate (&tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2835 if (tmp
.num_chars
> 0)
2837 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2838 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2840 vec
->push_back (tmp
);
2843 current
= &vec
->back ();
2845 /* Count repeated characters or bytes. */
2846 current
->repeat_count
= 1;
2847 if (current
->num_chars
== -1)
2855 struct converted_character d
;
2862 /* Get the next character. */
2863 d
.num_chars
= iter
->iterate (&d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2865 /* If a character was successfully converted, save the character
2866 into the converted character. */
2867 if (d
.num_chars
> 0)
2869 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2870 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2873 /* Determine if the current character is the same as this
2875 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2877 /* There are two cases to consider:
2879 1) Equality of converted character (num_chars > 0)
2880 2) Equality of non-converted character (num_chars == 0) */
2881 if ((current
->num_chars
> 0
2882 && memcmp (current
->chars
, d
.chars
,
2883 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2884 || (current
->num_chars
== 0
2885 && current
->buflen
== d
.buflen
2886 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2887 ++current
->repeat_count
;
2895 /* Push this next converted character onto the result vector. */
2896 repeat
= current
->repeat_count
;
2902 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2903 character to use with string output. WIDTH is the size of the output
2904 character type. BYTE_ORDER is the target byte order. OPTIONS
2905 is the user's print options. */
2908 print_converted_chars_to_obstack (struct obstack
*obstack
,
2909 const std::vector
<converted_character
> &chars
,
2910 int quote_char
, int width
,
2911 enum bfd_endian byte_order
,
2912 const struct value_print_options
*options
)
2915 const converted_character
*elem
;
2916 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2917 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2918 int need_escape
= 0;
2920 /* Set the start state. */
2922 last
= state
= START
;
2930 /* Nothing to do. */
2937 /* We are outputting a single character
2938 (< options->repeat_count_threshold). */
2942 /* We were outputting some other type of content, so we
2943 must output and a comma and a quote. */
2945 obstack_grow_wstr (obstack
, LCST (", "));
2946 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2948 /* Output the character. */
2949 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2951 if (elem
->result
== wchar_iterate_ok
)
2952 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2953 byte_order
, obstack
, quote_char
, &need_escape
);
2955 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2956 byte_order
, obstack
, quote_char
, &need_escape
);
2965 /* We are outputting a character with a repeat count
2966 greater than options->repeat_count_threshold. */
2970 /* We were outputting a single string. Terminate the
2972 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2975 obstack_grow_wstr (obstack
, LCST (", "));
2977 /* Output the character and repeat string. */
2978 obstack_grow_wstr (obstack
, LCST ("'"));
2979 if (elem
->result
== wchar_iterate_ok
)
2980 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2981 byte_order
, obstack
, quote_char
, &need_escape
);
2983 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2984 byte_order
, obstack
, quote_char
, &need_escape
);
2985 obstack_grow_wstr (obstack
, LCST ("'"));
2986 std::string s
= string_printf (_(" <repeats %u times>"),
2987 elem
->repeat_count
);
2988 for (j
= 0; s
[j
]; ++j
)
2990 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2991 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2997 /* We are outputting an incomplete sequence. */
3000 /* If we were outputting a string of SINGLE characters,
3001 terminate the quote. */
3002 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
3005 obstack_grow_wstr (obstack
, LCST (", "));
3007 /* Output the incomplete sequence string. */
3008 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
3009 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
3010 obstack
, 0, &need_escape
);
3011 obstack_grow_wstr (obstack
, LCST (">"));
3013 /* We do not attempt to output anything after this. */
3018 /* All done. If we were outputting a string of SINGLE
3019 characters, the string must be terminated. Otherwise,
3020 REPEAT and INCOMPLETE are always left properly terminated. */
3022 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
3027 /* Get the next element and state. */
3029 if (state
!= FINISH
)
3031 elem
= &chars
[idx
++];
3032 switch (elem
->result
)
3034 case wchar_iterate_ok
:
3035 case wchar_iterate_invalid
:
3036 if (elem
->repeat_count
> options
->repeat_count_threshold
)
3042 case wchar_iterate_incomplete
:
3046 case wchar_iterate_eof
:
3054 /* Print the character string STRING, printing at most LENGTH
3055 characters. LENGTH is -1 if the string is nul terminated. TYPE is
3056 the type of each character. OPTIONS holds the printing options;
3057 printing stops early if the number hits print_max; repeat counts
3058 are printed as appropriate. Print ellipses at the end if we had to
3059 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
3060 QUOTE_CHAR is the character to print at each end of the string. If
3061 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
3065 generic_printstr (struct ui_file
*stream
, struct type
*type
,
3066 const gdb_byte
*string
, unsigned int length
,
3067 const char *encoding
, int force_ellipses
,
3068 int quote_char
, int c_style_terminator
,
3069 const struct value_print_options
*options
)
3071 enum bfd_endian byte_order
= type_byte_order (type
);
3073 int width
= TYPE_LENGTH (type
);
3075 struct converted_character
*last
;
3079 unsigned long current_char
= 1;
3081 for (i
= 0; current_char
; ++i
)
3084 current_char
= extract_unsigned_integer (string
+ i
* width
,
3090 /* If the string was not truncated due to `set print elements', and
3091 the last byte of it is a null, we don't print that, in
3092 traditional C style. */
3093 if (c_style_terminator
3096 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
3097 width
, byte_order
) == 0))
3102 fputs_filtered ("\"\"", stream
);
3106 /* Arrange to iterate over the characters, in wchar_t form. */
3107 wchar_iterator
iter (string
, length
* width
, encoding
, width
);
3108 std::vector
<converted_character
> converted_chars
;
3110 /* Convert characters until the string is over or the maximum
3111 number of printed characters has been reached. */
3113 while (i
< options
->print_max
)
3119 /* Grab the next character and repeat count. */
3120 r
= count_next_character (&iter
, &converted_chars
);
3122 /* If less than zero, the end of the input string was reached. */
3126 /* Otherwise, add the count to the total print count and get
3127 the next character. */
3131 /* Get the last element and determine if the entire string was
3133 last
= &converted_chars
.back ();
3134 finished
= (last
->result
== wchar_iterate_eof
);
3136 /* Ensure that CONVERTED_CHARS is terminated. */
3137 last
->result
= wchar_iterate_eof
;
3139 /* WCHAR_BUF is the obstack we use to represent the string in
3141 auto_obstack wchar_buf
;
3143 /* Print the output string to the obstack. */
3144 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
3145 width
, byte_order
, options
);
3147 if (force_ellipses
|| !finished
)
3148 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
3150 /* OUTPUT is where we collect `char's for printing. */
3151 auto_obstack output
;
3153 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
3154 (gdb_byte
*) obstack_base (&wchar_buf
),
3155 obstack_object_size (&wchar_buf
),
3156 sizeof (gdb_wchar_t
), &output
, translit_char
);
3157 obstack_1grow (&output
, '\0');
3159 fputs_filtered ((const char *) obstack_base (&output
), stream
);
3162 /* Print a string from the inferior, starting at ADDR and printing up to LEN
3163 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
3164 stops at the first null byte, otherwise printing proceeds (including null
3165 bytes) until either print_max or LEN characters have been printed,
3166 whichever is smaller. ENCODING is the name of the string's
3167 encoding. It can be NULL, in which case the target encoding is
3171 val_print_string (struct type
*elttype
, const char *encoding
,
3172 CORE_ADDR addr
, int len
,
3173 struct ui_file
*stream
,
3174 const struct value_print_options
*options
)
3176 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
3177 int err
; /* Non-zero if we got a bad read. */
3178 int found_nul
; /* Non-zero if we found the nul char. */
3179 unsigned int fetchlimit
; /* Maximum number of chars to print. */
3181 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
; /* Dynamically growable fetch buffer. */
3182 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
3183 enum bfd_endian byte_order
= type_byte_order (elttype
);
3184 int width
= TYPE_LENGTH (elttype
);
3186 /* First we need to figure out the limit on the number of characters we are
3187 going to attempt to fetch and print. This is actually pretty simple. If
3188 LEN >= zero, then the limit is the minimum of LEN and print_max. If
3189 LEN is -1, then the limit is print_max. This is true regardless of
3190 whether print_max is zero, UINT_MAX (unlimited), or something in between,
3191 because finding the null byte (or available memory) is what actually
3192 limits the fetch. */
3194 fetchlimit
= (len
== -1 ? options
->print_max
: std::min ((unsigned) len
,
3195 options
->print_max
));
3197 err
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
3198 &buffer
, &bytes_read
);
3202 /* We now have either successfully filled the buffer to fetchlimit,
3203 or terminated early due to an error or finding a null char when
3206 /* Determine found_nul by looking at the last character read. */
3208 if (bytes_read
>= width
)
3209 found_nul
= extract_unsigned_integer (buffer
.get () + bytes_read
- width
,
3210 width
, byte_order
) == 0;
3211 if (len
== -1 && !found_nul
)
3215 /* We didn't find a NUL terminator we were looking for. Attempt
3216 to peek at the next character. If not successful, or it is not
3217 a null byte, then force ellipsis to be printed. */
3219 peekbuf
= (gdb_byte
*) alloca (width
);
3221 if (target_read_memory (addr
, peekbuf
, width
) == 0
3222 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
3225 else if ((len
>= 0 && err
!= 0) || (len
> bytes_read
/ width
))
3227 /* Getting an error when we have a requested length, or fetching less
3228 than the number of characters actually requested, always make us
3233 /* If we get an error before fetching anything, don't print a string.
3234 But if we fetch something and then get an error, print the string
3235 and then the error message. */
3236 if (err
== 0 || bytes_read
> 0)
3238 LA_PRINT_STRING (stream
, elttype
, buffer
.get (), bytes_read
/ width
,
3239 encoding
, force_ellipsis
, options
);
3244 std::string str
= memory_error_message (TARGET_XFER_E_IO
, gdbarch
, addr
);
3246 fprintf_filtered (stream
, _("<error: %ps>"),
3247 styled_string (metadata_style
.style (),
3251 return (bytes_read
/ width
);
3254 /* Handle 'show print max-depth'. */
3257 show_print_max_depth (struct ui_file
*file
, int from_tty
,
3258 struct cmd_list_element
*c
, const char *value
)
3260 fprintf_filtered (file
, _("Maximum print depth is %s.\n"), value
);
3264 /* The 'set input-radix' command writes to this auxiliary variable.
3265 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
3266 it is left unchanged. */
3268 static unsigned input_radix_1
= 10;
3270 /* Validate an input or output radix setting, and make sure the user
3271 knows what they really did here. Radix setting is confusing, e.g.
3272 setting the input radix to "10" never changes it! */
3275 set_input_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
3277 set_input_radix_1 (from_tty
, input_radix_1
);
3281 set_input_radix_1 (int from_tty
, unsigned radix
)
3283 /* We don't currently disallow any input radix except 0 or 1, which don't
3284 make any mathematical sense. In theory, we can deal with any input
3285 radix greater than 1, even if we don't have unique digits for every
3286 value from 0 to radix-1, but in practice we lose on large radix values.
3287 We should either fix the lossage or restrict the radix range more.
3292 input_radix_1
= input_radix
;
3293 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
3296 input_radix_1
= input_radix
= radix
;
3299 printf_filtered (_("Input radix now set to "
3300 "decimal %u, hex %x, octal %o.\n"),
3301 radix
, radix
, radix
);
3305 /* The 'set output-radix' command writes to this auxiliary variable.
3306 If the requested radix is valid, OUTPUT_RADIX is updated,
3307 otherwise, it is left unchanged. */
3309 static unsigned output_radix_1
= 10;
3312 set_output_radix (const char *args
, int from_tty
, struct cmd_list_element
*c
)
3314 set_output_radix_1 (from_tty
, output_radix_1
);
3318 set_output_radix_1 (int from_tty
, unsigned radix
)
3320 /* Validate the radix and disallow ones that we aren't prepared to
3321 handle correctly, leaving the radix unchanged. */
3325 user_print_options
.output_format
= 'x'; /* hex */
3328 user_print_options
.output_format
= 0; /* decimal */
3331 user_print_options
.output_format
= 'o'; /* octal */
3334 output_radix_1
= output_radix
;
3335 error (_("Unsupported output radix ``decimal %u''; "
3336 "output radix unchanged."),
3339 output_radix_1
= output_radix
= radix
;
3342 printf_filtered (_("Output radix now set to "
3343 "decimal %u, hex %x, octal %o.\n"),
3344 radix
, radix
, radix
);
3348 /* Set both the input and output radix at once. Try to set the output radix
3349 first, since it has the most restrictive range. An radix that is valid as
3350 an output radix is also valid as an input radix.
3352 It may be useful to have an unusual input radix. If the user wishes to
3353 set an input radix that is not valid as an output radix, he needs to use
3354 the 'set input-radix' command. */
3357 set_radix (const char *arg
, int from_tty
)
3361 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
3362 set_output_radix_1 (0, radix
);
3363 set_input_radix_1 (0, radix
);
3366 printf_filtered (_("Input and output radices now set to "
3367 "decimal %u, hex %x, octal %o.\n"),
3368 radix
, radix
, radix
);
3372 /* Show both the input and output radices. */
3375 show_radix (const char *arg
, int from_tty
)
3379 if (input_radix
== output_radix
)
3381 printf_filtered (_("Input and output radices set to "
3382 "decimal %u, hex %x, octal %o.\n"),
3383 input_radix
, input_radix
, input_radix
);
3387 printf_filtered (_("Input radix set to decimal "
3388 "%u, hex %x, octal %o.\n"),
3389 input_radix
, input_radix
, input_radix
);
3390 printf_filtered (_("Output radix set to decimal "
3391 "%u, hex %x, octal %o.\n"),
3392 output_radix
, output_radix
, output_radix
);
3399 set_print (const char *arg
, int from_tty
)
3402 "\"set print\" must be followed by the name of a print subcommand.\n");
3403 help_list (setprintlist
, "set print ", all_commands
, gdb_stdout
);
3407 show_print (const char *args
, int from_tty
)
3409 cmd_show_list (showprintlist
, from_tty
, "");
3413 set_print_raw (const char *arg
, int from_tty
)
3416 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
3417 help_list (setprintrawlist
, "set print raw ", all_commands
, gdb_stdout
);
3421 show_print_raw (const char *args
, int from_tty
)
3423 cmd_show_list (showprintrawlist
, from_tty
, "");
3426 /* Controls printing of vtbl's. */
3428 show_vtblprint (struct ui_file
*file
, int from_tty
,
3429 struct cmd_list_element
*c
, const char *value
)
3431 fprintf_filtered (file
, _("\
3432 Printing of C++ virtual function tables is %s.\n"),
3436 /* Controls looking up an object's derived type using what we find in
3439 show_objectprint (struct ui_file
*file
, int from_tty
,
3440 struct cmd_list_element
*c
,
3443 fprintf_filtered (file
, _("\
3444 Printing of object's derived type based on vtable info is %s.\n"),
3449 show_static_field_print (struct ui_file
*file
, int from_tty
,
3450 struct cmd_list_element
*c
,
3453 fprintf_filtered (file
,
3454 _("Printing of C++ static members is %s.\n"),
3460 /* A couple typedefs to make writing the options a bit more
3462 using boolean_option_def
3463 = gdb::option::boolean_option_def
<value_print_options
>;
3464 using uinteger_option_def
3465 = gdb::option::uinteger_option_def
<value_print_options
>;
3466 using zuinteger_unlimited_option_def
3467 = gdb::option::zuinteger_unlimited_option_def
<value_print_options
>;
3469 /* Definitions of options for the "print" and "compile print"
3471 static const gdb::option::option_def value_print_option_defs
[] = {
3473 boolean_option_def
{
3475 [] (value_print_options
*opt
) { return &opt
->addressprint
; },
3476 show_addressprint
, /* show_cmd_cb */
3477 N_("Set printing of addresses."),
3478 N_("Show printing of addresses."),
3479 NULL
, /* help_doc */
3482 boolean_option_def
{
3484 [] (value_print_options
*opt
) { return &opt
->prettyformat_arrays
; },
3485 show_prettyformat_arrays
, /* show_cmd_cb */
3486 N_("Set pretty formatting of arrays."),
3487 N_("Show pretty formatting of arrays."),
3488 NULL
, /* help_doc */
3491 boolean_option_def
{
3493 [] (value_print_options
*opt
) { return &opt
->print_array_indexes
; },
3494 show_print_array_indexes
, /* show_cmd_cb */
3495 N_("Set printing of array indexes."),
3496 N_("Show printing of array indexes."),
3497 NULL
, /* help_doc */
3500 uinteger_option_def
{
3502 [] (value_print_options
*opt
) { return &opt
->print_max
; },
3503 show_print_max
, /* show_cmd_cb */
3504 N_("Set limit on string chars or array elements to print."),
3505 N_("Show limit on string chars or array elements to print."),
3506 N_("\"unlimited\" causes there to be no limit."),
3509 zuinteger_unlimited_option_def
{
3511 [] (value_print_options
*opt
) { return &opt
->max_depth
; },
3512 show_print_max_depth
, /* show_cmd_cb */
3513 N_("Set maximum print depth for nested structures, unions and arrays."),
3514 N_("Show maximum print depth for nested structures, unions, and arrays."),
3515 N_("When structures, unions, or arrays are nested beyond this depth then they\n\
3516 will be replaced with either '{...}' or '(...)' depending on the language.\n\
3517 Use \"unlimited\" to print the complete structure.")
3520 boolean_option_def
{
3522 [] (value_print_options
*opt
) { return &opt
->stop_print_at_null
; },
3523 show_stop_print_at_null
, /* show_cmd_cb */
3524 N_("Set printing of char arrays to stop at first null char."),
3525 N_("Show printing of char arrays to stop at first null char."),
3526 NULL
, /* help_doc */
3529 boolean_option_def
{
3531 [] (value_print_options
*opt
) { return &opt
->objectprint
; },
3532 show_objectprint
, /* show_cmd_cb */
3533 _("Set printing of C++ virtual function tables."),
3534 _("Show printing of C++ virtual function tables."),
3535 NULL
, /* help_doc */
3538 boolean_option_def
{
3540 [] (value_print_options
*opt
) { return &opt
->prettyformat_structs
; },
3541 show_prettyformat_structs
, /* show_cmd_cb */
3542 N_("Set pretty formatting of structures."),
3543 N_("Show pretty formatting of structures."),
3544 NULL
, /* help_doc */
3547 boolean_option_def
{
3549 [] (value_print_options
*opt
) { return &opt
->raw
; },
3550 NULL
, /* show_cmd_cb */
3551 N_("Set whether to print values in raw form."),
3552 N_("Show whether to print values in raw form."),
3553 N_("If set, values are printed in raw form, bypassing any\n\
3554 pretty-printers for that value.")
3557 uinteger_option_def
{
3559 [] (value_print_options
*opt
) { return &opt
->repeat_count_threshold
; },
3560 show_repeat_count_threshold
, /* show_cmd_cb */
3561 N_("Set threshold for repeated print elements."),
3562 N_("Show threshold for repeated print elements."),
3563 N_("\"unlimited\" causes all elements to be individually printed."),
3566 boolean_option_def
{
3568 [] (value_print_options
*opt
) { return &opt
->static_field_print
; },
3569 show_static_field_print
, /* show_cmd_cb */
3570 N_("Set printing of C++ static members."),
3571 N_("Show printing of C++ static members."),
3572 NULL
, /* help_doc */
3575 boolean_option_def
{
3577 [] (value_print_options
*opt
) { return &opt
->symbol_print
; },
3578 show_symbol_print
, /* show_cmd_cb */
3579 N_("Set printing of symbol names when printing pointers."),
3580 N_("Show printing of symbol names when printing pointers."),
3581 NULL
, /* help_doc */
3584 boolean_option_def
{
3586 [] (value_print_options
*opt
) { return &opt
->unionprint
; },
3587 show_unionprint
, /* show_cmd_cb */
3588 N_("Set printing of unions interior to structures."),
3589 N_("Show printing of unions interior to structures."),
3590 NULL
, /* help_doc */
3593 boolean_option_def
{
3595 [] (value_print_options
*opt
) { return &opt
->vtblprint
; },
3596 show_vtblprint
, /* show_cmd_cb */
3597 N_("Set printing of C++ virtual function tables."),
3598 N_("Show printing of C++ virtual function tables."),
3599 NULL
, /* help_doc */
3603 /* See valprint.h. */
3605 gdb::option::option_def_group
3606 make_value_print_options_def_group (value_print_options
*opts
)
3608 return {{value_print_option_defs
}, opts
};
3611 void _initialize_valprint ();
3613 _initialize_valprint ()
3615 cmd_list_element
*cmd
;
3617 add_prefix_cmd ("print", no_class
, set_print
,
3618 _("Generic command for setting how things print."),
3619 &setprintlist
, "set print ", 0, &setlist
);
3620 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
3621 /* Prefer set print to set prompt. */
3622 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
3624 add_prefix_cmd ("print", no_class
, show_print
,
3625 _("Generic command for showing print settings."),
3626 &showprintlist
, "show print ", 0, &showlist
);
3627 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
3628 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
3630 cmd
= add_prefix_cmd ("raw", no_class
, set_print_raw
,
3632 Generic command for setting what things to print in \"raw\" mode."),
3633 &setprintrawlist
, "set print raw ", 0,
3635 deprecate_cmd (cmd
, nullptr);
3637 cmd
= add_prefix_cmd ("raw", no_class
, show_print_raw
,
3638 _("Generic command for showing \"print raw\" settings."),
3639 &showprintrawlist
, "show print raw ", 0,
3641 deprecate_cmd (cmd
, nullptr);
3643 gdb::option::add_setshow_cmds_for_options
3644 (class_support
, &user_print_options
, value_print_option_defs
,
3645 &setprintlist
, &showprintlist
);
3647 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
3649 Set default input radix for entering numbers."), _("\
3650 Show default input radix for entering numbers."), NULL
,
3653 &setlist
, &showlist
);
3655 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
3657 Set default output radix for printing of values."), _("\
3658 Show default output radix for printing of values."), NULL
,
3661 &setlist
, &showlist
);
3663 /* The "set radix" and "show radix" commands are special in that
3664 they are like normal set and show commands but allow two normally
3665 independent variables to be either set or shown with a single
3666 command. So the usual deprecated_add_set_cmd() and [deleted]
3667 add_show_from_set() commands aren't really appropriate. */
3668 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3669 longer true - show can display anything. */
3670 add_cmd ("radix", class_support
, set_radix
, _("\
3671 Set default input and output number radices.\n\
3672 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
3673 Without an argument, sets both radices back to the default value of 10."),
3675 add_cmd ("radix", class_support
, show_radix
, _("\
3676 Show the default input and output number radices.\n\
3677 Use 'show input-radix' or 'show output-radix' to independently show each."),