1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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 "floatformat.h"
33 #include "extension.h"
35 #include "gdb_obstack.h"
37 #include "typeprint.h"
41 /* Maximum number of wchars returned from wchar_iterate. */
44 /* A convenience macro to compute the size of a wchar_t buffer containing X
46 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
48 /* Character buffer size saved while iterating over wchars. */
49 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
51 /* A structure to encapsulate state information from iterated
52 character conversions. */
53 struct converted_character
55 /* The number of characters converted. */
58 /* The result of the conversion. See charset.h for more. */
59 enum wchar_iterate_result result
;
61 /* The (saved) converted character(s). */
62 gdb_wchar_t chars
[WCHAR_BUFLEN_MAX
];
64 /* The first converted target byte. */
67 /* The number of bytes converted. */
70 /* How many times this character(s) is repeated. */
74 typedef struct converted_character converted_character_d
;
75 DEF_VEC_O (converted_character_d
);
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 show_print (char *, int);
88 static void set_print (char *, int);
90 static void set_radix (char *, int);
92 static void show_radix (char *, int);
94 static void set_input_radix (char *, int, struct cmd_list_element
*);
96 static void set_input_radix_1 (int, unsigned);
98 static void set_output_radix (char *, int, struct cmd_list_element
*);
100 static void set_output_radix_1 (int, unsigned);
102 static void val_print_type_code_flags (struct type
*type
,
103 const gdb_byte
*valaddr
,
104 struct ui_file
*stream
);
106 void _initialize_valprint (void);
108 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
110 struct value_print_options user_print_options
=
112 Val_prettyformat_default
, /* prettyformat */
113 0, /* prettyformat_arrays */
114 0, /* prettyformat_structs */
117 1, /* addressprint */
119 PRINT_MAX_DEFAULT
, /* print_max */
120 10, /* repeat_count_threshold */
121 0, /* output_format */
123 0, /* stop_print_at_null */
124 0, /* print_array_indexes */
126 1, /* static_field_print */
127 1, /* pascal_static_field_print */
133 /* Initialize *OPTS to be a copy of the user print options. */
135 get_user_print_options (struct value_print_options
*opts
)
137 *opts
= user_print_options
;
140 /* Initialize *OPTS to be a copy of the user print options, but with
141 pretty-formatting disabled. */
143 get_no_prettyformat_print_options (struct value_print_options
*opts
)
145 *opts
= user_print_options
;
146 opts
->prettyformat
= Val_no_prettyformat
;
149 /* Initialize *OPTS to be a copy of the user print options, but using
150 FORMAT as the formatting option. */
152 get_formatted_print_options (struct value_print_options
*opts
,
155 *opts
= user_print_options
;
156 opts
->format
= format
;
160 show_print_max (struct ui_file
*file
, int from_tty
,
161 struct cmd_list_element
*c
, const char *value
)
163 fprintf_filtered (file
,
164 _("Limit on string chars or array "
165 "elements to print is %s.\n"),
170 /* Default input and output radixes, and output format letter. */
172 unsigned input_radix
= 10;
174 show_input_radix (struct ui_file
*file
, int from_tty
,
175 struct cmd_list_element
*c
, const char *value
)
177 fprintf_filtered (file
,
178 _("Default input radix for entering numbers is %s.\n"),
182 unsigned output_radix
= 10;
184 show_output_radix (struct ui_file
*file
, int from_tty
,
185 struct cmd_list_element
*c
, const char *value
)
187 fprintf_filtered (file
,
188 _("Default output radix for printing of values is %s.\n"),
192 /* By default we print arrays without printing the index of each element in
193 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
196 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
197 struct cmd_list_element
*c
, const char *value
)
199 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
202 /* Print repeat counts if there are more than this many repetitions of an
203 element in an array. Referenced by the low level language dependent
207 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
208 struct cmd_list_element
*c
, const char *value
)
210 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
214 /* If nonzero, stops printing of char arrays at first null. */
217 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
218 struct cmd_list_element
*c
, const char *value
)
220 fprintf_filtered (file
,
221 _("Printing of char arrays to stop "
222 "at first null char is %s.\n"),
226 /* Controls pretty printing of structures. */
229 show_prettyformat_structs (struct ui_file
*file
, int from_tty
,
230 struct cmd_list_element
*c
, const char *value
)
232 fprintf_filtered (file
, _("Pretty formatting of structures is %s.\n"), value
);
235 /* Controls pretty printing of arrays. */
238 show_prettyformat_arrays (struct ui_file
*file
, int from_tty
,
239 struct cmd_list_element
*c
, const char *value
)
241 fprintf_filtered (file
, _("Pretty formatting of arrays is %s.\n"), value
);
244 /* If nonzero, causes unions inside structures or other unions to be
248 show_unionprint (struct ui_file
*file
, int from_tty
,
249 struct cmd_list_element
*c
, const char *value
)
251 fprintf_filtered (file
,
252 _("Printing of unions interior to structures is %s.\n"),
256 /* If nonzero, causes machine addresses to be printed in certain contexts. */
259 show_addressprint (struct ui_file
*file
, int from_tty
,
260 struct cmd_list_element
*c
, const char *value
)
262 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
266 show_symbol_print (struct ui_file
*file
, int from_tty
,
267 struct cmd_list_element
*c
, const char *value
)
269 fprintf_filtered (file
,
270 _("Printing of symbols when printing pointers is %s.\n"),
276 /* A helper function for val_print. When printing in "summary" mode,
277 we want to print scalar arguments, but not aggregate arguments.
278 This function distinguishes between the two. */
281 val_print_scalar_type_p (struct type
*type
)
283 type
= check_typedef (type
);
284 while (TYPE_IS_REFERENCE (type
))
286 type
= TYPE_TARGET_TYPE (type
);
287 type
= check_typedef (type
);
289 switch (TYPE_CODE (type
))
291 case TYPE_CODE_ARRAY
:
292 case TYPE_CODE_STRUCT
:
293 case TYPE_CODE_UNION
:
295 case TYPE_CODE_STRING
:
302 /* See its definition in value.h. */
305 valprint_check_validity (struct ui_file
*stream
,
307 LONGEST embedded_offset
,
308 const struct value
*val
)
310 type
= check_typedef (type
);
312 if (type_not_associated (type
))
314 val_print_not_associated (stream
);
318 if (type_not_allocated (type
))
320 val_print_not_allocated (stream
);
324 if (TYPE_CODE (type
) != TYPE_CODE_UNION
325 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
326 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
328 if (value_bits_any_optimized_out (val
,
329 TARGET_CHAR_BIT
* embedded_offset
,
330 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
332 val_print_optimized_out (val
, stream
);
336 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
337 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
339 const int is_ref
= TYPE_CODE (type
) == TYPE_CODE_REF
;
340 int ref_is_addressable
= 0;
344 const struct value
*deref_val
= coerce_ref_if_computed (val
);
346 if (deref_val
!= NULL
)
347 ref_is_addressable
= value_lval_const (deref_val
) == lval_memory
;
350 if (!is_ref
|| !ref_is_addressable
)
351 fputs_filtered (_("<synthetic pointer>"), stream
);
353 /* C++ references should be valid even if they're synthetic. */
357 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
359 val_print_unavailable (stream
);
368 val_print_optimized_out (const struct value
*val
, struct ui_file
*stream
)
370 if (val
!= NULL
&& value_lval_const (val
) == lval_register
)
371 val_print_not_saved (stream
);
373 fprintf_filtered (stream
, _("<optimized out>"));
377 val_print_not_saved (struct ui_file
*stream
)
379 fprintf_filtered (stream
, _("<not saved>"));
383 val_print_unavailable (struct ui_file
*stream
)
385 fprintf_filtered (stream
, _("<unavailable>"));
389 val_print_invalid_address (struct ui_file
*stream
)
391 fprintf_filtered (stream
, _("<invalid address>"));
394 /* Print a pointer based on the type of its target.
396 Arguments to this functions are roughly the same as those in
397 generic_val_print. A difference is that ADDRESS is the address to print,
398 with embedded_offset already added. ELTTYPE represents
399 the pointed type after check_typedef. */
402 print_unpacked_pointer (struct type
*type
, struct type
*elttype
,
403 CORE_ADDR address
, struct ui_file
*stream
,
404 const struct value_print_options
*options
)
406 struct gdbarch
*gdbarch
= get_type_arch (type
);
408 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
410 /* Try to print what function it points to. */
411 print_function_pointer_address (options
, gdbarch
, address
, stream
);
415 if (options
->symbol_print
)
416 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
417 else if (options
->addressprint
)
418 fputs_filtered (paddress (gdbarch
, address
), stream
);
421 /* generic_val_print helper for TYPE_CODE_ARRAY. */
424 generic_val_print_array (struct type
*type
,
425 int embedded_offset
, CORE_ADDR address
,
426 struct ui_file
*stream
, int recurse
,
427 struct value
*original_value
,
428 const struct value_print_options
*options
,
430 generic_val_print_decorations
*decorations
)
432 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
433 struct type
*elttype
= check_typedef (unresolved_elttype
);
435 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
437 LONGEST low_bound
, high_bound
;
439 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
440 error (_("Could not determine the array high bound"));
442 if (options
->prettyformat_arrays
)
444 print_spaces_filtered (2 + 2 * recurse
, stream
);
447 fputs_filtered (decorations
->array_start
, stream
);
448 val_print_array_elements (type
, embedded_offset
,
450 recurse
, original_value
, options
, 0);
451 fputs_filtered (decorations
->array_end
, stream
);
455 /* Array of unspecified length: treat like pointer to first elt. */
456 print_unpacked_pointer (type
, elttype
, address
+ embedded_offset
, stream
,
462 /* generic_val_print helper for TYPE_CODE_PTR. */
465 generic_val_print_ptr (struct type
*type
,
466 int embedded_offset
, struct ui_file
*stream
,
467 struct value
*original_value
,
468 const struct value_print_options
*options
)
470 struct gdbarch
*gdbarch
= get_type_arch (type
);
471 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
473 if (options
->format
&& options
->format
!= 's')
475 val_print_scalar_formatted (type
, embedded_offset
,
476 original_value
, options
, 0, stream
);
480 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE(type
);
481 struct type
*elttype
= check_typedef (unresolved_elttype
);
482 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
483 CORE_ADDR addr
= unpack_pointer (type
,
484 valaddr
+ embedded_offset
* unit_size
);
486 print_unpacked_pointer (type
, elttype
, addr
, stream
, options
);
491 /* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
494 generic_val_print_memberptr (struct type
*type
,
495 int embedded_offset
, struct ui_file
*stream
,
496 struct value
*original_value
,
497 const struct value_print_options
*options
)
499 val_print_scalar_formatted (type
, embedded_offset
,
500 original_value
, options
, 0, stream
);
503 /* Print '@' followed by the address contained in ADDRESS_BUFFER. */
506 print_ref_address (struct type
*type
, const gdb_byte
*address_buffer
,
507 int embedded_offset
, struct ui_file
*stream
)
509 struct gdbarch
*gdbarch
= get_type_arch (type
);
511 if (address_buffer
!= NULL
)
514 = extract_typed_address (address_buffer
+ embedded_offset
, type
);
516 fprintf_filtered (stream
, "@");
517 fputs_filtered (paddress (gdbarch
, address
), stream
);
519 /* Else: we have a non-addressable value, such as a DW_AT_const_value. */
522 /* If VAL is addressable, return the value contents buffer of a value that
523 represents a pointer to VAL. Otherwise return NULL. */
525 static const gdb_byte
*
526 get_value_addr_contents (struct value
*deref_val
)
528 gdb_assert (deref_val
!= NULL
);
530 if (value_lval_const (deref_val
) == lval_memory
)
531 return value_contents_for_printing_const (value_addr (deref_val
));
534 /* We have a non-addressable value, such as a DW_AT_const_value. */
539 /* generic_val_print helper for TYPE_CODE_{RVALUE_,}REF. */
542 generic_val_print_ref (struct type
*type
,
543 int embedded_offset
, struct ui_file
*stream
, int recurse
,
544 struct value
*original_value
,
545 const struct value_print_options
*options
)
547 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
548 struct value
*deref_val
= NULL
;
549 const int value_is_synthetic
550 = value_bits_synthetic_pointer (original_value
,
551 TARGET_CHAR_BIT
* embedded_offset
,
552 TARGET_CHAR_BIT
* TYPE_LENGTH (type
));
553 const int must_coerce_ref
= ((options
->addressprint
&& value_is_synthetic
)
554 || options
->deref_ref
);
555 const int type_is_defined
= TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
;
556 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
558 if (must_coerce_ref
&& type_is_defined
)
560 deref_val
= coerce_ref_if_computed (original_value
);
562 if (deref_val
!= NULL
)
564 /* More complicated computed references are not supported. */
565 gdb_assert (embedded_offset
== 0);
568 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
569 unpack_pointer (type
, valaddr
+ embedded_offset
));
571 /* Else, original_value isn't a synthetic reference or we don't have to print
572 the reference's contents.
574 Notice that for references to TYPE_CODE_STRUCT, 'set print object on' will
575 cause original_value to be a not_lval instead of an lval_computed,
576 which will make value_bits_synthetic_pointer return false.
577 This happens because if options->objectprint is true, c_value_print will
578 overwrite original_value's contents with the result of coercing
579 the reference through value_addr, and then set its type back to
580 TYPE_CODE_REF. In that case we don't have to coerce the reference again;
581 we can simply treat it as non-synthetic and move on. */
583 if (options
->addressprint
)
585 const gdb_byte
*address
= (value_is_synthetic
&& type_is_defined
586 ? get_value_addr_contents (deref_val
)
589 print_ref_address (type
, address
, embedded_offset
, stream
);
591 if (options
->deref_ref
)
592 fputs_filtered (": ", stream
);
595 if (options
->deref_ref
)
598 common_val_print (deref_val
, stream
, recurse
, options
,
601 fputs_filtered ("???", stream
);
605 /* Helper function for generic_val_print_enum.
606 This is also used to print enums in TYPE_CODE_FLAGS values. */
609 generic_val_print_enum_1 (struct type
*type
, LONGEST val
,
610 struct ui_file
*stream
)
615 len
= TYPE_NFIELDS (type
);
616 for (i
= 0; i
< len
; i
++)
619 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
626 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
628 else if (TYPE_FLAG_ENUM (type
))
632 /* We have a "flag" enum, so we try to decompose it into
633 pieces as appropriate. A flag enum has disjoint
634 constants by definition. */
635 fputs_filtered ("(", stream
);
636 for (i
= 0; i
< len
; ++i
)
640 if ((val
& TYPE_FIELD_ENUMVAL (type
, i
)) != 0)
643 fputs_filtered (" | ", stream
);
646 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
647 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
651 if (first
|| val
!= 0)
654 fputs_filtered (" | ", stream
);
655 fputs_filtered ("unknown: ", stream
);
656 print_longest (stream
, 'd', 0, val
);
659 fputs_filtered (")", stream
);
662 print_longest (stream
, 'd', 0, val
);
665 /* generic_val_print helper for TYPE_CODE_ENUM. */
668 generic_val_print_enum (struct type
*type
,
669 int embedded_offset
, struct ui_file
*stream
,
670 struct value
*original_value
,
671 const struct value_print_options
*options
)
674 struct gdbarch
*gdbarch
= get_type_arch (type
);
675 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
679 val_print_scalar_formatted (type
, embedded_offset
,
680 original_value
, options
, 0, stream
);
684 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
686 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
688 generic_val_print_enum_1 (type
, val
, stream
);
692 /* generic_val_print helper for TYPE_CODE_FLAGS. */
695 generic_val_print_flags (struct type
*type
,
696 int embedded_offset
, struct ui_file
*stream
,
697 struct value
*original_value
,
698 const struct value_print_options
*options
)
702 val_print_scalar_formatted (type
, embedded_offset
, original_value
,
706 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
708 val_print_type_code_flags (type
, valaddr
+ embedded_offset
, stream
);
712 /* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
715 generic_val_print_func (struct type
*type
,
716 int embedded_offset
, CORE_ADDR address
,
717 struct ui_file
*stream
,
718 struct value
*original_value
,
719 const struct value_print_options
*options
)
721 struct gdbarch
*gdbarch
= get_type_arch (type
);
725 val_print_scalar_formatted (type
, embedded_offset
,
726 original_value
, options
, 0, stream
);
730 /* FIXME, we should consider, at least for ANSI C language,
731 eliminating the distinction made between FUNCs and POINTERs
733 fprintf_filtered (stream
, "{");
734 type_print (type
, "", stream
, -1);
735 fprintf_filtered (stream
, "} ");
736 /* Try to print what function it points to, and its address. */
737 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
741 /* generic_val_print helper for TYPE_CODE_BOOL. */
744 generic_val_print_bool (struct type
*type
,
745 int embedded_offset
, struct ui_file
*stream
,
746 struct value
*original_value
,
747 const struct value_print_options
*options
,
748 const struct generic_val_print_decorations
*decorations
)
751 struct gdbarch
*gdbarch
= get_type_arch (type
);
752 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
754 if (options
->format
|| options
->output_format
)
756 struct value_print_options opts
= *options
;
757 opts
.format
= (options
->format
? options
->format
758 : options
->output_format
);
759 val_print_scalar_formatted (type
, embedded_offset
,
760 original_value
, &opts
, 0, stream
);
764 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
766 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
768 fputs_filtered (decorations
->false_name
, stream
);
770 fputs_filtered (decorations
->true_name
, stream
);
772 print_longest (stream
, 'd', 0, val
);
776 /* generic_val_print helper for TYPE_CODE_INT. */
779 generic_val_print_int (struct type
*type
,
780 int embedded_offset
, struct ui_file
*stream
,
781 struct value
*original_value
,
782 const struct value_print_options
*options
)
784 struct value_print_options opts
= *options
;
786 opts
.format
= (options
->format
? options
->format
787 : options
->output_format
);
788 val_print_scalar_formatted (type
, embedded_offset
,
789 original_value
, &opts
, 0, stream
);
792 /* generic_val_print helper for TYPE_CODE_CHAR. */
795 generic_val_print_char (struct type
*type
, struct type
*unresolved_type
,
797 struct ui_file
*stream
,
798 struct value
*original_value
,
799 const struct value_print_options
*options
)
802 struct gdbarch
*gdbarch
= get_type_arch (type
);
803 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
805 if (options
->format
|| options
->output_format
)
807 struct value_print_options opts
= *options
;
809 opts
.format
= (options
->format
? options
->format
810 : options
->output_format
);
811 val_print_scalar_formatted (type
, embedded_offset
,
812 original_value
, &opts
, 0, stream
);
816 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
818 val
= unpack_long (type
, valaddr
+ embedded_offset
* unit_size
);
819 if (TYPE_UNSIGNED (type
))
820 fprintf_filtered (stream
, "%u", (unsigned int) val
);
822 fprintf_filtered (stream
, "%d", (int) val
);
823 fputs_filtered (" ", stream
);
824 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
828 /* generic_val_print helper for TYPE_CODE_FLT. */
831 generic_val_print_float (struct type
*type
,
832 int embedded_offset
, struct ui_file
*stream
,
833 struct value
*original_value
,
834 const struct value_print_options
*options
)
836 struct gdbarch
*gdbarch
= get_type_arch (type
);
837 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
841 val_print_scalar_formatted (type
, embedded_offset
,
842 original_value
, options
, 0, stream
);
846 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
848 print_floating (valaddr
+ embedded_offset
* unit_size
, type
, stream
);
852 /* generic_val_print helper for TYPE_CODE_DECFLOAT. */
855 generic_val_print_decfloat (struct type
*type
,
856 int embedded_offset
, struct ui_file
*stream
,
857 struct value
*original_value
,
858 const struct value_print_options
*options
)
860 struct gdbarch
*gdbarch
= get_type_arch (type
);
861 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
864 val_print_scalar_formatted (type
, embedded_offset
, original_value
,
868 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
870 print_decimal_floating (valaddr
+ embedded_offset
* unit_size
, type
,
875 /* generic_val_print helper for TYPE_CODE_COMPLEX. */
878 generic_val_print_complex (struct type
*type
,
879 int embedded_offset
, struct ui_file
*stream
,
880 struct value
*original_value
,
881 const struct value_print_options
*options
,
882 const struct generic_val_print_decorations
885 struct gdbarch
*gdbarch
= get_type_arch (type
);
886 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
887 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
889 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
891 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
892 embedded_offset
, original_value
, options
, 0,
895 print_floating (valaddr
+ embedded_offset
* unit_size
,
896 TYPE_TARGET_TYPE (type
), stream
);
897 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
899 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
901 + type_length_units (TYPE_TARGET_TYPE (type
)),
902 original_value
, options
, 0, stream
);
904 print_floating (valaddr
+ embedded_offset
* unit_size
905 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
906 TYPE_TARGET_TYPE (type
), stream
);
907 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
910 /* A generic val_print that is suitable for use by language
911 implementations of the la_val_print method. This function can
912 handle most type codes, though not all, notably exception
913 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
916 Most arguments are as to val_print.
918 The additional DECORATIONS argument can be used to customize the
919 output in some small, language-specific ways. */
922 generic_val_print (struct type
*type
,
923 int embedded_offset
, CORE_ADDR address
,
924 struct ui_file
*stream
, int recurse
,
925 struct value
*original_value
,
926 const struct value_print_options
*options
,
927 const struct generic_val_print_decorations
*decorations
)
929 struct type
*unresolved_type
= type
;
931 type
= check_typedef (type
);
932 switch (TYPE_CODE (type
))
934 case TYPE_CODE_ARRAY
:
935 generic_val_print_array (type
, embedded_offset
, address
, stream
,
936 recurse
, original_value
, options
, decorations
);
939 case TYPE_CODE_MEMBERPTR
:
940 generic_val_print_memberptr (type
, embedded_offset
, stream
,
941 original_value
, options
);
945 generic_val_print_ptr (type
, embedded_offset
, stream
,
946 original_value
, options
);
950 case TYPE_CODE_RVALUE_REF
:
951 generic_val_print_ref (type
, embedded_offset
, stream
, recurse
,
952 original_value
, options
);
956 generic_val_print_enum (type
, embedded_offset
, stream
,
957 original_value
, options
);
960 case TYPE_CODE_FLAGS
:
961 generic_val_print_flags (type
, embedded_offset
, stream
,
962 original_value
, options
);
966 case TYPE_CODE_METHOD
:
967 generic_val_print_func (type
, embedded_offset
, address
, stream
,
968 original_value
, options
);
972 generic_val_print_bool (type
, embedded_offset
, stream
,
973 original_value
, options
, decorations
);
976 case TYPE_CODE_RANGE
:
977 /* FIXME: create_static_range_type does not set the unsigned bit in a
978 range type (I think it probably should copy it from the
979 target type), so we won't print values which are too large to
980 fit in a signed integer correctly. */
981 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
982 print with the target type, though, because the size of our
983 type and the target type might differ). */
988 generic_val_print_int (type
, embedded_offset
, stream
,
989 original_value
, options
);
993 generic_val_print_char (type
, unresolved_type
, embedded_offset
,
994 stream
, original_value
, options
);
998 generic_val_print_float (type
, embedded_offset
, stream
,
999 original_value
, options
);
1002 case TYPE_CODE_DECFLOAT
:
1003 generic_val_print_decfloat (type
, embedded_offset
, stream
,
1004 original_value
, options
);
1007 case TYPE_CODE_VOID
:
1008 fputs_filtered (decorations
->void_name
, stream
);
1011 case TYPE_CODE_ERROR
:
1012 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1015 case TYPE_CODE_UNDEF
:
1016 /* This happens (without TYPE_STUB set) on systems which don't use
1017 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1018 and no complete type for struct foo in that file. */
1019 fprintf_filtered (stream
, _("<incomplete type>"));
1022 case TYPE_CODE_COMPLEX
:
1023 generic_val_print_complex (type
, embedded_offset
, stream
,
1024 original_value
, options
, decorations
);
1027 case TYPE_CODE_UNION
:
1028 case TYPE_CODE_STRUCT
:
1029 case TYPE_CODE_METHODPTR
:
1031 error (_("Unhandled type code %d in symbol table."),
1037 /* Print using the given LANGUAGE the data of type TYPE located at
1038 VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came
1039 from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto
1040 stdio stream STREAM according to OPTIONS. VAL is the whole object
1041 that came from ADDRESS.
1043 The language printers will pass down an adjusted EMBEDDED_OFFSET to
1044 further helper subroutines as subfields of TYPE are printed. In
1045 such cases, VAL is passed down unadjusted, so
1046 that VAL can be queried for metadata about the contents data being
1047 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
1048 buffer. For example: "has this field been optimized out", or "I'm
1049 printing an object while inspecting a traceframe; has this
1050 particular piece of data been collected?".
1052 RECURSE indicates the amount of indentation to supply before
1053 continuation lines; this amount is roughly twice the value of
1057 val_print (struct type
*type
, LONGEST embedded_offset
,
1058 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
1060 const struct value_print_options
*options
,
1061 const struct language_defn
*language
)
1064 struct value_print_options local_opts
= *options
;
1065 struct type
*real_type
= check_typedef (type
);
1067 if (local_opts
.prettyformat
== Val_prettyformat_default
)
1068 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
1069 ? Val_prettyformat
: Val_no_prettyformat
);
1073 /* Ensure that the type is complete and not just a stub. If the type is
1074 only a stub and we can't find and substitute its complete type, then
1075 print appropriate string and return. */
1077 if (TYPE_STUB (real_type
))
1079 fprintf_filtered (stream
, _("<incomplete type>"));
1084 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
1089 ret
= apply_ext_lang_val_pretty_printer (type
, embedded_offset
,
1090 address
, stream
, recurse
,
1091 val
, options
, language
);
1096 /* Handle summary mode. If the value is a scalar, print it;
1097 otherwise, print an ellipsis. */
1098 if (options
->summary
&& !val_print_scalar_type_p (type
))
1100 fprintf_filtered (stream
, "...");
1106 language
->la_val_print (type
, embedded_offset
, address
,
1107 stream
, recurse
, val
,
1110 CATCH (except
, RETURN_MASK_ERROR
)
1112 fprintf_filtered (stream
, _("<error reading variable>"));
1117 /* Check whether the value VAL is printable. Return 1 if it is;
1118 return 0 and print an appropriate error message to STREAM according to
1119 OPTIONS if it is not. */
1122 value_check_printable (struct value
*val
, struct ui_file
*stream
,
1123 const struct value_print_options
*options
)
1127 fprintf_filtered (stream
, _("<address of value unknown>"));
1131 if (value_entirely_optimized_out (val
))
1133 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1134 fprintf_filtered (stream
, "...");
1136 val_print_optimized_out (val
, stream
);
1140 if (value_entirely_unavailable (val
))
1142 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
1143 fprintf_filtered (stream
, "...");
1145 val_print_unavailable (stream
);
1149 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
1151 fprintf_filtered (stream
, _("<internal function %s>"),
1152 value_internal_function_name (val
));
1156 if (type_not_associated (value_type (val
)))
1158 val_print_not_associated (stream
);
1162 if (type_not_allocated (value_type (val
)))
1164 val_print_not_allocated (stream
);
1171 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
1174 This is a preferable interface to val_print, above, because it uses
1175 GDB's value mechanism. */
1178 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
1179 const struct value_print_options
*options
,
1180 const struct language_defn
*language
)
1182 if (!value_check_printable (val
, stream
, options
))
1185 if (language
->la_language
== language_ada
)
1186 /* The value might have a dynamic type, which would cause trouble
1187 below when trying to extract the value contents (since the value
1188 size is determined from the type size which is unknown). So
1189 get a fixed representation of our value. */
1190 val
= ada_to_fixed_value (val
);
1192 if (value_lazy (val
))
1193 value_fetch_lazy (val
);
1195 val_print (value_type (val
),
1196 value_embedded_offset (val
), value_address (val
),
1198 val
, options
, language
);
1201 /* Print on stream STREAM the value VAL according to OPTIONS. The value
1202 is printed using the current_language syntax. */
1205 value_print (struct value
*val
, struct ui_file
*stream
,
1206 const struct value_print_options
*options
)
1208 if (!value_check_printable (val
, stream
, options
))
1214 = apply_ext_lang_val_pretty_printer (value_type (val
),
1215 value_embedded_offset (val
),
1216 value_address (val
),
1218 val
, options
, current_language
);
1224 LA_VALUE_PRINT (val
, stream
, options
);
1228 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
1229 struct ui_file
*stream
)
1231 ULONGEST val
= unpack_long (type
, valaddr
);
1232 int field
, nfields
= TYPE_NFIELDS (type
);
1233 struct gdbarch
*gdbarch
= get_type_arch (type
);
1234 struct type
*bool_type
= builtin_type (gdbarch
)->builtin_bool
;
1236 fputs_filtered ("[", stream
);
1237 for (field
= 0; field
< nfields
; field
++)
1239 if (TYPE_FIELD_NAME (type
, field
)[0] != '\0')
1241 struct type
*field_type
= TYPE_FIELD_TYPE (type
, field
);
1243 if (field_type
== bool_type
1244 /* We require boolean types here to be one bit wide. This is a
1245 problematic place to notify the user of an internal error
1246 though. Instead just fall through and print the field as an
1248 && TYPE_FIELD_BITSIZE (type
, field
) == 1)
1250 if (val
& ((ULONGEST
)1 << TYPE_FIELD_BITPOS (type
, field
)))
1251 fprintf_filtered (stream
, " %s",
1252 TYPE_FIELD_NAME (type
, field
));
1256 unsigned field_len
= TYPE_FIELD_BITSIZE (type
, field
);
1258 = val
>> (TYPE_FIELD_BITPOS (type
, field
) - field_len
+ 1);
1260 if (field_len
< sizeof (ULONGEST
) * TARGET_CHAR_BIT
)
1261 field_val
&= ((ULONGEST
) 1 << field_len
) - 1;
1262 fprintf_filtered (stream
, " %s=",
1263 TYPE_FIELD_NAME (type
, field
));
1264 if (TYPE_CODE (field_type
) == TYPE_CODE_ENUM
)
1265 generic_val_print_enum_1 (field_type
, field_val
, stream
);
1267 print_longest (stream
, 'd', 0, field_val
);
1271 fputs_filtered (" ]", stream
);
1274 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
1275 according to OPTIONS and SIZE on STREAM. Format i is not supported
1278 This is how the elements of an array or structure are printed
1282 val_print_scalar_formatted (struct type
*type
,
1283 LONGEST embedded_offset
,
1285 const struct value_print_options
*options
,
1287 struct ui_file
*stream
)
1289 struct gdbarch
*arch
= get_type_arch (type
);
1290 int unit_size
= gdbarch_addressable_memory_unit_size (arch
);
1292 gdb_assert (val
!= NULL
);
1294 /* If we get here with a string format, try again without it. Go
1295 all the way back to the language printers, which may call us
1297 if (options
->format
== 's')
1299 struct value_print_options opts
= *options
;
1302 val_print (type
, embedded_offset
, 0, stream
, 0, val
, &opts
,
1307 /* value_contents_for_printing fetches all VAL's contents. They are
1308 needed to check whether VAL is optimized-out or unavailable
1310 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1312 /* A scalar object that does not have all bits available can't be
1313 printed, because all bits contribute to its representation. */
1314 if (value_bits_any_optimized_out (val
,
1315 TARGET_CHAR_BIT
* embedded_offset
,
1316 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1317 val_print_optimized_out (val
, stream
);
1318 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
1319 val_print_unavailable (stream
);
1321 print_scalar_formatted (valaddr
+ embedded_offset
* unit_size
, type
,
1322 options
, size
, stream
);
1325 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1326 The raison d'etre of this function is to consolidate printing of
1327 LONG_LONG's into this one function. The format chars b,h,w,g are
1328 from print_scalar_formatted(). Numbers are printed using C
1331 USE_C_FORMAT means to use C format in all cases. Without it,
1332 'o' and 'x' format do not include the standard C radix prefix
1335 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1336 and was intended to request formating according to the current
1337 language and would be used for most integers that GDB prints. The
1338 exceptional cases were things like protocols where the format of
1339 the integer is a protocol thing, not a user-visible thing). The
1340 parameter remains to preserve the information of what things might
1341 be printed with language-specific format, should we ever resurrect
1345 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1353 val
= int_string (val_long
, 10, 1, 0, 1); break;
1355 val
= int_string (val_long
, 10, 0, 0, 1); break;
1357 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1359 val
= int_string (val_long
, 16, 0, 2, 1); break;
1361 val
= int_string (val_long
, 16, 0, 4, 1); break;
1363 val
= int_string (val_long
, 16, 0, 8, 1); break;
1365 val
= int_string (val_long
, 16, 0, 16, 1); break;
1368 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1370 internal_error (__FILE__
, __LINE__
,
1371 _("failed internal consistency check"));
1373 fputs_filtered (val
, stream
);
1376 /* This used to be a macro, but I don't think it is called often enough
1377 to merit such treatment. */
1378 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1379 arguments to a function, number in a value history, register number, etc.)
1380 where the value must not be larger than can fit in an int. */
1383 longest_to_int (LONGEST arg
)
1385 /* Let the compiler do the work. */
1386 int rtnval
= (int) arg
;
1388 /* Check for overflows or underflows. */
1389 if (sizeof (LONGEST
) > sizeof (int))
1393 error (_("Value out of range."));
1399 /* Print a floating point value of type TYPE (not always a
1400 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1403 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1404 struct ui_file
*stream
)
1408 const struct floatformat
*fmt
= NULL
;
1409 unsigned len
= TYPE_LENGTH (type
);
1410 enum float_kind kind
;
1412 /* If it is a floating-point, check for obvious problems. */
1413 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1414 fmt
= floatformat_from_type (type
);
1417 kind
= floatformat_classify (fmt
, valaddr
);
1418 if (kind
== float_nan
)
1420 if (floatformat_is_negative (fmt
, valaddr
))
1421 fprintf_filtered (stream
, "-");
1422 fprintf_filtered (stream
, "nan(");
1423 fputs_filtered ("0x", stream
);
1424 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
1425 fprintf_filtered (stream
, ")");
1428 else if (kind
== float_infinite
)
1430 if (floatformat_is_negative (fmt
, valaddr
))
1431 fputs_filtered ("-", stream
);
1432 fputs_filtered ("inf", stream
);
1437 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1438 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1439 needs to be used as that takes care of any necessary type
1440 conversions. Such conversions are of course direct to DOUBLEST
1441 and disregard any possible target floating point limitations.
1442 For instance, a u64 would be converted and displayed exactly on a
1443 host with 80 bit DOUBLEST but with loss of information on a host
1444 with 64 bit DOUBLEST. */
1446 doub
= unpack_double (type
, valaddr
, &inv
);
1449 fprintf_filtered (stream
, "<invalid float value>");
1453 /* FIXME: kettenis/2001-01-20: The following code makes too much
1454 assumptions about the host and target floating point format. */
1456 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1457 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1458 instead uses the type's length to determine the precision of the
1459 floating-point value being printed. */
1461 if (len
< sizeof (double))
1462 fprintf_filtered (stream
, "%.9g", (double) doub
);
1463 else if (len
== sizeof (double))
1464 fprintf_filtered (stream
, "%.17g", (double) doub
);
1466 #ifdef PRINTF_HAS_LONG_DOUBLE
1467 fprintf_filtered (stream
, "%.35Lg", doub
);
1469 /* This at least wins with values that are representable as
1471 fprintf_filtered (stream
, "%.17g", (double) doub
);
1476 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
1477 struct ui_file
*stream
)
1479 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
1480 char decstr
[MAX_DECIMAL_STRING
];
1481 unsigned len
= TYPE_LENGTH (type
);
1483 decimal_to_string (valaddr
, len
, byte_order
, decstr
);
1484 fputs_filtered (decstr
, stream
);
1489 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1490 unsigned len
, enum bfd_endian byte_order
, bool zero_pad
)
1493 #define BITS_IN_BYTES 8
1498 bool seen_a_one
= false;
1500 /* Declared "int" so it will be signed.
1501 This ensures that right shift will shift in zeros. */
1503 const int mask
= 0x080;
1505 if (byte_order
== BFD_ENDIAN_BIG
)
1511 /* Every byte has 8 binary characters; peel off
1512 and print from the MSB end. */
1514 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1516 if (*p
& (mask
>> i
))
1521 if (zero_pad
|| seen_a_one
|| b
== '1')
1522 fputc_filtered (b
, stream
);
1530 for (p
= valaddr
+ len
- 1;
1534 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1536 if (*p
& (mask
>> i
))
1541 if (zero_pad
|| seen_a_one
|| b
== '1')
1542 fputc_filtered (b
, stream
);
1549 /* When not zero-padding, ensure that something is printed when the
1551 if (!zero_pad
&& !seen_a_one
)
1552 fputc_filtered ('0', stream
);
1555 /* A helper for print_octal_chars that emits a single octal digit,
1556 optionally suppressing it if is zero and updating SEEN_A_ONE. */
1559 emit_octal_digit (struct ui_file
*stream
, bool *seen_a_one
, int digit
)
1561 if (*seen_a_one
|| digit
!= 0)
1562 fprintf_filtered (stream
, "%o", digit
);
1567 /* VALADDR points to an integer of LEN bytes.
1568 Print it in octal on stream or format it in buf. */
1571 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1572 unsigned len
, enum bfd_endian byte_order
)
1575 unsigned char octa1
, octa2
, octa3
, carry
;
1578 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1579 * the extra bits, which cycle every three bytes:
1581 * Byte side: 0 1 2 3
1583 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1585 * Octal side: 0 1 carry 3 4 carry ...
1587 * Cycle number: 0 1 2
1589 * But of course we are printing from the high side, so we have to
1590 * figure out where in the cycle we are so that we end up with no
1591 * left over bits at the end.
1593 #define BITS_IN_OCTAL 3
1594 #define HIGH_ZERO 0340
1595 #define LOW_ZERO 0016
1596 #define CARRY_ZERO 0003
1597 #define HIGH_ONE 0200
1598 #define MID_ONE 0160
1599 #define LOW_ONE 0016
1600 #define CARRY_ONE 0001
1601 #define HIGH_TWO 0300
1602 #define MID_TWO 0070
1603 #define LOW_TWO 0007
1605 /* For 32 we start in cycle 2, with two bits and one bit carry;
1606 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1608 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
1611 fputs_filtered ("0", stream
);
1612 bool seen_a_one
= false;
1613 if (byte_order
== BFD_ENDIAN_BIG
)
1622 /* No carry in, carry out two bits. */
1624 octa1
= (HIGH_ZERO
& *p
) >> 5;
1625 octa2
= (LOW_ZERO
& *p
) >> 2;
1626 carry
= (CARRY_ZERO
& *p
);
1627 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1628 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1632 /* Carry in two bits, carry out one bit. */
1634 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1635 octa2
= (MID_ONE
& *p
) >> 4;
1636 octa3
= (LOW_ONE
& *p
) >> 1;
1637 carry
= (CARRY_ONE
& *p
);
1638 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1639 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1640 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1644 /* Carry in one bit, no carry out. */
1646 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1647 octa2
= (MID_TWO
& *p
) >> 3;
1648 octa3
= (LOW_TWO
& *p
);
1650 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1651 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1652 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1656 error (_("Internal error in octal conversion;"));
1660 cycle
= cycle
% BITS_IN_OCTAL
;
1665 for (p
= valaddr
+ len
- 1;
1672 /* Carry out, no carry in */
1674 octa1
= (HIGH_ZERO
& *p
) >> 5;
1675 octa2
= (LOW_ZERO
& *p
) >> 2;
1676 carry
= (CARRY_ZERO
& *p
);
1677 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1678 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1682 /* Carry in, carry out */
1684 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1685 octa2
= (MID_ONE
& *p
) >> 4;
1686 octa3
= (LOW_ONE
& *p
) >> 1;
1687 carry
= (CARRY_ONE
& *p
);
1688 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1689 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1690 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1694 /* Carry in, no carry out */
1696 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1697 octa2
= (MID_TWO
& *p
) >> 3;
1698 octa3
= (LOW_TWO
& *p
);
1700 emit_octal_digit (stream
, &seen_a_one
, octa1
);
1701 emit_octal_digit (stream
, &seen_a_one
, octa2
);
1702 emit_octal_digit (stream
, &seen_a_one
, octa3
);
1706 error (_("Internal error in octal conversion;"));
1710 cycle
= cycle
% BITS_IN_OCTAL
;
1716 /* Possibly negate the integer represented by BYTES. It contains LEN
1717 bytes in the specified byte order. If the integer is negative,
1718 copy it into OUT_VEC, negate it, and return true. Otherwise, do
1719 nothing and return false. */
1722 maybe_negate_by_bytes (const gdb_byte
*bytes
, unsigned len
,
1723 enum bfd_endian byte_order
,
1724 std::vector
<gdb_byte
> *out_vec
)
1727 if (byte_order
== BFD_ENDIAN_BIG
)
1728 sign_byte
= bytes
[0];
1730 sign_byte
= bytes
[len
- 1];
1731 if ((sign_byte
& 0x80) == 0)
1734 out_vec
->resize (len
);
1736 /* Compute -x == 1 + ~x. */
1737 if (byte_order
== BFD_ENDIAN_LITTLE
)
1740 for (unsigned i
= 0; i
< len
; ++i
)
1742 unsigned tem
= (0xff & ~bytes
[i
]) + carry
;
1743 (*out_vec
)[i
] = tem
& 0xff;
1750 for (unsigned i
= len
; i
> 0; --i
)
1752 unsigned tem
= (0xff & ~bytes
[i
- 1]) + carry
;
1753 (*out_vec
)[i
- 1] = tem
& 0xff;
1761 /* VALADDR points to an integer of LEN bytes.
1762 Print it in decimal on stream or format it in buf. */
1765 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1766 unsigned len
, bool is_signed
,
1767 enum bfd_endian byte_order
)
1770 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1771 #define CARRY_LEFT( x ) ((x) % TEN)
1772 #define SHIFT( x ) ((x) << 4)
1773 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1774 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1779 int i
, j
, decimal_digits
;
1783 std::vector
<gdb_byte
> negated_bytes
;
1785 && maybe_negate_by_bytes (valaddr
, len
, byte_order
, &negated_bytes
))
1787 fputs_filtered ("-", stream
);
1788 valaddr
= negated_bytes
.data ();
1791 /* Base-ten number is less than twice as many digits
1792 as the base 16 number, which is 2 digits per byte. */
1794 decimal_len
= len
* 2 * 2;
1795 std::vector
<unsigned char> digits (decimal_len
, 0);
1797 /* Ok, we have an unknown number of bytes of data to be printed in
1800 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1801 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1802 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1804 * The trick is that "digits" holds a base-10 number, but sometimes
1805 * the individual digits are > 10.
1807 * Outer loop is per nibble (hex digit) of input, from MSD end to
1810 decimal_digits
= 0; /* Number of decimal digits so far */
1811 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1813 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1816 * Multiply current base-ten number by 16 in place.
1817 * Each digit was between 0 and 9, now is between
1820 for (j
= 0; j
< decimal_digits
; j
++)
1822 digits
[j
] = SHIFT (digits
[j
]);
1825 /* Take the next nibble off the input and add it to what
1826 * we've got in the LSB position. Bottom 'digit' is now
1827 * between 0 and 159.
1829 * "flip" is used to run this loop twice for each byte.
1833 /* Take top nibble. */
1835 digits
[0] += HIGH_NIBBLE (*p
);
1840 /* Take low nibble and bump our pointer "p". */
1842 digits
[0] += LOW_NIBBLE (*p
);
1843 if (byte_order
== BFD_ENDIAN_BIG
)
1850 /* Re-decimalize. We have to do this often enough
1851 * that we don't overflow, but once per nibble is
1852 * overkill. Easier this way, though. Note that the
1853 * carry is often larger than 10 (e.g. max initial
1854 * carry out of lowest nibble is 15, could bubble all
1855 * the way up greater than 10). So we have to do
1856 * the carrying beyond the last current digit.
1859 for (j
= 0; j
< decimal_len
- 1; j
++)
1863 /* "/" won't handle an unsigned char with
1864 * a value that if signed would be negative.
1865 * So extend to longword int via "dummy".
1868 carry
= CARRY_OUT (dummy
);
1869 digits
[j
] = CARRY_LEFT (dummy
);
1871 if (j
>= decimal_digits
&& carry
== 0)
1874 * All higher digits are 0 and we
1875 * no longer have a carry.
1877 * Note: "j" is 0-based, "decimal_digits" is
1880 decimal_digits
= j
+ 1;
1886 /* Ok, now "digits" is the decimal representation, with
1887 the "decimal_digits" actual digits. Print! */
1889 for (i
= decimal_digits
- 1; i
> 0 && digits
[i
] == 0; --i
)
1894 fprintf_filtered (stream
, "%1d", digits
[i
]);
1898 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1901 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1902 unsigned len
, enum bfd_endian byte_order
,
1907 fputs_filtered ("0x", stream
);
1908 if (byte_order
== BFD_ENDIAN_BIG
)
1914 /* Strip leading 0 bytes, but be sure to leave at least a
1915 single byte at the end. */
1916 for (; p
< valaddr
+ len
- 1 && !*p
; ++p
)
1920 const gdb_byte
*first
= p
;
1925 /* When not zero-padding, use a different format for the
1926 very first byte printed. */
1927 if (!zero_pad
&& p
== first
)
1928 fprintf_filtered (stream
, "%x", *p
);
1930 fprintf_filtered (stream
, "%02x", *p
);
1935 p
= valaddr
+ len
- 1;
1939 /* Strip leading 0 bytes, but be sure to leave at least a
1940 single byte at the end. */
1941 for (; p
>= valaddr
+ 1 && !*p
; --p
)
1945 const gdb_byte
*first
= p
;
1950 /* When not zero-padding, use a different format for the
1951 very first byte printed. */
1952 if (!zero_pad
&& p
== first
)
1953 fprintf_filtered (stream
, "%x", *p
);
1955 fprintf_filtered (stream
, "%02x", *p
);
1960 /* VALADDR points to a char integer of LEN bytes.
1961 Print it out in appropriate language form on stream.
1962 Omit any leading zero chars. */
1965 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1966 const gdb_byte
*valaddr
,
1967 unsigned len
, enum bfd_endian byte_order
)
1971 if (byte_order
== BFD_ENDIAN_BIG
)
1974 while (p
< valaddr
+ len
- 1 && *p
== 0)
1977 while (p
< valaddr
+ len
)
1979 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1985 p
= valaddr
+ len
- 1;
1986 while (p
> valaddr
&& *p
== 0)
1989 while (p
>= valaddr
)
1991 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1997 /* Print function pointer with inferior address ADDRESS onto stdio
2001 print_function_pointer_address (const struct value_print_options
*options
,
2002 struct gdbarch
*gdbarch
,
2004 struct ui_file
*stream
)
2007 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
2010 /* If the function pointer is represented by a description, print
2011 the address of the description. */
2012 if (options
->addressprint
&& func_addr
!= address
)
2014 fputs_filtered ("@", stream
);
2015 fputs_filtered (paddress (gdbarch
, address
), stream
);
2016 fputs_filtered (": ", stream
);
2018 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
2022 /* Print on STREAM using the given OPTIONS the index for the element
2023 at INDEX of an array whose index type is INDEX_TYPE. */
2026 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
2027 struct ui_file
*stream
,
2028 const struct value_print_options
*options
)
2030 struct value
*index_value
;
2032 if (!options
->print_array_indexes
)
2035 index_value
= value_from_longest (index_type
, index
);
2037 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
2040 /* Called by various <lang>_val_print routines to print elements of an
2041 array in the form "<elem1>, <elem2>, <elem3>, ...".
2043 (FIXME?) Assumes array element separator is a comma, which is correct
2044 for all languages currently handled.
2045 (FIXME?) Some languages have a notation for repeated array elements,
2046 perhaps we should try to use that notation when appropriate. */
2049 val_print_array_elements (struct type
*type
,
2050 LONGEST embedded_offset
,
2051 CORE_ADDR address
, struct ui_file
*stream
,
2054 const struct value_print_options
*options
,
2057 unsigned int things_printed
= 0;
2059 struct type
*elttype
, *index_type
, *base_index_type
;
2061 /* Position of the array element we are examining to see
2062 whether it is repeated. */
2064 /* Number of repetitions we have detected so far. */
2066 LONGEST low_bound
, high_bound
;
2067 LONGEST low_pos
, high_pos
;
2069 elttype
= TYPE_TARGET_TYPE (type
);
2070 eltlen
= type_length_units (check_typedef (elttype
));
2071 index_type
= TYPE_INDEX_TYPE (type
);
2073 if (get_array_bounds (type
, &low_bound
, &high_bound
))
2075 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
2076 base_index_type
= TYPE_TARGET_TYPE (index_type
);
2078 base_index_type
= index_type
;
2080 /* Non-contiguous enumerations types can by used as index types
2081 in some languages (e.g. Ada). In this case, the array length
2082 shall be computed from the positions of the first and last
2083 literal in the enumeration type, and not from the values
2084 of these literals. */
2085 if (!discrete_position (base_index_type
, low_bound
, &low_pos
)
2086 || !discrete_position (base_index_type
, high_bound
, &high_pos
))
2088 warning (_("unable to get positions in array, use bounds instead"));
2089 low_pos
= low_bound
;
2090 high_pos
= high_bound
;
2093 /* The array length should normally be HIGH_POS - LOW_POS + 1.
2094 But we have to be a little extra careful, because some languages
2095 such as Ada allow LOW_POS to be greater than HIGH_POS for
2096 empty arrays. In that situation, the array length is just zero,
2098 if (low_pos
> high_pos
)
2101 len
= high_pos
- low_pos
+ 1;
2105 warning (_("unable to get bounds of array, assuming null array"));
2110 annotate_array_section_begin (i
, elttype
);
2112 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
2116 if (options
->prettyformat_arrays
)
2118 fprintf_filtered (stream
, ",\n");
2119 print_spaces_filtered (2 + 2 * recurse
, stream
);
2123 fprintf_filtered (stream
, ", ");
2126 wrap_here (n_spaces (2 + 2 * recurse
));
2127 maybe_print_array_index (index_type
, i
+ low_bound
,
2132 /* Only check for reps if repeat_count_threshold is not set to
2133 UINT_MAX (unlimited). */
2134 if (options
->repeat_count_threshold
< UINT_MAX
)
2137 && value_contents_eq (val
,
2138 embedded_offset
+ i
* eltlen
,
2149 if (reps
> options
->repeat_count_threshold
)
2151 val_print (elttype
, embedded_offset
+ i
* eltlen
,
2152 address
, stream
, recurse
+ 1, val
, options
,
2154 annotate_elt_rep (reps
);
2155 fprintf_filtered (stream
, " <repeats %u times>", reps
);
2156 annotate_elt_rep_end ();
2159 things_printed
+= options
->repeat_count_threshold
;
2163 val_print (elttype
, embedded_offset
+ i
* eltlen
,
2165 stream
, recurse
+ 1, val
, options
, current_language
);
2170 annotate_array_section_end ();
2173 fprintf_filtered (stream
, "...");
2177 /* Read LEN bytes of target memory at address MEMADDR, placing the
2178 results in GDB's memory at MYADDR. Returns a count of the bytes
2179 actually read, and optionally a target_xfer_status value in the
2180 location pointed to by ERRPTR if ERRPTR is non-null. */
2182 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
2183 function be eliminated. */
2186 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
2187 int len
, int *errptr
)
2189 int nread
; /* Number of bytes actually read. */
2190 int errcode
; /* Error from last read. */
2192 /* First try a complete read. */
2193 errcode
= target_read_memory (memaddr
, myaddr
, len
);
2201 /* Loop, reading one byte at a time until we get as much as we can. */
2202 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
2204 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
2206 /* If an error, the last read was unsuccessful, so adjust count. */
2219 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
2220 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
2221 allocated buffer containing the string, which the caller is responsible to
2222 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
2223 success, or a target_xfer_status on failure.
2225 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
2226 (including eventual NULs in the middle or end of the string).
2228 If LEN is -1, stops at the first null character (not necessarily
2229 the first null byte) up to a maximum of FETCHLIMIT characters. Set
2230 FETCHLIMIT to UINT_MAX to read as many characters as possible from
2233 Unless an exception is thrown, BUFFER will always be allocated, even on
2234 failure. In this case, some characters might have been read before the
2235 failure happened. Check BYTES_READ to recognize this situation.
2237 Note: There was a FIXME asking to make this code use target_read_string,
2238 but this function is more general (can read past null characters, up to
2239 given LEN). Besides, it is used much more often than target_read_string
2240 so it is more tested. Perhaps callers of target_read_string should use
2241 this function instead? */
2244 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
2245 enum bfd_endian byte_order
, gdb_byte
**buffer
, int *bytes_read
)
2247 int errcode
; /* Errno returned from bad reads. */
2248 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
2249 gdb_byte
*bufptr
; /* Pointer to next available byte in
2251 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
2253 /* Loop until we either have all the characters, or we encounter
2254 some error, such as bumping into the end of the address space. */
2258 old_chain
= make_cleanup (free_current_contents
, buffer
);
2262 /* We want fetchlimit chars, so we might as well read them all in
2264 unsigned int fetchlen
= std::min ((unsigned) len
, fetchlimit
);
2266 *buffer
= (gdb_byte
*) xmalloc (fetchlen
* width
);
2269 nfetch
= partial_memory_read (addr
, bufptr
, fetchlen
* width
, &errcode
)
2271 addr
+= nfetch
* width
;
2272 bufptr
+= nfetch
* width
;
2276 unsigned long bufsize
= 0;
2277 unsigned int chunksize
; /* Size of each fetch, in chars. */
2278 int found_nul
; /* Non-zero if we found the nul char. */
2279 gdb_byte
*limit
; /* First location past end of fetch buffer. */
2282 /* We are looking for a NUL terminator to end the fetching, so we
2283 might as well read in blocks that are large enough to be efficient,
2284 but not so large as to be slow if fetchlimit happens to be large.
2285 So we choose the minimum of 8 and fetchlimit. We used to use 200
2286 instead of 8 but 200 is way too big for remote debugging over a
2288 chunksize
= std::min (8u, fetchlimit
);
2293 nfetch
= std::min ((unsigned long) chunksize
, fetchlimit
- bufsize
);
2295 if (*buffer
== NULL
)
2296 *buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
2298 *buffer
= (gdb_byte
*) xrealloc (*buffer
,
2299 (nfetch
+ bufsize
) * width
);
2301 bufptr
= *buffer
+ bufsize
* width
;
2304 /* Read as much as we can. */
2305 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
2308 /* Scan this chunk for the null character that terminates the string
2309 to print. If found, we don't need to fetch any more. Note
2310 that bufptr is explicitly left pointing at the next character
2311 after the null character, or at the next character after the end
2314 limit
= bufptr
+ nfetch
* width
;
2315 while (bufptr
< limit
)
2319 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
2324 /* We don't care about any error which happened after
2325 the NUL terminator. */
2332 while (errcode
== 0 /* no error */
2333 && bufptr
- *buffer
< fetchlimit
* width
/* no overrun */
2334 && !found_nul
); /* haven't found NUL yet */
2337 { /* Length of string is really 0! */
2338 /* We always allocate *buffer. */
2339 *buffer
= bufptr
= (gdb_byte
*) xmalloc (1);
2343 /* bufptr and addr now point immediately beyond the last byte which we
2344 consider part of the string (including a '\0' which ends the string). */
2345 *bytes_read
= bufptr
- *buffer
;
2349 discard_cleanups (old_chain
);
2354 /* Return true if print_wchar can display W without resorting to a
2355 numeric escape, false otherwise. */
2358 wchar_printable (gdb_wchar_t w
)
2360 return (gdb_iswprint (w
)
2361 || w
== LCST ('\a') || w
== LCST ('\b')
2362 || w
== LCST ('\f') || w
== LCST ('\n')
2363 || w
== LCST ('\r') || w
== LCST ('\t')
2364 || w
== LCST ('\v'));
2367 /* A helper function that converts the contents of STRING to wide
2368 characters and then appends them to OUTPUT. */
2371 append_string_as_wide (const char *string
,
2372 struct obstack
*output
)
2374 for (; *string
; ++string
)
2376 gdb_wchar_t w
= gdb_btowc (*string
);
2377 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
2381 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2382 original (target) bytes representing the character, ORIG_LEN is the
2383 number of valid bytes. WIDTH is the number of bytes in a base
2384 characters of the type. OUTPUT is an obstack to which wide
2385 characters are emitted. QUOTER is a (narrow) character indicating
2386 the style of quotes surrounding the character to be printed.
2387 NEED_ESCAPE is an in/out flag which is used to track numeric
2388 escapes across calls. */
2391 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
2392 int orig_len
, int width
,
2393 enum bfd_endian byte_order
,
2394 struct obstack
*output
,
2395 int quoter
, int *need_escapep
)
2397 int need_escape
= *need_escapep
;
2401 /* iswprint implementation on Windows returns 1 for tab character.
2402 In order to avoid different printout on this host, we explicitly
2403 use wchar_printable function. */
2407 obstack_grow_wstr (output
, LCST ("\\a"));
2410 obstack_grow_wstr (output
, LCST ("\\b"));
2413 obstack_grow_wstr (output
, LCST ("\\f"));
2416 obstack_grow_wstr (output
, LCST ("\\n"));
2419 obstack_grow_wstr (output
, LCST ("\\r"));
2422 obstack_grow_wstr (output
, LCST ("\\t"));
2425 obstack_grow_wstr (output
, LCST ("\\v"));
2429 if (wchar_printable (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
2431 && w
!= LCST ('9'))))
2433 gdb_wchar_t wchar
= w
;
2435 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
2436 obstack_grow_wstr (output
, LCST ("\\"));
2437 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
2443 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
2448 value
= extract_unsigned_integer (&orig
[i
], width
,
2450 /* If the value fits in 3 octal digits, print it that
2451 way. Otherwise, print it as a hex escape. */
2453 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
2454 (int) (value
& 0777));
2456 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
2457 append_string_as_wide (octal
, output
);
2459 /* If we somehow have extra bytes, print them now. */
2460 while (i
< orig_len
)
2464 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
2465 append_string_as_wide (octal
, output
);
2476 /* Print the character C on STREAM as part of the contents of a
2477 literal string whose delimiter is QUOTER. ENCODING names the
2481 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2482 int quoter
, const char *encoding
)
2484 enum bfd_endian byte_order
2485 = gdbarch_byte_order (get_type_arch (type
));
2486 struct obstack wchar_buf
, output
;
2487 struct cleanup
*cleanups
;
2489 int need_escape
= 0;
2491 buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
2492 pack_long (buf
, type
, c
);
2494 wchar_iterator
iter (buf
, TYPE_LENGTH (type
), encoding
, TYPE_LENGTH (type
));
2496 /* This holds the printable form of the wchar_t data. */
2497 obstack_init (&wchar_buf
);
2498 cleanups
= make_cleanup_obstack_free (&wchar_buf
);
2504 const gdb_byte
*buf
;
2506 int print_escape
= 1;
2507 enum wchar_iterate_result result
;
2509 num_chars
= iter
.iterate (&result
, &chars
, &buf
, &buflen
);
2514 /* If all characters are printable, print them. Otherwise,
2515 we're going to have to print an escape sequence. We
2516 check all characters because we want to print the target
2517 bytes in the escape sequence, and we don't know character
2518 boundaries there. */
2522 for (i
= 0; i
< num_chars
; ++i
)
2523 if (!wchar_printable (chars
[i
]))
2531 for (i
= 0; i
< num_chars
; ++i
)
2532 print_wchar (chars
[i
], buf
, buflen
,
2533 TYPE_LENGTH (type
), byte_order
,
2534 &wchar_buf
, quoter
, &need_escape
);
2538 /* This handles the NUM_CHARS == 0 case as well. */
2540 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2541 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2544 /* The output in the host encoding. */
2545 obstack_init (&output
);
2546 make_cleanup_obstack_free (&output
);
2548 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2549 (gdb_byte
*) obstack_base (&wchar_buf
),
2550 obstack_object_size (&wchar_buf
),
2551 sizeof (gdb_wchar_t
), &output
, translit_char
);
2552 obstack_1grow (&output
, '\0');
2554 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2556 do_cleanups (cleanups
);
2559 /* Return the repeat count of the next character/byte in ITER,
2560 storing the result in VEC. */
2563 count_next_character (wchar_iterator
*iter
,
2564 VEC (converted_character_d
) **vec
)
2566 struct converted_character
*current
;
2568 if (VEC_empty (converted_character_d
, *vec
))
2570 struct converted_character tmp
;
2574 = iter
->iterate (&tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2575 if (tmp
.num_chars
> 0)
2577 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2578 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2580 VEC_safe_push (converted_character_d
, *vec
, &tmp
);
2583 current
= VEC_last (converted_character_d
, *vec
);
2585 /* Count repeated characters or bytes. */
2586 current
->repeat_count
= 1;
2587 if (current
->num_chars
== -1)
2595 struct converted_character d
;
2602 /* Get the next character. */
2603 d
.num_chars
= iter
->iterate (&d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2605 /* If a character was successfully converted, save the character
2606 into the converted character. */
2607 if (d
.num_chars
> 0)
2609 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2610 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2613 /* Determine if the current character is the same as this
2615 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2617 /* There are two cases to consider:
2619 1) Equality of converted character (num_chars > 0)
2620 2) Equality of non-converted character (num_chars == 0) */
2621 if ((current
->num_chars
> 0
2622 && memcmp (current
->chars
, d
.chars
,
2623 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2624 || (current
->num_chars
== 0
2625 && current
->buflen
== d
.buflen
2626 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2627 ++current
->repeat_count
;
2635 /* Push this next converted character onto the result vector. */
2636 repeat
= current
->repeat_count
;
2637 VEC_safe_push (converted_character_d
, *vec
, &d
);
2642 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2643 character to use with string output. WIDTH is the size of the output
2644 character type. BYTE_ORDER is the the target byte order. OPTIONS
2645 is the user's print options. */
2648 print_converted_chars_to_obstack (struct obstack
*obstack
,
2649 VEC (converted_character_d
) *chars
,
2650 int quote_char
, int width
,
2651 enum bfd_endian byte_order
,
2652 const struct value_print_options
*options
)
2655 struct converted_character
*elem
;
2656 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2657 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2658 int need_escape
= 0;
2660 /* Set the start state. */
2662 last
= state
= START
;
2670 /* Nothing to do. */
2677 /* We are outputting a single character
2678 (< options->repeat_count_threshold). */
2682 /* We were outputting some other type of content, so we
2683 must output and a comma and a quote. */
2685 obstack_grow_wstr (obstack
, LCST (", "));
2686 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2688 /* Output the character. */
2689 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2691 if (elem
->result
== wchar_iterate_ok
)
2692 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2693 byte_order
, obstack
, quote_char
, &need_escape
);
2695 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2696 byte_order
, obstack
, quote_char
, &need_escape
);
2706 /* We are outputting a character with a repeat count
2707 greater than options->repeat_count_threshold. */
2711 /* We were outputting a single string. Terminate the
2713 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2716 obstack_grow_wstr (obstack
, LCST (", "));
2718 /* Output the character and repeat string. */
2719 obstack_grow_wstr (obstack
, LCST ("'"));
2720 if (elem
->result
== wchar_iterate_ok
)
2721 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2722 byte_order
, obstack
, quote_char
, &need_escape
);
2724 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2725 byte_order
, obstack
, quote_char
, &need_escape
);
2726 obstack_grow_wstr (obstack
, LCST ("'"));
2727 s
= xstrprintf (_(" <repeats %u times>"), elem
->repeat_count
);
2728 for (j
= 0; s
[j
]; ++j
)
2730 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2731 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2738 /* We are outputting an incomplete sequence. */
2741 /* If we were outputting a string of SINGLE characters,
2742 terminate the quote. */
2743 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2746 obstack_grow_wstr (obstack
, LCST (", "));
2748 /* Output the incomplete sequence string. */
2749 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
2750 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
2751 obstack
, 0, &need_escape
);
2752 obstack_grow_wstr (obstack
, LCST (">"));
2754 /* We do not attempt to outupt anything after this. */
2759 /* All done. If we were outputting a string of SINGLE
2760 characters, the string must be terminated. Otherwise,
2761 REPEAT and INCOMPLETE are always left properly terminated. */
2763 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2768 /* Get the next element and state. */
2770 if (state
!= FINISH
)
2772 elem
= VEC_index (converted_character_d
, chars
, idx
++);
2773 switch (elem
->result
)
2775 case wchar_iterate_ok
:
2776 case wchar_iterate_invalid
:
2777 if (elem
->repeat_count
> options
->repeat_count_threshold
)
2783 case wchar_iterate_incomplete
:
2787 case wchar_iterate_eof
:
2795 /* Print the character string STRING, printing at most LENGTH
2796 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2797 the type of each character. OPTIONS holds the printing options;
2798 printing stops early if the number hits print_max; repeat counts
2799 are printed as appropriate. Print ellipses at the end if we had to
2800 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2801 QUOTE_CHAR is the character to print at each end of the string. If
2802 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2806 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2807 const gdb_byte
*string
, unsigned int length
,
2808 const char *encoding
, int force_ellipses
,
2809 int quote_char
, int c_style_terminator
,
2810 const struct value_print_options
*options
)
2812 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2814 int width
= TYPE_LENGTH (type
);
2815 struct obstack wchar_buf
, output
;
2816 struct cleanup
*cleanup
;
2818 struct converted_character
*last
;
2819 VEC (converted_character_d
) *converted_chars
;
2823 unsigned long current_char
= 1;
2825 for (i
= 0; current_char
; ++i
)
2828 current_char
= extract_unsigned_integer (string
+ i
* width
,
2834 /* If the string was not truncated due to `set print elements', and
2835 the last byte of it is a null, we don't print that, in
2836 traditional C style. */
2837 if (c_style_terminator
2840 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2841 width
, byte_order
) == 0))
2846 fputs_filtered ("\"\"", stream
);
2850 /* Arrange to iterate over the characters, in wchar_t form. */
2851 wchar_iterator
iter (string
, length
* width
, encoding
, width
);
2852 converted_chars
= NULL
;
2853 cleanup
= make_cleanup (VEC_cleanup (converted_character_d
),
2856 /* Convert characters until the string is over or the maximum
2857 number of printed characters has been reached. */
2859 while (i
< options
->print_max
)
2865 /* Grab the next character and repeat count. */
2866 r
= count_next_character (&iter
, &converted_chars
);
2868 /* If less than zero, the end of the input string was reached. */
2872 /* Otherwise, add the count to the total print count and get
2873 the next character. */
2877 /* Get the last element and determine if the entire string was
2879 last
= VEC_last (converted_character_d
, converted_chars
);
2880 finished
= (last
->result
== wchar_iterate_eof
);
2882 /* Ensure that CONVERTED_CHARS is terminated. */
2883 last
->result
= wchar_iterate_eof
;
2885 /* WCHAR_BUF is the obstack we use to represent the string in
2887 obstack_init (&wchar_buf
);
2888 make_cleanup_obstack_free (&wchar_buf
);
2890 /* Print the output string to the obstack. */
2891 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
2892 width
, byte_order
, options
);
2894 if (force_ellipses
|| !finished
)
2895 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2897 /* OUTPUT is where we collect `char's for printing. */
2898 obstack_init (&output
);
2899 make_cleanup_obstack_free (&output
);
2901 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2902 (gdb_byte
*) obstack_base (&wchar_buf
),
2903 obstack_object_size (&wchar_buf
),
2904 sizeof (gdb_wchar_t
), &output
, translit_char
);
2905 obstack_1grow (&output
, '\0');
2907 fputs_filtered ((const char *) obstack_base (&output
), stream
);
2909 do_cleanups (cleanup
);
2912 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2913 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2914 stops at the first null byte, otherwise printing proceeds (including null
2915 bytes) until either print_max or LEN characters have been printed,
2916 whichever is smaller. ENCODING is the name of the string's
2917 encoding. It can be NULL, in which case the target encoding is
2921 val_print_string (struct type
*elttype
, const char *encoding
,
2922 CORE_ADDR addr
, int len
,
2923 struct ui_file
*stream
,
2924 const struct value_print_options
*options
)
2926 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2927 int err
; /* Non-zero if we got a bad read. */
2928 int found_nul
; /* Non-zero if we found the nul char. */
2929 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2931 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
2932 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
2933 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2934 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2935 int width
= TYPE_LENGTH (elttype
);
2937 /* First we need to figure out the limit on the number of characters we are
2938 going to attempt to fetch and print. This is actually pretty simple. If
2939 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2940 LEN is -1, then the limit is print_max. This is true regardless of
2941 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2942 because finding the null byte (or available memory) is what actually
2943 limits the fetch. */
2945 fetchlimit
= (len
== -1 ? options
->print_max
: std::min ((unsigned) len
,
2946 options
->print_max
));
2948 err
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2949 &buffer
, &bytes_read
);
2950 old_chain
= make_cleanup (xfree
, buffer
);
2954 /* We now have either successfully filled the buffer to fetchlimit,
2955 or terminated early due to an error or finding a null char when
2958 /* Determine found_nul by looking at the last character read. */
2960 if (bytes_read
>= width
)
2961 found_nul
= extract_unsigned_integer (buffer
+ bytes_read
- width
, width
,
2963 if (len
== -1 && !found_nul
)
2967 /* We didn't find a NUL terminator we were looking for. Attempt
2968 to peek at the next character. If not successful, or it is not
2969 a null byte, then force ellipsis to be printed. */
2971 peekbuf
= (gdb_byte
*) alloca (width
);
2973 if (target_read_memory (addr
, peekbuf
, width
) == 0
2974 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2977 else if ((len
>= 0 && err
!= 0) || (len
> bytes_read
/ width
))
2979 /* Getting an error when we have a requested length, or fetching less
2980 than the number of characters actually requested, always make us
2985 /* If we get an error before fetching anything, don't print a string.
2986 But if we fetch something and then get an error, print the string
2987 and then the error message. */
2988 if (err
== 0 || bytes_read
> 0)
2990 LA_PRINT_STRING (stream
, elttype
, buffer
, bytes_read
/ width
,
2991 encoding
, force_ellipsis
, options
);
2998 str
= memory_error_message (TARGET_XFER_E_IO
, gdbarch
, addr
);
2999 make_cleanup (xfree
, str
);
3001 fprintf_filtered (stream
, "<error: ");
3002 fputs_filtered (str
, stream
);
3003 fprintf_filtered (stream
, ">");
3007 do_cleanups (old_chain
);
3009 return (bytes_read
/ width
);
3013 /* The 'set input-radix' command writes to this auxiliary variable.
3014 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
3015 it is left unchanged. */
3017 static unsigned input_radix_1
= 10;
3019 /* Validate an input or output radix setting, and make sure the user
3020 knows what they really did here. Radix setting is confusing, e.g.
3021 setting the input radix to "10" never changes it! */
3024 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
3026 set_input_radix_1 (from_tty
, input_radix_1
);
3030 set_input_radix_1 (int from_tty
, unsigned radix
)
3032 /* We don't currently disallow any input radix except 0 or 1, which don't
3033 make any mathematical sense. In theory, we can deal with any input
3034 radix greater than 1, even if we don't have unique digits for every
3035 value from 0 to radix-1, but in practice we lose on large radix values.
3036 We should either fix the lossage or restrict the radix range more.
3041 input_radix_1
= input_radix
;
3042 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
3045 input_radix_1
= input_radix
= radix
;
3048 printf_filtered (_("Input radix now set to "
3049 "decimal %u, hex %x, octal %o.\n"),
3050 radix
, radix
, radix
);
3054 /* The 'set output-radix' command writes to this auxiliary variable.
3055 If the requested radix is valid, OUTPUT_RADIX is updated,
3056 otherwise, it is left unchanged. */
3058 static unsigned output_radix_1
= 10;
3061 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
3063 set_output_radix_1 (from_tty
, output_radix_1
);
3067 set_output_radix_1 (int from_tty
, unsigned radix
)
3069 /* Validate the radix and disallow ones that we aren't prepared to
3070 handle correctly, leaving the radix unchanged. */
3074 user_print_options
.output_format
= 'x'; /* hex */
3077 user_print_options
.output_format
= 0; /* decimal */
3080 user_print_options
.output_format
= 'o'; /* octal */
3083 output_radix_1
= output_radix
;
3084 error (_("Unsupported output radix ``decimal %u''; "
3085 "output radix unchanged."),
3088 output_radix_1
= output_radix
= radix
;
3091 printf_filtered (_("Output radix now set to "
3092 "decimal %u, hex %x, octal %o.\n"),
3093 radix
, radix
, radix
);
3097 /* Set both the input and output radix at once. Try to set the output radix
3098 first, since it has the most restrictive range. An radix that is valid as
3099 an output radix is also valid as an input radix.
3101 It may be useful to have an unusual input radix. If the user wishes to
3102 set an input radix that is not valid as an output radix, he needs to use
3103 the 'set input-radix' command. */
3106 set_radix (char *arg
, int from_tty
)
3110 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
3111 set_output_radix_1 (0, radix
);
3112 set_input_radix_1 (0, radix
);
3115 printf_filtered (_("Input and output radices now set to "
3116 "decimal %u, hex %x, octal %o.\n"),
3117 radix
, radix
, radix
);
3121 /* Show both the input and output radices. */
3124 show_radix (char *arg
, int from_tty
)
3128 if (input_radix
== output_radix
)
3130 printf_filtered (_("Input and output radices set to "
3131 "decimal %u, hex %x, octal %o.\n"),
3132 input_radix
, input_radix
, input_radix
);
3136 printf_filtered (_("Input radix set to decimal "
3137 "%u, hex %x, octal %o.\n"),
3138 input_radix
, input_radix
, input_radix
);
3139 printf_filtered (_("Output radix set to decimal "
3140 "%u, hex %x, octal %o.\n"),
3141 output_radix
, output_radix
, output_radix
);
3148 set_print (char *arg
, int from_tty
)
3151 "\"set print\" must be followed by the name of a print subcommand.\n");
3152 help_list (setprintlist
, "set print ", all_commands
, gdb_stdout
);
3156 show_print (char *args
, int from_tty
)
3158 cmd_show_list (showprintlist
, from_tty
, "");
3162 set_print_raw (char *arg
, int from_tty
)
3165 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
3166 help_list (setprintrawlist
, "set print raw ", all_commands
, gdb_stdout
);
3170 show_print_raw (char *args
, int from_tty
)
3172 cmd_show_list (showprintrawlist
, from_tty
, "");
3177 _initialize_valprint (void)
3179 add_prefix_cmd ("print", no_class
, set_print
,
3180 _("Generic command for setting how things print."),
3181 &setprintlist
, "set print ", 0, &setlist
);
3182 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
3183 /* Prefer set print to set prompt. */
3184 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
3186 add_prefix_cmd ("print", no_class
, show_print
,
3187 _("Generic command for showing print settings."),
3188 &showprintlist
, "show print ", 0, &showlist
);
3189 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
3190 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
3192 add_prefix_cmd ("raw", no_class
, set_print_raw
,
3194 Generic command for setting what things to print in \"raw\" mode."),
3195 &setprintrawlist
, "set print raw ", 0, &setprintlist
);
3196 add_prefix_cmd ("raw", no_class
, show_print_raw
,
3197 _("Generic command for showing \"print raw\" settings."),
3198 &showprintrawlist
, "show print raw ", 0, &showprintlist
);
3200 add_setshow_uinteger_cmd ("elements", no_class
,
3201 &user_print_options
.print_max
, _("\
3202 Set limit on string chars or array elements to print."), _("\
3203 Show limit on string chars or array elements to print."), _("\
3204 \"set print elements unlimited\" causes there to be no limit."),
3207 &setprintlist
, &showprintlist
);
3209 add_setshow_boolean_cmd ("null-stop", no_class
,
3210 &user_print_options
.stop_print_at_null
, _("\
3211 Set printing of char arrays to stop at first null char."), _("\
3212 Show printing of char arrays to stop at first null char."), NULL
,
3214 show_stop_print_at_null
,
3215 &setprintlist
, &showprintlist
);
3217 add_setshow_uinteger_cmd ("repeats", no_class
,
3218 &user_print_options
.repeat_count_threshold
, _("\
3219 Set threshold for repeated print elements."), _("\
3220 Show threshold for repeated print elements."), _("\
3221 \"set print repeats unlimited\" causes all elements to be individually printed."),
3223 show_repeat_count_threshold
,
3224 &setprintlist
, &showprintlist
);
3226 add_setshow_boolean_cmd ("pretty", class_support
,
3227 &user_print_options
.prettyformat_structs
, _("\
3228 Set pretty formatting of structures."), _("\
3229 Show pretty formatting of structures."), NULL
,
3231 show_prettyformat_structs
,
3232 &setprintlist
, &showprintlist
);
3234 add_setshow_boolean_cmd ("union", class_support
,
3235 &user_print_options
.unionprint
, _("\
3236 Set printing of unions interior to structures."), _("\
3237 Show printing of unions interior to structures."), NULL
,
3240 &setprintlist
, &showprintlist
);
3242 add_setshow_boolean_cmd ("array", class_support
,
3243 &user_print_options
.prettyformat_arrays
, _("\
3244 Set pretty formatting of arrays."), _("\
3245 Show pretty formatting of arrays."), NULL
,
3247 show_prettyformat_arrays
,
3248 &setprintlist
, &showprintlist
);
3250 add_setshow_boolean_cmd ("address", class_support
,
3251 &user_print_options
.addressprint
, _("\
3252 Set printing of addresses."), _("\
3253 Show printing of addresses."), NULL
,
3256 &setprintlist
, &showprintlist
);
3258 add_setshow_boolean_cmd ("symbol", class_support
,
3259 &user_print_options
.symbol_print
, _("\
3260 Set printing of symbol names when printing pointers."), _("\
3261 Show printing of symbol names when printing pointers."),
3264 &setprintlist
, &showprintlist
);
3266 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
3268 Set default input radix for entering numbers."), _("\
3269 Show default input radix for entering numbers."), NULL
,
3272 &setlist
, &showlist
);
3274 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
3276 Set default output radix for printing of values."), _("\
3277 Show default output radix for printing of values."), NULL
,
3280 &setlist
, &showlist
);
3282 /* The "set radix" and "show radix" commands are special in that
3283 they are like normal set and show commands but allow two normally
3284 independent variables to be either set or shown with a single
3285 command. So the usual deprecated_add_set_cmd() and [deleted]
3286 add_show_from_set() commands aren't really appropriate. */
3287 /* FIXME: i18n: With the new add_setshow_integer command, that is no
3288 longer true - show can display anything. */
3289 add_cmd ("radix", class_support
, set_radix
, _("\
3290 Set default input and output number radices.\n\
3291 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
3292 Without an argument, sets both radices back to the default value of 10."),
3294 add_cmd ("radix", class_support
, show_radix
, _("\
3295 Show the default input and output number radices.\n\
3296 Use 'show input-radix' or 'show output-radix' to independently show each."),
3299 add_setshow_boolean_cmd ("array-indexes", class_support
,
3300 &user_print_options
.print_array_indexes
, _("\
3301 Set printing of array indexes."), _("\
3302 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
3303 &setprintlist
, &showprintlist
);