1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 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"
39 /* Maximum number of wchars returned from wchar_iterate. */
42 /* A convenience macro to compute the size of a wchar_t buffer containing X
44 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
46 /* Character buffer size saved while iterating over wchars. */
47 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
49 /* A structure to encapsulate state information from iterated
50 character conversions. */
51 struct converted_character
53 /* The number of characters converted. */
56 /* The result of the conversion. See charset.h for more. */
57 enum wchar_iterate_result result
;
59 /* The (saved) converted character(s). */
60 gdb_wchar_t chars
[WCHAR_BUFLEN_MAX
];
62 /* The first converted target byte. */
65 /* The number of bytes converted. */
68 /* How many times this character(s) is repeated. */
72 typedef struct converted_character converted_character_d
;
73 DEF_VEC_O (converted_character_d
);
75 /* Command lists for set/show print raw. */
76 struct cmd_list_element
*setprintrawlist
;
77 struct cmd_list_element
*showprintrawlist
;
79 /* Prototypes for local functions */
81 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
82 int len
, int *errptr
);
84 static void show_print (char *, int);
86 static void set_print (char *, int);
88 static void set_radix (char *, int);
90 static void show_radix (char *, int);
92 static void set_input_radix (char *, int, struct cmd_list_element
*);
94 static void set_input_radix_1 (int, unsigned);
96 static void set_output_radix (char *, int, struct cmd_list_element
*);
98 static void set_output_radix_1 (int, unsigned);
100 void _initialize_valprint (void);
102 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
104 struct value_print_options user_print_options
=
106 Val_prettyformat_default
, /* prettyformat */
107 0, /* prettyformat_arrays */
108 0, /* prettyformat_structs */
111 1, /* addressprint */
113 PRINT_MAX_DEFAULT
, /* print_max */
114 10, /* repeat_count_threshold */
115 0, /* output_format */
117 0, /* stop_print_at_null */
118 0, /* print_array_indexes */
120 1, /* static_field_print */
121 1, /* pascal_static_field_print */
127 /* Initialize *OPTS to be a copy of the user print options. */
129 get_user_print_options (struct value_print_options
*opts
)
131 *opts
= user_print_options
;
134 /* Initialize *OPTS to be a copy of the user print options, but with
135 pretty-formatting disabled. */
137 get_no_prettyformat_print_options (struct value_print_options
*opts
)
139 *opts
= user_print_options
;
140 opts
->prettyformat
= Val_no_prettyformat
;
143 /* Initialize *OPTS to be a copy of the user print options, but using
144 FORMAT as the formatting option. */
146 get_formatted_print_options (struct value_print_options
*opts
,
149 *opts
= user_print_options
;
150 opts
->format
= format
;
154 show_print_max (struct ui_file
*file
, int from_tty
,
155 struct cmd_list_element
*c
, const char *value
)
157 fprintf_filtered (file
,
158 _("Limit on string chars or array "
159 "elements to print is %s.\n"),
164 /* Default input and output radixes, and output format letter. */
166 unsigned input_radix
= 10;
168 show_input_radix (struct ui_file
*file
, int from_tty
,
169 struct cmd_list_element
*c
, const char *value
)
171 fprintf_filtered (file
,
172 _("Default input radix for entering numbers is %s.\n"),
176 unsigned output_radix
= 10;
178 show_output_radix (struct ui_file
*file
, int from_tty
,
179 struct cmd_list_element
*c
, const char *value
)
181 fprintf_filtered (file
,
182 _("Default output radix for printing of values is %s.\n"),
186 /* By default we print arrays without printing the index of each element in
187 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
190 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
191 struct cmd_list_element
*c
, const char *value
)
193 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
196 /* Print repeat counts if there are more than this many repetitions of an
197 element in an array. Referenced by the low level language dependent
201 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
202 struct cmd_list_element
*c
, const char *value
)
204 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
208 /* If nonzero, stops printing of char arrays at first null. */
211 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
212 struct cmd_list_element
*c
, const char *value
)
214 fprintf_filtered (file
,
215 _("Printing of char arrays to stop "
216 "at first null char is %s.\n"),
220 /* Controls pretty printing of structures. */
223 show_prettyformat_structs (struct ui_file
*file
, int from_tty
,
224 struct cmd_list_element
*c
, const char *value
)
226 fprintf_filtered (file
, _("Pretty formatting of structures is %s.\n"), value
);
229 /* Controls pretty printing of arrays. */
232 show_prettyformat_arrays (struct ui_file
*file
, int from_tty
,
233 struct cmd_list_element
*c
, const char *value
)
235 fprintf_filtered (file
, _("Pretty formatting of arrays is %s.\n"), value
);
238 /* If nonzero, causes unions inside structures or other unions to be
242 show_unionprint (struct ui_file
*file
, int from_tty
,
243 struct cmd_list_element
*c
, const char *value
)
245 fprintf_filtered (file
,
246 _("Printing of unions interior to structures is %s.\n"),
250 /* If nonzero, causes machine addresses to be printed in certain contexts. */
253 show_addressprint (struct ui_file
*file
, int from_tty
,
254 struct cmd_list_element
*c
, const char *value
)
256 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
260 show_symbol_print (struct ui_file
*file
, int from_tty
,
261 struct cmd_list_element
*c
, const char *value
)
263 fprintf_filtered (file
,
264 _("Printing of symbols when printing pointers is %s.\n"),
270 /* A helper function for val_print. When printing in "summary" mode,
271 we want to print scalar arguments, but not aggregate arguments.
272 This function distinguishes between the two. */
275 val_print_scalar_type_p (struct type
*type
)
277 type
= check_typedef (type
);
278 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
280 type
= TYPE_TARGET_TYPE (type
);
281 type
= check_typedef (type
);
283 switch (TYPE_CODE (type
))
285 case TYPE_CODE_ARRAY
:
286 case TYPE_CODE_STRUCT
:
287 case TYPE_CODE_UNION
:
289 case TYPE_CODE_STRING
:
296 /* See its definition in value.h. */
299 valprint_check_validity (struct ui_file
*stream
,
302 const struct value
*val
)
304 type
= check_typedef (type
);
306 if (TYPE_CODE (type
) != TYPE_CODE_UNION
307 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
308 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
310 if (value_bits_any_optimized_out (val
,
311 TARGET_CHAR_BIT
* embedded_offset
,
312 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
314 val_print_optimized_out (val
, stream
);
318 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
319 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
321 fputs_filtered (_("<synthetic pointer>"), stream
);
325 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
327 val_print_unavailable (stream
);
336 val_print_optimized_out (const struct value
*val
, struct ui_file
*stream
)
338 if (val
!= NULL
&& value_lval_const (val
) == lval_register
)
339 val_print_not_saved (stream
);
341 fprintf_filtered (stream
, _("<optimized out>"));
345 val_print_not_saved (struct ui_file
*stream
)
347 fprintf_filtered (stream
, _("<not saved>"));
351 val_print_unavailable (struct ui_file
*stream
)
353 fprintf_filtered (stream
, _("<unavailable>"));
357 val_print_invalid_address (struct ui_file
*stream
)
359 fprintf_filtered (stream
, _("<invalid address>"));
362 /* Print a pointer based on the type of its target.
364 Arguments to this functions are roughly the same as those in
365 generic_val_print. A difference is that ADDRESS is the address to print,
366 with embedded_offset already added. ELTTYPE represents
367 the pointed type after check_typedef. */
370 print_unpacked_pointer (struct type
*type
, struct type
*elttype
,
371 CORE_ADDR address
, struct ui_file
*stream
,
372 const struct value_print_options
*options
)
374 struct gdbarch
*gdbarch
= get_type_arch (type
);
376 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
378 /* Try to print what function it points to. */
379 print_function_pointer_address (options
, gdbarch
, address
, stream
);
383 if (options
->symbol_print
)
384 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
385 else if (options
->addressprint
)
386 fputs_filtered (paddress (gdbarch
, address
), stream
);
389 /* generic_val_print helper for TYPE_CODE_ARRAY. */
392 generic_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
393 int embedded_offset
, CORE_ADDR address
,
394 struct ui_file
*stream
, int recurse
,
395 const struct value
*original_value
,
396 const struct value_print_options
*options
)
398 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE (type
);
399 struct type
*elttype
= check_typedef (unresolved_elttype
);
401 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
403 LONGEST low_bound
, high_bound
;
405 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
406 error (_("Could not determine the array high bound"));
408 if (options
->prettyformat_arrays
)
410 print_spaces_filtered (2 + 2 * recurse
, stream
);
413 fprintf_filtered (stream
, "{");
414 val_print_array_elements (type
, valaddr
, embedded_offset
,
416 recurse
, original_value
, options
, 0);
417 fprintf_filtered (stream
, "}");
421 /* Array of unspecified length: treat like pointer to first elt. */
422 print_unpacked_pointer (type
, elttype
, address
+ embedded_offset
, stream
,
428 /* generic_val_print helper for TYPE_CODE_PTR. */
431 generic_val_print_ptr (struct type
*type
, const gdb_byte
*valaddr
,
432 int embedded_offset
, struct ui_file
*stream
,
433 const struct value
*original_value
,
434 const struct value_print_options
*options
)
436 if (options
->format
&& options
->format
!= 's')
438 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
439 original_value
, options
, 0, stream
);
443 struct type
*unresolved_elttype
= TYPE_TARGET_TYPE(type
);
444 struct type
*elttype
= check_typedef (unresolved_elttype
);
445 CORE_ADDR addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
447 print_unpacked_pointer (type
, elttype
, addr
, stream
, options
);
452 /* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
455 generic_val_print_memberptr (struct type
*type
, const gdb_byte
*valaddr
,
456 int embedded_offset
, struct ui_file
*stream
,
457 const struct value
*original_value
,
458 const struct value_print_options
*options
)
460 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
461 original_value
, options
, 0, stream
);
464 /* generic_val_print helper for TYPE_CODE_REF. */
467 generic_val_print_ref (struct type
*type
, const gdb_byte
*valaddr
,
468 int embedded_offset
, struct ui_file
*stream
, int recurse
,
469 const struct value
*original_value
,
470 const struct value_print_options
*options
)
472 struct gdbarch
*gdbarch
= get_type_arch (type
);
473 struct type
*elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
475 if (options
->addressprint
)
478 = extract_typed_address (valaddr
+ embedded_offset
, type
);
480 fprintf_filtered (stream
, "@");
481 fputs_filtered (paddress (gdbarch
, addr
), stream
);
482 if (options
->deref_ref
)
483 fputs_filtered (": ", stream
);
485 /* De-reference the reference. */
486 if (options
->deref_ref
)
488 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
490 struct value
*deref_val
;
492 deref_val
= coerce_ref_if_computed (original_value
);
493 if (deref_val
!= NULL
)
495 /* More complicated computed references are not supported. */
496 gdb_assert (embedded_offset
== 0);
499 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
500 unpack_pointer (type
,
502 + embedded_offset
)));
504 common_val_print (deref_val
, stream
, recurse
, options
,
508 fputs_filtered ("???", stream
);
512 /* generic_val_print helper for TYPE_CODE_ENUM. */
515 generic_val_print_enum (struct type
*type
, const gdb_byte
*valaddr
,
516 int embedded_offset
, struct ui_file
*stream
,
517 const struct value
*original_value
,
518 const struct value_print_options
*options
)
526 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
527 original_value
, options
, 0, stream
);
530 len
= TYPE_NFIELDS (type
);
531 val
= unpack_long (type
, valaddr
+ embedded_offset
);
532 for (i
= 0; i
< len
; i
++)
535 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
542 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
544 else if (TYPE_FLAG_ENUM (type
))
548 /* We have a "flag" enum, so we try to decompose it into
549 pieces as appropriate. A flag enum has disjoint
550 constants by definition. */
551 fputs_filtered ("(", stream
);
552 for (i
= 0; i
< len
; ++i
)
556 if ((val
& TYPE_FIELD_ENUMVAL (type
, i
)) != 0)
559 fputs_filtered (" | ", stream
);
562 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
563 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
567 if (first
|| val
!= 0)
570 fputs_filtered (" | ", stream
);
571 fputs_filtered ("unknown: ", stream
);
572 print_longest (stream
, 'd', 0, val
);
575 fputs_filtered (")", stream
);
578 print_longest (stream
, 'd', 0, val
);
581 /* A generic val_print that is suitable for use by language
582 implementations of the la_val_print method. This function can
583 handle most type codes, though not all, notably exception
584 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
587 Most arguments are as to val_print.
589 The additional DECORATIONS argument can be used to customize the
590 output in some small, language-specific ways. */
593 generic_val_print (struct type
*type
, const gdb_byte
*valaddr
,
594 int embedded_offset
, CORE_ADDR address
,
595 struct ui_file
*stream
, int recurse
,
596 const struct value
*original_value
,
597 const struct value_print_options
*options
,
598 const struct generic_val_print_decorations
*decorations
)
600 struct gdbarch
*gdbarch
= get_type_arch (type
);
601 struct type
*unresolved_type
= type
;
604 type
= check_typedef (type
);
605 switch (TYPE_CODE (type
))
607 case TYPE_CODE_ARRAY
:
608 generic_val_print_array (type
, valaddr
, embedded_offset
, address
, stream
,
609 recurse
, original_value
, options
);
612 case TYPE_CODE_MEMBERPTR
:
613 generic_val_print_memberptr (type
, valaddr
, embedded_offset
, stream
,
614 original_value
, options
);
618 generic_val_print_ptr (type
, valaddr
, embedded_offset
, stream
,
619 original_value
, options
);
623 generic_val_print_ref (type
, valaddr
, embedded_offset
, stream
, recurse
,
624 original_value
, options
);
628 generic_val_print_enum (type
, valaddr
, embedded_offset
, stream
,
629 original_value
, options
);
632 case TYPE_CODE_FLAGS
:
634 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
635 original_value
, options
, 0, stream
);
637 val_print_type_code_flags (type
, valaddr
+ embedded_offset
,
642 case TYPE_CODE_METHOD
:
645 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
646 original_value
, options
, 0, stream
);
649 /* FIXME, we should consider, at least for ANSI C language,
650 eliminating the distinction made between FUNCs and POINTERs
652 fprintf_filtered (stream
, "{");
653 type_print (type
, "", stream
, -1);
654 fprintf_filtered (stream
, "} ");
655 /* Try to print what function it points to, and its address. */
656 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
660 if (options
->format
|| options
->output_format
)
662 struct value_print_options opts
= *options
;
663 opts
.format
= (options
->format
? options
->format
664 : options
->output_format
);
665 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
666 original_value
, &opts
, 0, stream
);
670 val
= unpack_long (type
, valaddr
+ embedded_offset
);
672 fputs_filtered (decorations
->false_name
, stream
);
674 fputs_filtered (decorations
->true_name
, stream
);
676 print_longest (stream
, 'd', 0, val
);
680 case TYPE_CODE_RANGE
:
681 /* FIXME: create_static_range_type does not set the unsigned bit in a
682 range type (I think it probably should copy it from the
683 target type), so we won't print values which are too large to
684 fit in a signed integer correctly. */
685 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
686 print with the target type, though, because the size of our
687 type and the target type might differ). */
692 if (options
->format
|| options
->output_format
)
694 struct value_print_options opts
= *options
;
696 opts
.format
= (options
->format
? options
->format
697 : options
->output_format
);
698 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
699 original_value
, &opts
, 0, stream
);
702 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
706 if (options
->format
|| options
->output_format
)
708 struct value_print_options opts
= *options
;
710 opts
.format
= (options
->format
? options
->format
711 : options
->output_format
);
712 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
713 original_value
, &opts
, 0, stream
);
717 val
= unpack_long (type
, valaddr
+ embedded_offset
);
718 if (TYPE_UNSIGNED (type
))
719 fprintf_filtered (stream
, "%u", (unsigned int) val
);
721 fprintf_filtered (stream
, "%d", (int) val
);
722 fputs_filtered (" ", stream
);
723 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
730 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
731 original_value
, options
, 0, stream
);
735 print_floating (valaddr
+ embedded_offset
, type
, stream
);
739 case TYPE_CODE_DECFLOAT
:
741 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
742 original_value
, options
, 0, stream
);
744 print_decimal_floating (valaddr
+ embedded_offset
,
749 fputs_filtered (decorations
->void_name
, stream
);
752 case TYPE_CODE_ERROR
:
753 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
756 case TYPE_CODE_UNDEF
:
757 /* This happens (without TYPE_FLAG_STUB set) on systems which
758 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
759 "struct foo *bar" and no complete type for struct foo in that
761 fprintf_filtered (stream
, _("<incomplete type>"));
764 case TYPE_CODE_COMPLEX
:
765 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
767 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
768 valaddr
, embedded_offset
,
769 original_value
, options
, 0, stream
);
771 print_floating (valaddr
+ embedded_offset
,
772 TYPE_TARGET_TYPE (type
),
774 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
776 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
779 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
783 print_floating (valaddr
+ embedded_offset
784 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
785 TYPE_TARGET_TYPE (type
),
787 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
790 case TYPE_CODE_UNION
:
791 case TYPE_CODE_STRUCT
:
792 case TYPE_CODE_METHODPTR
:
794 error (_("Unhandled type code %d in symbol table."),
800 /* Print using the given LANGUAGE the data of type TYPE located at
801 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
802 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
803 STREAM according to OPTIONS. VAL is the whole object that came
804 from ADDRESS. VALADDR must point to the head of VAL's contents
807 The language printers will pass down an adjusted EMBEDDED_OFFSET to
808 further helper subroutines as subfields of TYPE are printed. In
809 such cases, VALADDR is passed down unadjusted, as well as VAL, so
810 that VAL can be queried for metadata about the contents data being
811 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
812 buffer. For example: "has this field been optimized out", or "I'm
813 printing an object while inspecting a traceframe; has this
814 particular piece of data been collected?".
816 RECURSE indicates the amount of indentation to supply before
817 continuation lines; this amount is roughly twice the value of
821 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
822 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
823 const struct value
*val
,
824 const struct value_print_options
*options
,
825 const struct language_defn
*language
)
828 struct value_print_options local_opts
= *options
;
829 struct type
*real_type
= check_typedef (type
);
831 if (local_opts
.prettyformat
== Val_prettyformat_default
)
832 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
833 ? Val_prettyformat
: Val_no_prettyformat
);
837 /* Ensure that the type is complete and not just a stub. If the type is
838 only a stub and we can't find and substitute its complete type, then
839 print appropriate string and return. */
841 if (TYPE_STUB (real_type
))
843 fprintf_filtered (stream
, _("<incomplete type>"));
848 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
853 ret
= apply_ext_lang_val_pretty_printer (type
, valaddr
, embedded_offset
,
854 address
, stream
, recurse
,
855 val
, options
, language
);
860 /* Handle summary mode. If the value is a scalar, print it;
861 otherwise, print an ellipsis. */
862 if (options
->summary
&& !val_print_scalar_type_p (type
))
864 fprintf_filtered (stream
, "...");
870 language
->la_val_print (type
, valaddr
, embedded_offset
, address
,
871 stream
, recurse
, val
,
874 CATCH (except
, RETURN_MASK_ERROR
)
876 fprintf_filtered (stream
, _("<error reading variable>"));
881 /* Check whether the value VAL is printable. Return 1 if it is;
882 return 0 and print an appropriate error message to STREAM according to
883 OPTIONS if it is not. */
886 value_check_printable (struct value
*val
, struct ui_file
*stream
,
887 const struct value_print_options
*options
)
891 fprintf_filtered (stream
, _("<address of value unknown>"));
895 if (value_entirely_optimized_out (val
))
897 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
898 fprintf_filtered (stream
, "...");
900 val_print_optimized_out (val
, stream
);
904 if (value_entirely_unavailable (val
))
906 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
907 fprintf_filtered (stream
, "...");
909 val_print_unavailable (stream
);
913 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
915 fprintf_filtered (stream
, _("<internal function %s>"),
916 value_internal_function_name (val
));
923 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
926 This is a preferable interface to val_print, above, because it uses
927 GDB's value mechanism. */
930 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
931 const struct value_print_options
*options
,
932 const struct language_defn
*language
)
934 if (!value_check_printable (val
, stream
, options
))
937 if (language
->la_language
== language_ada
)
938 /* The value might have a dynamic type, which would cause trouble
939 below when trying to extract the value contents (since the value
940 size is determined from the type size which is unknown). So
941 get a fixed representation of our value. */
942 val
= ada_to_fixed_value (val
);
944 val_print (value_type (val
), value_contents_for_printing (val
),
945 value_embedded_offset (val
), value_address (val
),
947 val
, options
, language
);
950 /* Print on stream STREAM the value VAL according to OPTIONS. The value
951 is printed using the current_language syntax. */
954 value_print (struct value
*val
, struct ui_file
*stream
,
955 const struct value_print_options
*options
)
957 if (!value_check_printable (val
, stream
, options
))
963 = apply_ext_lang_val_pretty_printer (value_type (val
),
964 value_contents_for_printing (val
),
965 value_embedded_offset (val
),
968 val
, options
, current_language
);
974 LA_VALUE_PRINT (val
, stream
, options
);
977 /* Called by various <lang>_val_print routines to print
978 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
979 value. STREAM is where to print the value. */
982 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
983 struct ui_file
*stream
)
985 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
987 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
991 if (TYPE_UNSIGNED (type
)
992 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
995 print_longest (stream
, 'u', 0, val
);
999 /* Signed, or we couldn't turn an unsigned value into a
1000 LONGEST. For signed values, one could assume two's
1001 complement (a reasonable assumption, I think) and do
1002 better than this. */
1003 print_hex_chars (stream
, (unsigned char *) valaddr
,
1004 TYPE_LENGTH (type
), byte_order
);
1009 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
1010 unpack_long (type
, valaddr
));
1015 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
1016 struct ui_file
*stream
)
1018 ULONGEST val
= unpack_long (type
, valaddr
);
1019 int bitpos
, nfields
= TYPE_NFIELDS (type
);
1021 fputs_filtered ("[ ", stream
);
1022 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
1024 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
1025 && (val
& ((ULONGEST
)1 << bitpos
)))
1027 if (TYPE_FIELD_NAME (type
, bitpos
))
1028 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
1030 fprintf_filtered (stream
, "#%d ", bitpos
);
1033 fputs_filtered ("]", stream
);
1036 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
1037 according to OPTIONS and SIZE on STREAM. Format i is not supported
1040 This is how the elements of an array or structure are printed
1044 val_print_scalar_formatted (struct type
*type
,
1045 const gdb_byte
*valaddr
, int embedded_offset
,
1046 const struct value
*val
,
1047 const struct value_print_options
*options
,
1049 struct ui_file
*stream
)
1051 gdb_assert (val
!= NULL
);
1052 gdb_assert (valaddr
== value_contents_for_printing_const (val
));
1054 /* If we get here with a string format, try again without it. Go
1055 all the way back to the language printers, which may call us
1057 if (options
->format
== 's')
1059 struct value_print_options opts
= *options
;
1062 val_print (type
, valaddr
, embedded_offset
, 0, stream
, 0, val
, &opts
,
1067 /* A scalar object that does not have all bits available can't be
1068 printed, because all bits contribute to its representation. */
1069 if (value_bits_any_optimized_out (val
,
1070 TARGET_CHAR_BIT
* embedded_offset
,
1071 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
1072 val_print_optimized_out (val
, stream
);
1073 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
1074 val_print_unavailable (stream
);
1076 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
1077 options
, size
, stream
);
1080 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1081 The raison d'etre of this function is to consolidate printing of
1082 LONG_LONG's into this one function. The format chars b,h,w,g are
1083 from print_scalar_formatted(). Numbers are printed using C
1086 USE_C_FORMAT means to use C format in all cases. Without it,
1087 'o' and 'x' format do not include the standard C radix prefix
1090 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1091 and was intended to request formating according to the current
1092 language and would be used for most integers that GDB prints. The
1093 exceptional cases were things like protocols where the format of
1094 the integer is a protocol thing, not a user-visible thing). The
1095 parameter remains to preserve the information of what things might
1096 be printed with language-specific format, should we ever resurrect
1100 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1108 val
= int_string (val_long
, 10, 1, 0, 1); break;
1110 val
= int_string (val_long
, 10, 0, 0, 1); break;
1112 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1114 val
= int_string (val_long
, 16, 0, 2, 1); break;
1116 val
= int_string (val_long
, 16, 0, 4, 1); break;
1118 val
= int_string (val_long
, 16, 0, 8, 1); break;
1120 val
= int_string (val_long
, 16, 0, 16, 1); break;
1123 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1125 internal_error (__FILE__
, __LINE__
,
1126 _("failed internal consistency check"));
1128 fputs_filtered (val
, stream
);
1131 /* This used to be a macro, but I don't think it is called often enough
1132 to merit such treatment. */
1133 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1134 arguments to a function, number in a value history, register number, etc.)
1135 where the value must not be larger than can fit in an int. */
1138 longest_to_int (LONGEST arg
)
1140 /* Let the compiler do the work. */
1141 int rtnval
= (int) arg
;
1143 /* Check for overflows or underflows. */
1144 if (sizeof (LONGEST
) > sizeof (int))
1148 error (_("Value out of range."));
1154 /* Print a floating point value of type TYPE (not always a
1155 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1158 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1159 struct ui_file
*stream
)
1163 const struct floatformat
*fmt
= NULL
;
1164 unsigned len
= TYPE_LENGTH (type
);
1165 enum float_kind kind
;
1167 /* If it is a floating-point, check for obvious problems. */
1168 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1169 fmt
= floatformat_from_type (type
);
1172 kind
= floatformat_classify (fmt
, valaddr
);
1173 if (kind
== float_nan
)
1175 if (floatformat_is_negative (fmt
, valaddr
))
1176 fprintf_filtered (stream
, "-");
1177 fprintf_filtered (stream
, "nan(");
1178 fputs_filtered ("0x", stream
);
1179 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
1180 fprintf_filtered (stream
, ")");
1183 else if (kind
== float_infinite
)
1185 if (floatformat_is_negative (fmt
, valaddr
))
1186 fputs_filtered ("-", stream
);
1187 fputs_filtered ("inf", stream
);
1192 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1193 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1194 needs to be used as that takes care of any necessary type
1195 conversions. Such conversions are of course direct to DOUBLEST
1196 and disregard any possible target floating point limitations.
1197 For instance, a u64 would be converted and displayed exactly on a
1198 host with 80 bit DOUBLEST but with loss of information on a host
1199 with 64 bit DOUBLEST. */
1201 doub
= unpack_double (type
, valaddr
, &inv
);
1204 fprintf_filtered (stream
, "<invalid float value>");
1208 /* FIXME: kettenis/2001-01-20: The following code makes too much
1209 assumptions about the host and target floating point format. */
1211 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1212 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1213 instead uses the type's length to determine the precision of the
1214 floating-point value being printed. */
1216 if (len
< sizeof (double))
1217 fprintf_filtered (stream
, "%.9g", (double) doub
);
1218 else if (len
== sizeof (double))
1219 fprintf_filtered (stream
, "%.17g", (double) doub
);
1221 #ifdef PRINTF_HAS_LONG_DOUBLE
1222 fprintf_filtered (stream
, "%.35Lg", doub
);
1224 /* This at least wins with values that are representable as
1226 fprintf_filtered (stream
, "%.17g", (double) doub
);
1231 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
1232 struct ui_file
*stream
)
1234 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
1235 char decstr
[MAX_DECIMAL_STRING
];
1236 unsigned len
= TYPE_LENGTH (type
);
1238 decimal_to_string (valaddr
, len
, byte_order
, decstr
);
1239 fputs_filtered (decstr
, stream
);
1244 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1245 unsigned len
, enum bfd_endian byte_order
)
1248 #define BITS_IN_BYTES 8
1254 /* Declared "int" so it will be signed.
1255 This ensures that right shift will shift in zeros. */
1257 const int mask
= 0x080;
1259 /* FIXME: We should be not printing leading zeroes in most cases. */
1261 if (byte_order
== BFD_ENDIAN_BIG
)
1267 /* Every byte has 8 binary characters; peel off
1268 and print from the MSB end. */
1270 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1272 if (*p
& (mask
>> i
))
1277 fprintf_filtered (stream
, "%1d", b
);
1283 for (p
= valaddr
+ len
- 1;
1287 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1289 if (*p
& (mask
>> i
))
1294 fprintf_filtered (stream
, "%1d", b
);
1300 /* VALADDR points to an integer of LEN bytes.
1301 Print it in octal on stream or format it in buf. */
1304 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1305 unsigned len
, enum bfd_endian byte_order
)
1308 unsigned char octa1
, octa2
, octa3
, carry
;
1311 /* FIXME: We should be not printing leading zeroes in most cases. */
1314 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1315 * the extra bits, which cycle every three bytes:
1317 * Byte side: 0 1 2 3
1319 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1321 * Octal side: 0 1 carry 3 4 carry ...
1323 * Cycle number: 0 1 2
1325 * But of course we are printing from the high side, so we have to
1326 * figure out where in the cycle we are so that we end up with no
1327 * left over bits at the end.
1329 #define BITS_IN_OCTAL 3
1330 #define HIGH_ZERO 0340
1331 #define LOW_ZERO 0016
1332 #define CARRY_ZERO 0003
1333 #define HIGH_ONE 0200
1334 #define MID_ONE 0160
1335 #define LOW_ONE 0016
1336 #define CARRY_ONE 0001
1337 #define HIGH_TWO 0300
1338 #define MID_TWO 0070
1339 #define LOW_TWO 0007
1341 /* For 32 we start in cycle 2, with two bits and one bit carry;
1342 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1344 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
1347 fputs_filtered ("0", stream
);
1348 if (byte_order
== BFD_ENDIAN_BIG
)
1357 /* No carry in, carry out two bits. */
1359 octa1
= (HIGH_ZERO
& *p
) >> 5;
1360 octa2
= (LOW_ZERO
& *p
) >> 2;
1361 carry
= (CARRY_ZERO
& *p
);
1362 fprintf_filtered (stream
, "%o", octa1
);
1363 fprintf_filtered (stream
, "%o", octa2
);
1367 /* Carry in two bits, carry out one bit. */
1369 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1370 octa2
= (MID_ONE
& *p
) >> 4;
1371 octa3
= (LOW_ONE
& *p
) >> 1;
1372 carry
= (CARRY_ONE
& *p
);
1373 fprintf_filtered (stream
, "%o", octa1
);
1374 fprintf_filtered (stream
, "%o", octa2
);
1375 fprintf_filtered (stream
, "%o", octa3
);
1379 /* Carry in one bit, no carry out. */
1381 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1382 octa2
= (MID_TWO
& *p
) >> 3;
1383 octa3
= (LOW_TWO
& *p
);
1385 fprintf_filtered (stream
, "%o", octa1
);
1386 fprintf_filtered (stream
, "%o", octa2
);
1387 fprintf_filtered (stream
, "%o", octa3
);
1391 error (_("Internal error in octal conversion;"));
1395 cycle
= cycle
% BITS_IN_OCTAL
;
1400 for (p
= valaddr
+ len
- 1;
1407 /* Carry out, no carry in */
1409 octa1
= (HIGH_ZERO
& *p
) >> 5;
1410 octa2
= (LOW_ZERO
& *p
) >> 2;
1411 carry
= (CARRY_ZERO
& *p
);
1412 fprintf_filtered (stream
, "%o", octa1
);
1413 fprintf_filtered (stream
, "%o", octa2
);
1417 /* Carry in, carry out */
1419 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1420 octa2
= (MID_ONE
& *p
) >> 4;
1421 octa3
= (LOW_ONE
& *p
) >> 1;
1422 carry
= (CARRY_ONE
& *p
);
1423 fprintf_filtered (stream
, "%o", octa1
);
1424 fprintf_filtered (stream
, "%o", octa2
);
1425 fprintf_filtered (stream
, "%o", octa3
);
1429 /* Carry in, no carry out */
1431 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1432 octa2
= (MID_TWO
& *p
) >> 3;
1433 octa3
= (LOW_TWO
& *p
);
1435 fprintf_filtered (stream
, "%o", octa1
);
1436 fprintf_filtered (stream
, "%o", octa2
);
1437 fprintf_filtered (stream
, "%o", octa3
);
1441 error (_("Internal error in octal conversion;"));
1445 cycle
= cycle
% BITS_IN_OCTAL
;
1451 /* VALADDR points to an integer of LEN bytes.
1452 Print it in decimal on stream or format it in buf. */
1455 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1456 unsigned len
, enum bfd_endian byte_order
)
1459 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1460 #define CARRY_LEFT( x ) ((x) % TEN)
1461 #define SHIFT( x ) ((x) << 4)
1462 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1463 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1466 unsigned char *digits
;
1469 int i
, j
, decimal_digits
;
1473 /* Base-ten number is less than twice as many digits
1474 as the base 16 number, which is 2 digits per byte. */
1476 decimal_len
= len
* 2 * 2;
1477 digits
= xmalloc (decimal_len
);
1479 for (i
= 0; i
< decimal_len
; i
++)
1484 /* Ok, we have an unknown number of bytes of data to be printed in
1487 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1488 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1489 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1491 * The trick is that "digits" holds a base-10 number, but sometimes
1492 * the individual digits are > 10.
1494 * Outer loop is per nibble (hex digit) of input, from MSD end to
1497 decimal_digits
= 0; /* Number of decimal digits so far */
1498 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1500 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1503 * Multiply current base-ten number by 16 in place.
1504 * Each digit was between 0 and 9, now is between
1507 for (j
= 0; j
< decimal_digits
; j
++)
1509 digits
[j
] = SHIFT (digits
[j
]);
1512 /* Take the next nibble off the input and add it to what
1513 * we've got in the LSB position. Bottom 'digit' is now
1514 * between 0 and 159.
1516 * "flip" is used to run this loop twice for each byte.
1520 /* Take top nibble. */
1522 digits
[0] += HIGH_NIBBLE (*p
);
1527 /* Take low nibble and bump our pointer "p". */
1529 digits
[0] += LOW_NIBBLE (*p
);
1530 if (byte_order
== BFD_ENDIAN_BIG
)
1537 /* Re-decimalize. We have to do this often enough
1538 * that we don't overflow, but once per nibble is
1539 * overkill. Easier this way, though. Note that the
1540 * carry is often larger than 10 (e.g. max initial
1541 * carry out of lowest nibble is 15, could bubble all
1542 * the way up greater than 10). So we have to do
1543 * the carrying beyond the last current digit.
1546 for (j
= 0; j
< decimal_len
- 1; j
++)
1550 /* "/" won't handle an unsigned char with
1551 * a value that if signed would be negative.
1552 * So extend to longword int via "dummy".
1555 carry
= CARRY_OUT (dummy
);
1556 digits
[j
] = CARRY_LEFT (dummy
);
1558 if (j
>= decimal_digits
&& carry
== 0)
1561 * All higher digits are 0 and we
1562 * no longer have a carry.
1564 * Note: "j" is 0-based, "decimal_digits" is
1567 decimal_digits
= j
+ 1;
1573 /* Ok, now "digits" is the decimal representation, with
1574 the "decimal_digits" actual digits. Print! */
1576 for (i
= decimal_digits
- 1; i
>= 0; i
--)
1578 fprintf_filtered (stream
, "%1d", digits
[i
]);
1583 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1586 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1587 unsigned len
, enum bfd_endian byte_order
)
1591 /* FIXME: We should be not printing leading zeroes in most cases. */
1593 fputs_filtered ("0x", stream
);
1594 if (byte_order
== BFD_ENDIAN_BIG
)
1600 fprintf_filtered (stream
, "%02x", *p
);
1605 for (p
= valaddr
+ len
- 1;
1609 fprintf_filtered (stream
, "%02x", *p
);
1614 /* VALADDR points to a char integer of LEN bytes.
1615 Print it out in appropriate language form on stream.
1616 Omit any leading zero chars. */
1619 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1620 const gdb_byte
*valaddr
,
1621 unsigned len
, enum bfd_endian byte_order
)
1625 if (byte_order
== BFD_ENDIAN_BIG
)
1628 while (p
< valaddr
+ len
- 1 && *p
== 0)
1631 while (p
< valaddr
+ len
)
1633 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1639 p
= valaddr
+ len
- 1;
1640 while (p
> valaddr
&& *p
== 0)
1643 while (p
>= valaddr
)
1645 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1651 /* Print function pointer with inferior address ADDRESS onto stdio
1655 print_function_pointer_address (const struct value_print_options
*options
,
1656 struct gdbarch
*gdbarch
,
1658 struct ui_file
*stream
)
1661 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
1664 /* If the function pointer is represented by a description, print
1665 the address of the description. */
1666 if (options
->addressprint
&& func_addr
!= address
)
1668 fputs_filtered ("@", stream
);
1669 fputs_filtered (paddress (gdbarch
, address
), stream
);
1670 fputs_filtered (": ", stream
);
1672 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
1676 /* Print on STREAM using the given OPTIONS the index for the element
1677 at INDEX of an array whose index type is INDEX_TYPE. */
1680 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1681 struct ui_file
*stream
,
1682 const struct value_print_options
*options
)
1684 struct value
*index_value
;
1686 if (!options
->print_array_indexes
)
1689 index_value
= value_from_longest (index_type
, index
);
1691 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
1694 /* Called by various <lang>_val_print routines to print elements of an
1695 array in the form "<elem1>, <elem2>, <elem3>, ...".
1697 (FIXME?) Assumes array element separator is a comma, which is correct
1698 for all languages currently handled.
1699 (FIXME?) Some languages have a notation for repeated array elements,
1700 perhaps we should try to use that notation when appropriate. */
1703 val_print_array_elements (struct type
*type
,
1704 const gdb_byte
*valaddr
, int embedded_offset
,
1705 CORE_ADDR address
, struct ui_file
*stream
,
1707 const struct value
*val
,
1708 const struct value_print_options
*options
,
1711 unsigned int things_printed
= 0;
1713 struct type
*elttype
, *index_type
, *base_index_type
;
1715 /* Position of the array element we are examining to see
1716 whether it is repeated. */
1718 /* Number of repetitions we have detected so far. */
1720 LONGEST low_bound
, high_bound
;
1721 LONGEST low_pos
, high_pos
;
1723 elttype
= TYPE_TARGET_TYPE (type
);
1724 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1725 index_type
= TYPE_INDEX_TYPE (type
);
1727 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1729 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
1730 base_index_type
= TYPE_TARGET_TYPE (index_type
);
1732 base_index_type
= index_type
;
1734 /* Non-contiguous enumerations types can by used as index types
1735 in some languages (e.g. Ada). In this case, the array length
1736 shall be computed from the positions of the first and last
1737 literal in the enumeration type, and not from the values
1738 of these literals. */
1739 if (!discrete_position (base_index_type
, low_bound
, &low_pos
)
1740 || !discrete_position (base_index_type
, high_bound
, &high_pos
))
1742 warning (_("unable to get positions in array, use bounds instead"));
1743 low_pos
= low_bound
;
1744 high_pos
= high_bound
;
1747 /* The array length should normally be HIGH_POS - LOW_POS + 1.
1748 But we have to be a little extra careful, because some languages
1749 such as Ada allow LOW_POS to be greater than HIGH_POS for
1750 empty arrays. In that situation, the array length is just zero,
1752 if (low_pos
> high_pos
)
1755 len
= high_pos
- low_pos
+ 1;
1759 warning (_("unable to get bounds of array, assuming null array"));
1764 annotate_array_section_begin (i
, elttype
);
1766 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1770 if (options
->prettyformat_arrays
)
1772 fprintf_filtered (stream
, ",\n");
1773 print_spaces_filtered (2 + 2 * recurse
, stream
);
1777 fprintf_filtered (stream
, ", ");
1780 wrap_here (n_spaces (2 + 2 * recurse
));
1781 maybe_print_array_index (index_type
, i
+ low_bound
,
1786 /* Only check for reps if repeat_count_threshold is not set to
1787 UINT_MAX (unlimited). */
1788 if (options
->repeat_count_threshold
< UINT_MAX
)
1791 && value_contents_eq (val
,
1792 embedded_offset
+ i
* eltlen
,
1803 if (reps
> options
->repeat_count_threshold
)
1805 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1806 address
, stream
, recurse
+ 1, val
, options
,
1808 annotate_elt_rep (reps
);
1809 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1810 annotate_elt_rep_end ();
1813 things_printed
+= options
->repeat_count_threshold
;
1817 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1819 stream
, recurse
+ 1, val
, options
, current_language
);
1824 annotate_array_section_end ();
1827 fprintf_filtered (stream
, "...");
1831 /* Read LEN bytes of target memory at address MEMADDR, placing the
1832 results in GDB's memory at MYADDR. Returns a count of the bytes
1833 actually read, and optionally a target_xfer_status value in the
1834 location pointed to by ERRPTR if ERRPTR is non-null. */
1836 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1837 function be eliminated. */
1840 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
1841 int len
, int *errptr
)
1843 int nread
; /* Number of bytes actually read. */
1844 int errcode
; /* Error from last read. */
1846 /* First try a complete read. */
1847 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1855 /* Loop, reading one byte at a time until we get as much as we can. */
1856 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1858 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1860 /* If an error, the last read was unsuccessful, so adjust count. */
1873 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1874 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1875 allocated buffer containing the string, which the caller is responsible to
1876 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1877 success, or a target_xfer_status on failure.
1879 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
1880 (including eventual NULs in the middle or end of the string).
1882 If LEN is -1, stops at the first null character (not necessarily
1883 the first null byte) up to a maximum of FETCHLIMIT characters. Set
1884 FETCHLIMIT to UINT_MAX to read as many characters as possible from
1887 Unless an exception is thrown, BUFFER will always be allocated, even on
1888 failure. In this case, some characters might have been read before the
1889 failure happened. Check BYTES_READ to recognize this situation.
1891 Note: There was a FIXME asking to make this code use target_read_string,
1892 but this function is more general (can read past null characters, up to
1893 given LEN). Besides, it is used much more often than target_read_string
1894 so it is more tested. Perhaps callers of target_read_string should use
1895 this function instead? */
1898 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
1899 enum bfd_endian byte_order
, gdb_byte
**buffer
, int *bytes_read
)
1901 int errcode
; /* Errno returned from bad reads. */
1902 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1903 gdb_byte
*bufptr
; /* Pointer to next available byte in
1905 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1907 /* Loop until we either have all the characters, or we encounter
1908 some error, such as bumping into the end of the address space. */
1912 old_chain
= make_cleanup (free_current_contents
, buffer
);
1916 /* We want fetchlimit chars, so we might as well read them all in
1918 unsigned int fetchlen
= min (len
, fetchlimit
);
1920 *buffer
= (gdb_byte
*) xmalloc (fetchlen
* width
);
1923 nfetch
= partial_memory_read (addr
, bufptr
, fetchlen
* width
, &errcode
)
1925 addr
+= nfetch
* width
;
1926 bufptr
+= nfetch
* width
;
1930 unsigned long bufsize
= 0;
1931 unsigned int chunksize
; /* Size of each fetch, in chars. */
1932 int found_nul
; /* Non-zero if we found the nul char. */
1933 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1936 /* We are looking for a NUL terminator to end the fetching, so we
1937 might as well read in blocks that are large enough to be efficient,
1938 but not so large as to be slow if fetchlimit happens to be large.
1939 So we choose the minimum of 8 and fetchlimit. We used to use 200
1940 instead of 8 but 200 is way too big for remote debugging over a
1942 chunksize
= min (8, fetchlimit
);
1947 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1949 if (*buffer
== NULL
)
1950 *buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1952 *buffer
= (gdb_byte
*) xrealloc (*buffer
,
1953 (nfetch
+ bufsize
) * width
);
1955 bufptr
= *buffer
+ bufsize
* width
;
1958 /* Read as much as we can. */
1959 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1962 /* Scan this chunk for the null character that terminates the string
1963 to print. If found, we don't need to fetch any more. Note
1964 that bufptr is explicitly left pointing at the next character
1965 after the null character, or at the next character after the end
1968 limit
= bufptr
+ nfetch
* width
;
1969 while (bufptr
< limit
)
1973 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
1978 /* We don't care about any error which happened after
1979 the NUL terminator. */
1986 while (errcode
== 0 /* no error */
1987 && bufptr
- *buffer
< fetchlimit
* width
/* no overrun */
1988 && !found_nul
); /* haven't found NUL yet */
1991 { /* Length of string is really 0! */
1992 /* We always allocate *buffer. */
1993 *buffer
= bufptr
= xmalloc (1);
1997 /* bufptr and addr now point immediately beyond the last byte which we
1998 consider part of the string (including a '\0' which ends the string). */
1999 *bytes_read
= bufptr
- *buffer
;
2003 discard_cleanups (old_chain
);
2008 /* Return true if print_wchar can display W without resorting to a
2009 numeric escape, false otherwise. */
2012 wchar_printable (gdb_wchar_t w
)
2014 return (gdb_iswprint (w
)
2015 || w
== LCST ('\a') || w
== LCST ('\b')
2016 || w
== LCST ('\f') || w
== LCST ('\n')
2017 || w
== LCST ('\r') || w
== LCST ('\t')
2018 || w
== LCST ('\v'));
2021 /* A helper function that converts the contents of STRING to wide
2022 characters and then appends them to OUTPUT. */
2025 append_string_as_wide (const char *string
,
2026 struct obstack
*output
)
2028 for (; *string
; ++string
)
2030 gdb_wchar_t w
= gdb_btowc (*string
);
2031 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
2035 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
2036 original (target) bytes representing the character, ORIG_LEN is the
2037 number of valid bytes. WIDTH is the number of bytes in a base
2038 characters of the type. OUTPUT is an obstack to which wide
2039 characters are emitted. QUOTER is a (narrow) character indicating
2040 the style of quotes surrounding the character to be printed.
2041 NEED_ESCAPE is an in/out flag which is used to track numeric
2042 escapes across calls. */
2045 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
2046 int orig_len
, int width
,
2047 enum bfd_endian byte_order
,
2048 struct obstack
*output
,
2049 int quoter
, int *need_escapep
)
2051 int need_escape
= *need_escapep
;
2055 /* iswprint implementation on Windows returns 1 for tab character.
2056 In order to avoid different printout on this host, we explicitly
2057 use wchar_printable function. */
2061 obstack_grow_wstr (output
, LCST ("\\a"));
2064 obstack_grow_wstr (output
, LCST ("\\b"));
2067 obstack_grow_wstr (output
, LCST ("\\f"));
2070 obstack_grow_wstr (output
, LCST ("\\n"));
2073 obstack_grow_wstr (output
, LCST ("\\r"));
2076 obstack_grow_wstr (output
, LCST ("\\t"));
2079 obstack_grow_wstr (output
, LCST ("\\v"));
2083 if (wchar_printable (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
2085 && w
!= LCST ('9'))))
2087 gdb_wchar_t wchar
= w
;
2089 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
2090 obstack_grow_wstr (output
, LCST ("\\"));
2091 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
2097 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
2102 value
= extract_unsigned_integer (&orig
[i
], width
,
2104 /* If the value fits in 3 octal digits, print it that
2105 way. Otherwise, print it as a hex escape. */
2107 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
2108 (int) (value
& 0777));
2110 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
2111 append_string_as_wide (octal
, output
);
2113 /* If we somehow have extra bytes, print them now. */
2114 while (i
< orig_len
)
2118 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
2119 append_string_as_wide (octal
, output
);
2130 /* Print the character C on STREAM as part of the contents of a
2131 literal string whose delimiter is QUOTER. ENCODING names the
2135 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2136 int quoter
, const char *encoding
)
2138 enum bfd_endian byte_order
2139 = gdbarch_byte_order (get_type_arch (type
));
2140 struct obstack wchar_buf
, output
;
2141 struct cleanup
*cleanups
;
2143 struct wchar_iterator
*iter
;
2144 int need_escape
= 0;
2146 buf
= alloca (TYPE_LENGTH (type
));
2147 pack_long (buf
, type
, c
);
2149 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
),
2150 encoding
, TYPE_LENGTH (type
));
2151 cleanups
= make_cleanup_wchar_iterator (iter
);
2153 /* This holds the printable form of the wchar_t data. */
2154 obstack_init (&wchar_buf
);
2155 make_cleanup_obstack_free (&wchar_buf
);
2161 const gdb_byte
*buf
;
2163 int print_escape
= 1;
2164 enum wchar_iterate_result result
;
2166 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
2171 /* If all characters are printable, print them. Otherwise,
2172 we're going to have to print an escape sequence. We
2173 check all characters because we want to print the target
2174 bytes in the escape sequence, and we don't know character
2175 boundaries there. */
2179 for (i
= 0; i
< num_chars
; ++i
)
2180 if (!wchar_printable (chars
[i
]))
2188 for (i
= 0; i
< num_chars
; ++i
)
2189 print_wchar (chars
[i
], buf
, buflen
,
2190 TYPE_LENGTH (type
), byte_order
,
2191 &wchar_buf
, quoter
, &need_escape
);
2195 /* This handles the NUM_CHARS == 0 case as well. */
2197 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2198 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2201 /* The output in the host encoding. */
2202 obstack_init (&output
);
2203 make_cleanup_obstack_free (&output
);
2205 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2206 (gdb_byte
*) obstack_base (&wchar_buf
),
2207 obstack_object_size (&wchar_buf
),
2208 sizeof (gdb_wchar_t
), &output
, translit_char
);
2209 obstack_1grow (&output
, '\0');
2211 fputs_filtered (obstack_base (&output
), stream
);
2213 do_cleanups (cleanups
);
2216 /* Return the repeat count of the next character/byte in ITER,
2217 storing the result in VEC. */
2220 count_next_character (struct wchar_iterator
*iter
,
2221 VEC (converted_character_d
) **vec
)
2223 struct converted_character
*current
;
2225 if (VEC_empty (converted_character_d
, *vec
))
2227 struct converted_character tmp
;
2231 = wchar_iterate (iter
, &tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2232 if (tmp
.num_chars
> 0)
2234 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2235 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2237 VEC_safe_push (converted_character_d
, *vec
, &tmp
);
2240 current
= VEC_last (converted_character_d
, *vec
);
2242 /* Count repeated characters or bytes. */
2243 current
->repeat_count
= 1;
2244 if (current
->num_chars
== -1)
2252 struct converted_character d
;
2259 /* Get the next character. */
2261 = wchar_iterate (iter
, &d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2263 /* If a character was successfully converted, save the character
2264 into the converted character. */
2265 if (d
.num_chars
> 0)
2267 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2268 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2271 /* Determine if the current character is the same as this
2273 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2275 /* There are two cases to consider:
2277 1) Equality of converted character (num_chars > 0)
2278 2) Equality of non-converted character (num_chars == 0) */
2279 if ((current
->num_chars
> 0
2280 && memcmp (current
->chars
, d
.chars
,
2281 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2282 || (current
->num_chars
== 0
2283 && current
->buflen
== d
.buflen
2284 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2285 ++current
->repeat_count
;
2293 /* Push this next converted character onto the result vector. */
2294 repeat
= current
->repeat_count
;
2295 VEC_safe_push (converted_character_d
, *vec
, &d
);
2300 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2301 character to use with string output. WIDTH is the size of the output
2302 character type. BYTE_ORDER is the the target byte order. OPTIONS
2303 is the user's print options. */
2306 print_converted_chars_to_obstack (struct obstack
*obstack
,
2307 VEC (converted_character_d
) *chars
,
2308 int quote_char
, int width
,
2309 enum bfd_endian byte_order
,
2310 const struct value_print_options
*options
)
2313 struct converted_character
*elem
;
2314 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2315 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2316 int need_escape
= 0;
2318 /* Set the start state. */
2320 last
= state
= START
;
2328 /* Nothing to do. */
2335 /* We are outputting a single character
2336 (< options->repeat_count_threshold). */
2340 /* We were outputting some other type of content, so we
2341 must output and a comma and a quote. */
2343 obstack_grow_wstr (obstack
, LCST (", "));
2344 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2346 /* Output the character. */
2347 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2349 if (elem
->result
== wchar_iterate_ok
)
2350 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2351 byte_order
, obstack
, quote_char
, &need_escape
);
2353 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2354 byte_order
, obstack
, quote_char
, &need_escape
);
2364 /* We are outputting a character with a repeat count
2365 greater than options->repeat_count_threshold. */
2369 /* We were outputting a single string. Terminate the
2371 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2374 obstack_grow_wstr (obstack
, LCST (", "));
2376 /* Output the character and repeat string. */
2377 obstack_grow_wstr (obstack
, LCST ("'"));
2378 if (elem
->result
== wchar_iterate_ok
)
2379 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2380 byte_order
, obstack
, quote_char
, &need_escape
);
2382 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2383 byte_order
, obstack
, quote_char
, &need_escape
);
2384 obstack_grow_wstr (obstack
, LCST ("'"));
2385 s
= xstrprintf (_(" <repeats %u times>"), elem
->repeat_count
);
2386 for (j
= 0; s
[j
]; ++j
)
2388 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2389 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2396 /* We are outputting an incomplete sequence. */
2399 /* If we were outputting a string of SINGLE characters,
2400 terminate the quote. */
2401 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2404 obstack_grow_wstr (obstack
, LCST (", "));
2406 /* Output the incomplete sequence string. */
2407 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
2408 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
2409 obstack
, 0, &need_escape
);
2410 obstack_grow_wstr (obstack
, LCST (">"));
2412 /* We do not attempt to outupt anything after this. */
2417 /* All done. If we were outputting a string of SINGLE
2418 characters, the string must be terminated. Otherwise,
2419 REPEAT and INCOMPLETE are always left properly terminated. */
2421 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2426 /* Get the next element and state. */
2428 if (state
!= FINISH
)
2430 elem
= VEC_index (converted_character_d
, chars
, idx
++);
2431 switch (elem
->result
)
2433 case wchar_iterate_ok
:
2434 case wchar_iterate_invalid
:
2435 if (elem
->repeat_count
> options
->repeat_count_threshold
)
2441 case wchar_iterate_incomplete
:
2445 case wchar_iterate_eof
:
2453 /* Print the character string STRING, printing at most LENGTH
2454 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2455 the type of each character. OPTIONS holds the printing options;
2456 printing stops early if the number hits print_max; repeat counts
2457 are printed as appropriate. Print ellipses at the end if we had to
2458 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2459 QUOTE_CHAR is the character to print at each end of the string. If
2460 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2464 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2465 const gdb_byte
*string
, unsigned int length
,
2466 const char *encoding
, int force_ellipses
,
2467 int quote_char
, int c_style_terminator
,
2468 const struct value_print_options
*options
)
2470 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2472 int width
= TYPE_LENGTH (type
);
2473 struct obstack wchar_buf
, output
;
2474 struct cleanup
*cleanup
;
2475 struct wchar_iterator
*iter
;
2477 struct converted_character
*last
;
2478 VEC (converted_character_d
) *converted_chars
;
2482 unsigned long current_char
= 1;
2484 for (i
= 0; current_char
; ++i
)
2487 current_char
= extract_unsigned_integer (string
+ i
* width
,
2493 /* If the string was not truncated due to `set print elements', and
2494 the last byte of it is a null, we don't print that, in
2495 traditional C style. */
2496 if (c_style_terminator
2499 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2500 width
, byte_order
) == 0))
2505 fputs_filtered ("\"\"", stream
);
2509 /* Arrange to iterate over the characters, in wchar_t form. */
2510 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
2511 cleanup
= make_cleanup_wchar_iterator (iter
);
2512 converted_chars
= NULL
;
2513 make_cleanup (VEC_cleanup (converted_character_d
), &converted_chars
);
2515 /* Convert characters until the string is over or the maximum
2516 number of printed characters has been reached. */
2518 while (i
< options
->print_max
)
2524 /* Grab the next character and repeat count. */
2525 r
= count_next_character (iter
, &converted_chars
);
2527 /* If less than zero, the end of the input string was reached. */
2531 /* Otherwise, add the count to the total print count and get
2532 the next character. */
2536 /* Get the last element and determine if the entire string was
2538 last
= VEC_last (converted_character_d
, converted_chars
);
2539 finished
= (last
->result
== wchar_iterate_eof
);
2541 /* Ensure that CONVERTED_CHARS is terminated. */
2542 last
->result
= wchar_iterate_eof
;
2544 /* WCHAR_BUF is the obstack we use to represent the string in
2546 obstack_init (&wchar_buf
);
2547 make_cleanup_obstack_free (&wchar_buf
);
2549 /* Print the output string to the obstack. */
2550 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
2551 width
, byte_order
, options
);
2553 if (force_ellipses
|| !finished
)
2554 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2556 /* OUTPUT is where we collect `char's for printing. */
2557 obstack_init (&output
);
2558 make_cleanup_obstack_free (&output
);
2560 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2561 (gdb_byte
*) obstack_base (&wchar_buf
),
2562 obstack_object_size (&wchar_buf
),
2563 sizeof (gdb_wchar_t
), &output
, translit_char
);
2564 obstack_1grow (&output
, '\0');
2566 fputs_filtered (obstack_base (&output
), stream
);
2568 do_cleanups (cleanup
);
2571 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2572 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2573 stops at the first null byte, otherwise printing proceeds (including null
2574 bytes) until either print_max or LEN characters have been printed,
2575 whichever is smaller. ENCODING is the name of the string's
2576 encoding. It can be NULL, in which case the target encoding is
2580 val_print_string (struct type
*elttype
, const char *encoding
,
2581 CORE_ADDR addr
, int len
,
2582 struct ui_file
*stream
,
2583 const struct value_print_options
*options
)
2585 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2586 int errcode
; /* Errno returned from bad reads. */
2587 int found_nul
; /* Non-zero if we found the nul char. */
2588 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2590 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
2591 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
2592 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2593 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2594 int width
= TYPE_LENGTH (elttype
);
2596 /* First we need to figure out the limit on the number of characters we are
2597 going to attempt to fetch and print. This is actually pretty simple. If
2598 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2599 LEN is -1, then the limit is print_max. This is true regardless of
2600 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2601 because finding the null byte (or available memory) is what actually
2602 limits the fetch. */
2604 fetchlimit
= (len
== -1 ? options
->print_max
: min (len
,
2605 options
->print_max
));
2607 errcode
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2608 &buffer
, &bytes_read
);
2609 old_chain
= make_cleanup (xfree
, buffer
);
2613 /* We now have either successfully filled the buffer to fetchlimit,
2614 or terminated early due to an error or finding a null char when
2617 /* Determine found_nul by looking at the last character read. */
2619 if (bytes_read
>= width
)
2620 found_nul
= extract_unsigned_integer (buffer
+ bytes_read
- width
, width
,
2622 if (len
== -1 && !found_nul
)
2626 /* We didn't find a NUL terminator we were looking for. Attempt
2627 to peek at the next character. If not successful, or it is not
2628 a null byte, then force ellipsis to be printed. */
2630 peekbuf
= (gdb_byte
*) alloca (width
);
2632 if (target_read_memory (addr
, peekbuf
, width
) == 0
2633 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2636 else if ((len
>= 0 && errcode
!= 0) || (len
> bytes_read
/ width
))
2638 /* Getting an error when we have a requested length, or fetching less
2639 than the number of characters actually requested, always make us
2644 /* If we get an error before fetching anything, don't print a string.
2645 But if we fetch something and then get an error, print the string
2646 and then the error message. */
2647 if (errcode
== 0 || bytes_read
> 0)
2649 LA_PRINT_STRING (stream
, elttype
, buffer
, bytes_read
/ width
,
2650 encoding
, force_ellipsis
, options
);
2657 str
= memory_error_message (errcode
, gdbarch
, addr
);
2658 make_cleanup (xfree
, str
);
2660 fprintf_filtered (stream
, "<error: ");
2661 fputs_filtered (str
, stream
);
2662 fprintf_filtered (stream
, ">");
2666 do_cleanups (old_chain
);
2668 return (bytes_read
/ width
);
2672 /* The 'set input-radix' command writes to this auxiliary variable.
2673 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2674 it is left unchanged. */
2676 static unsigned input_radix_1
= 10;
2678 /* Validate an input or output radix setting, and make sure the user
2679 knows what they really did here. Radix setting is confusing, e.g.
2680 setting the input radix to "10" never changes it! */
2683 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2685 set_input_radix_1 (from_tty
, input_radix_1
);
2689 set_input_radix_1 (int from_tty
, unsigned radix
)
2691 /* We don't currently disallow any input radix except 0 or 1, which don't
2692 make any mathematical sense. In theory, we can deal with any input
2693 radix greater than 1, even if we don't have unique digits for every
2694 value from 0 to radix-1, but in practice we lose on large radix values.
2695 We should either fix the lossage or restrict the radix range more.
2700 input_radix_1
= input_radix
;
2701 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2704 input_radix_1
= input_radix
= radix
;
2707 printf_filtered (_("Input radix now set to "
2708 "decimal %u, hex %x, octal %o.\n"),
2709 radix
, radix
, radix
);
2713 /* The 'set output-radix' command writes to this auxiliary variable.
2714 If the requested radix is valid, OUTPUT_RADIX is updated,
2715 otherwise, it is left unchanged. */
2717 static unsigned output_radix_1
= 10;
2720 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2722 set_output_radix_1 (from_tty
, output_radix_1
);
2726 set_output_radix_1 (int from_tty
, unsigned radix
)
2728 /* Validate the radix and disallow ones that we aren't prepared to
2729 handle correctly, leaving the radix unchanged. */
2733 user_print_options
.output_format
= 'x'; /* hex */
2736 user_print_options
.output_format
= 0; /* decimal */
2739 user_print_options
.output_format
= 'o'; /* octal */
2742 output_radix_1
= output_radix
;
2743 error (_("Unsupported output radix ``decimal %u''; "
2744 "output radix unchanged."),
2747 output_radix_1
= output_radix
= radix
;
2750 printf_filtered (_("Output radix now set to "
2751 "decimal %u, hex %x, octal %o.\n"),
2752 radix
, radix
, radix
);
2756 /* Set both the input and output radix at once. Try to set the output radix
2757 first, since it has the most restrictive range. An radix that is valid as
2758 an output radix is also valid as an input radix.
2760 It may be useful to have an unusual input radix. If the user wishes to
2761 set an input radix that is not valid as an output radix, he needs to use
2762 the 'set input-radix' command. */
2765 set_radix (char *arg
, int from_tty
)
2769 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2770 set_output_radix_1 (0, radix
);
2771 set_input_radix_1 (0, radix
);
2774 printf_filtered (_("Input and output radices now set to "
2775 "decimal %u, hex %x, octal %o.\n"),
2776 radix
, radix
, radix
);
2780 /* Show both the input and output radices. */
2783 show_radix (char *arg
, int from_tty
)
2787 if (input_radix
== output_radix
)
2789 printf_filtered (_("Input and output radices set to "
2790 "decimal %u, hex %x, octal %o.\n"),
2791 input_radix
, input_radix
, input_radix
);
2795 printf_filtered (_("Input radix set to decimal "
2796 "%u, hex %x, octal %o.\n"),
2797 input_radix
, input_radix
, input_radix
);
2798 printf_filtered (_("Output radix set to decimal "
2799 "%u, hex %x, octal %o.\n"),
2800 output_radix
, output_radix
, output_radix
);
2807 set_print (char *arg
, int from_tty
)
2810 "\"set print\" must be followed by the name of a print subcommand.\n");
2811 help_list (setprintlist
, "set print ", all_commands
, gdb_stdout
);
2815 show_print (char *args
, int from_tty
)
2817 cmd_show_list (showprintlist
, from_tty
, "");
2821 set_print_raw (char *arg
, int from_tty
)
2824 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
2825 help_list (setprintrawlist
, "set print raw ", all_commands
, gdb_stdout
);
2829 show_print_raw (char *args
, int from_tty
)
2831 cmd_show_list (showprintrawlist
, from_tty
, "");
2836 _initialize_valprint (void)
2838 add_prefix_cmd ("print", no_class
, set_print
,
2839 _("Generic command for setting how things print."),
2840 &setprintlist
, "set print ", 0, &setlist
);
2841 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
2842 /* Prefer set print to set prompt. */
2843 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
2845 add_prefix_cmd ("print", no_class
, show_print
,
2846 _("Generic command for showing print settings."),
2847 &showprintlist
, "show print ", 0, &showlist
);
2848 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
2849 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
2851 add_prefix_cmd ("raw", no_class
, set_print_raw
,
2853 Generic command for setting what things to print in \"raw\" mode."),
2854 &setprintrawlist
, "set print raw ", 0, &setprintlist
);
2855 add_prefix_cmd ("raw", no_class
, show_print_raw
,
2856 _("Generic command for showing \"print raw\" settings."),
2857 &showprintrawlist
, "show print raw ", 0, &showprintlist
);
2859 add_setshow_uinteger_cmd ("elements", no_class
,
2860 &user_print_options
.print_max
, _("\
2861 Set limit on string chars or array elements to print."), _("\
2862 Show limit on string chars or array elements to print."), _("\
2863 \"set print elements unlimited\" causes there to be no limit."),
2866 &setprintlist
, &showprintlist
);
2868 add_setshow_boolean_cmd ("null-stop", no_class
,
2869 &user_print_options
.stop_print_at_null
, _("\
2870 Set printing of char arrays to stop at first null char."), _("\
2871 Show printing of char arrays to stop at first null char."), NULL
,
2873 show_stop_print_at_null
,
2874 &setprintlist
, &showprintlist
);
2876 add_setshow_uinteger_cmd ("repeats", no_class
,
2877 &user_print_options
.repeat_count_threshold
, _("\
2878 Set threshold for repeated print elements."), _("\
2879 Show threshold for repeated print elements."), _("\
2880 \"set print repeats unlimited\" causes all elements to be individually printed."),
2882 show_repeat_count_threshold
,
2883 &setprintlist
, &showprintlist
);
2885 add_setshow_boolean_cmd ("pretty", class_support
,
2886 &user_print_options
.prettyformat_structs
, _("\
2887 Set pretty formatting of structures."), _("\
2888 Show pretty formatting of structures."), NULL
,
2890 show_prettyformat_structs
,
2891 &setprintlist
, &showprintlist
);
2893 add_setshow_boolean_cmd ("union", class_support
,
2894 &user_print_options
.unionprint
, _("\
2895 Set printing of unions interior to structures."), _("\
2896 Show printing of unions interior to structures."), NULL
,
2899 &setprintlist
, &showprintlist
);
2901 add_setshow_boolean_cmd ("array", class_support
,
2902 &user_print_options
.prettyformat_arrays
, _("\
2903 Set pretty formatting of arrays."), _("\
2904 Show pretty formatting of arrays."), NULL
,
2906 show_prettyformat_arrays
,
2907 &setprintlist
, &showprintlist
);
2909 add_setshow_boolean_cmd ("address", class_support
,
2910 &user_print_options
.addressprint
, _("\
2911 Set printing of addresses."), _("\
2912 Show printing of addresses."), NULL
,
2915 &setprintlist
, &showprintlist
);
2917 add_setshow_boolean_cmd ("symbol", class_support
,
2918 &user_print_options
.symbol_print
, _("\
2919 Set printing of symbol names when printing pointers."), _("\
2920 Show printing of symbol names when printing pointers."),
2923 &setprintlist
, &showprintlist
);
2925 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
2927 Set default input radix for entering numbers."), _("\
2928 Show default input radix for entering numbers."), NULL
,
2931 &setlist
, &showlist
);
2933 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
2935 Set default output radix for printing of values."), _("\
2936 Show default output radix for printing of values."), NULL
,
2939 &setlist
, &showlist
);
2941 /* The "set radix" and "show radix" commands are special in that
2942 they are like normal set and show commands but allow two normally
2943 independent variables to be either set or shown with a single
2944 command. So the usual deprecated_add_set_cmd() and [deleted]
2945 add_show_from_set() commands aren't really appropriate. */
2946 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2947 longer true - show can display anything. */
2948 add_cmd ("radix", class_support
, set_radix
, _("\
2949 Set default input and output number radices.\n\
2950 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2951 Without an argument, sets both radices back to the default value of 10."),
2953 add_cmd ("radix", class_support
, show_radix
, _("\
2954 Show the default input and output number radices.\n\
2955 Use 'show input-radix' or 'show output-radix' to independently show each."),
2958 add_setshow_boolean_cmd ("array-indexes", class_support
,
2959 &user_print_options
.print_array_indexes
, _("\
2960 Set printing of array indexes."), _("\
2961 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
2962 &setprintlist
, &showprintlist
);