1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-2012 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/>. */
21 #include "gdb_string.h"
31 #include "floatformat.h"
33 #include "exceptions.h"
35 #include "python/python.h"
37 #include "gdb_obstack.h"
43 /* Prototypes for local functions */
45 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
46 int len, int *errnoptr);
48 static void show_print (char *, int);
50 static void set_print (char *, int);
52 static void set_radix (char *, int);
54 static void show_radix (char *, int);
56 static void set_input_radix (char *, int, struct cmd_list_element *);
58 static void set_input_radix_1 (int, unsigned);
60 static void set_output_radix (char *, int, struct cmd_list_element *);
62 static void set_output_radix_1 (int, unsigned);
64 void _initialize_valprint (void);
66 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
68 struct value_print_options user_print_options =
70 Val_pretty_default, /* pretty */
71 0, /* prettyprint_arrays */
72 0, /* prettyprint_structs */
77 PRINT_MAX_DEFAULT, /* print_max */
78 10, /* repeat_count_threshold */
79 0, /* output_format */
81 0, /* stop_print_at_null */
83 0, /* print_array_indexes */
85 1, /* static_field_print */
86 1, /* pascal_static_field_print */
91 /* Initialize *OPTS to be a copy of the user print options. */
93 get_user_print_options (struct value_print_options *opts)
95 *opts = user_print_options;
98 /* Initialize *OPTS to be a copy of the user print options, but with
99 pretty-printing disabled. */
101 get_raw_print_options (struct value_print_options *opts)
103 *opts = user_print_options;
104 opts->pretty = Val_no_prettyprint;
107 /* Initialize *OPTS to be a copy of the user print options, but using
108 FORMAT as the formatting option. */
110 get_formatted_print_options (struct value_print_options *opts,
113 *opts = user_print_options;
114 opts->format = format;
118 show_print_max (struct ui_file *file, int from_tty,
119 struct cmd_list_element *c, const char *value)
121 fprintf_filtered (file,
122 _("Limit on string chars or array "
123 "elements to print is %s.\n"),
128 /* Default input and output radixes, and output format letter. */
130 unsigned input_radix = 10;
132 show_input_radix (struct ui_file *file, int from_tty,
133 struct cmd_list_element *c, const char *value)
135 fprintf_filtered (file,
136 _("Default input radix for entering numbers is %s.\n"),
140 unsigned output_radix = 10;
142 show_output_radix (struct ui_file *file, int from_tty,
143 struct cmd_list_element *c, const char *value)
145 fprintf_filtered (file,
146 _("Default output radix for printing of values is %s.\n"),
150 /* By default we print arrays without printing the index of each element in
151 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
154 show_print_array_indexes (struct ui_file *file, int from_tty,
155 struct cmd_list_element *c, const char *value)
157 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
160 /* Print repeat counts if there are more than this many repetitions of an
161 element in an array. Referenced by the low level language dependent
165 show_repeat_count_threshold (struct ui_file *file, int from_tty,
166 struct cmd_list_element *c, const char *value)
168 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
172 /* If nonzero, stops printing of char arrays at first null. */
175 show_stop_print_at_null (struct ui_file *file, int from_tty,
176 struct cmd_list_element *c, const char *value)
178 fprintf_filtered (file,
179 _("Printing of char arrays to stop "
180 "at first null char is %s.\n"),
184 /* Controls pretty printing of structures. */
187 show_prettyprint_structs (struct ui_file *file, int from_tty,
188 struct cmd_list_element *c, const char *value)
190 fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
193 /* Controls pretty printing of arrays. */
196 show_prettyprint_arrays (struct ui_file *file, int from_tty,
197 struct cmd_list_element *c, const char *value)
199 fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
202 /* If nonzero, causes unions inside structures or other unions to be
206 show_unionprint (struct ui_file *file, int from_tty,
207 struct cmd_list_element *c, const char *value)
209 fprintf_filtered (file,
210 _("Printing of unions interior to structures is %s.\n"),
214 /* If nonzero, causes machine addresses to be printed in certain contexts. */
217 show_addressprint (struct ui_file *file, int from_tty,
218 struct cmd_list_element *c, const char *value)
220 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
224 /* A helper function for val_print. When printing in "summary" mode,
225 we want to print scalar arguments, but not aggregate arguments.
226 This function distinguishes between the two. */
229 scalar_type_p (struct type *type)
231 CHECK_TYPEDEF (type);
232 while (TYPE_CODE (type) == TYPE_CODE_REF)
234 type = TYPE_TARGET_TYPE (type);
235 CHECK_TYPEDEF (type);
237 switch (TYPE_CODE (type))
239 case TYPE_CODE_ARRAY:
240 case TYPE_CODE_STRUCT:
241 case TYPE_CODE_UNION:
243 case TYPE_CODE_STRING:
244 case TYPE_CODE_BITSTRING:
251 /* Helper function to check the validity of some bits of a value.
253 If TYPE represents some aggregate type (e.g., a structure), return 1.
255 Otherwise, any of the bytes starting at OFFSET and extending for
256 TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
257 return 0. The checking is done using FUNCS.
259 Otherwise, return 1. */
262 valprint_check_validity (struct ui_file *stream,
265 const struct value *val)
267 CHECK_TYPEDEF (type);
269 if (TYPE_CODE (type) != TYPE_CODE_UNION
270 && TYPE_CODE (type) != TYPE_CODE_STRUCT
271 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
273 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
274 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
276 val_print_optimized_out (stream);
280 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
281 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
283 fputs_filtered (_("<synthetic pointer>"), stream);
287 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
289 val_print_unavailable (stream);
298 val_print_optimized_out (struct ui_file *stream)
300 fprintf_filtered (stream, _("<optimized out>"));
304 val_print_unavailable (struct ui_file *stream)
306 fprintf_filtered (stream, _("<unavailable>"));
310 val_print_invalid_address (struct ui_file *stream)
312 fprintf_filtered (stream, _("<invalid address>"));
315 /* A generic val_print that is suitable for use by language
316 implementations of the la_val_print method. This function can
317 handle most type codes, though not all, notably exception
318 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
321 Most arguments are as to val_print.
323 The additional DECORATIONS argument can be used to customize the
324 output in some small, language-specific ways. */
327 generic_val_print (struct type *type, const gdb_byte *valaddr,
328 int embedded_offset, CORE_ADDR address,
329 struct ui_file *stream, int recurse,
330 const struct value *original_value,
331 const struct value_print_options *options,
332 const struct generic_val_print_decorations *decorations)
334 struct gdbarch *gdbarch = get_type_arch (type);
335 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
336 unsigned int i = 0; /* Number of characters printed. */
338 struct type *elttype, *unresolved_elttype;
339 struct type *unresolved_type = type;
344 CHECK_TYPEDEF (type);
345 switch (TYPE_CODE (type))
347 case TYPE_CODE_ARRAY:
348 unresolved_elttype = TYPE_TARGET_TYPE (type);
349 elttype = check_typedef (unresolved_elttype);
350 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
352 LONGEST low_bound, high_bound;
354 if (!get_array_bounds (type, &low_bound, &high_bound))
355 error (_("Could not determine the array high bound"));
357 if (options->prettyprint_arrays)
359 print_spaces_filtered (2 + 2 * recurse, stream);
362 fprintf_filtered (stream, "{");
363 val_print_array_elements (type, valaddr, embedded_offset,
365 recurse, original_value, options, 0);
366 fprintf_filtered (stream, "}");
369 /* Array of unspecified length: treat like pointer to first
371 addr = address + embedded_offset;
372 goto print_unpacked_pointer;
374 case TYPE_CODE_MEMBERPTR:
375 val_print_scalar_formatted (type, valaddr, embedded_offset,
376 original_value, options, 0, stream);
380 if (options->format && options->format != 's')
382 val_print_scalar_formatted (type, valaddr, embedded_offset,
383 original_value, options, 0, stream);
386 unresolved_elttype = TYPE_TARGET_TYPE (type);
387 elttype = check_typedef (unresolved_elttype);
389 addr = unpack_pointer (type, valaddr + embedded_offset);
390 print_unpacked_pointer:
392 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
394 /* Try to print what function it points to. */
395 print_function_pointer_address (gdbarch, addr, stream,
396 options->addressprint);
400 if (options->addressprint)
401 fputs_filtered (paddress (gdbarch, addr), stream);
406 elttype = check_typedef (TYPE_TARGET_TYPE (type));
407 if (options->addressprint)
410 = extract_typed_address (valaddr + embedded_offset, type);
412 fprintf_filtered (stream, "@");
413 fputs_filtered (paddress (gdbarch, addr), stream);
414 if (options->deref_ref)
415 fputs_filtered (": ", stream);
417 /* De-reference the reference. */
418 if (options->deref_ref)
420 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
422 struct value *deref_val;
424 deref_val = coerce_ref_if_computed (original_value);
425 if (deref_val != NULL)
427 /* More complicated computed references are not supported. */
428 gdb_assert (embedded_offset == 0);
431 deref_val = value_at (TYPE_TARGET_TYPE (type),
432 unpack_pointer (type,
434 + embedded_offset)));
436 common_val_print (deref_val, stream, recurse, options,
440 fputs_filtered ("???", stream);
447 val_print_scalar_formatted (type, valaddr, embedded_offset,
448 original_value, options, 0, stream);
451 len = TYPE_NFIELDS (type);
452 val = unpack_long (type, valaddr + embedded_offset);
453 for (i = 0; i < len; i++)
456 if (val == TYPE_FIELD_BITPOS (type, i))
463 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
465 else if (TYPE_FLAG_ENUM (type))
469 /* We have a "flag" enum, so we try to decompose it into
470 pieces as appropriate. A flag enum has disjoint
471 constants by definition. */
472 fputs_filtered ("(", stream);
473 for (i = 0; i < len; ++i)
477 if ((val & TYPE_FIELD_BITPOS (type, i)) != 0)
480 fputs_filtered (" | ", stream);
483 val &= ~TYPE_FIELD_BITPOS (type, i);
484 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
488 if (first || val != 0)
491 fputs_filtered (" | ", stream);
492 fputs_filtered ("unknown: ", stream);
493 print_longest (stream, 'd', 0, val);
496 fputs_filtered (")", stream);
499 print_longest (stream, 'd', 0, val);
502 case TYPE_CODE_FLAGS:
504 val_print_scalar_formatted (type, valaddr, embedded_offset,
505 original_value, options, 0, stream);
507 val_print_type_code_flags (type, valaddr + embedded_offset,
512 case TYPE_CODE_METHOD:
515 val_print_scalar_formatted (type, valaddr, embedded_offset,
516 original_value, options, 0, stream);
519 /* FIXME, we should consider, at least for ANSI C language,
520 eliminating the distinction made between FUNCs and POINTERs
522 fprintf_filtered (stream, "{");
523 type_print (type, "", stream, -1);
524 fprintf_filtered (stream, "} ");
525 /* Try to print what function it points to, and its address. */
526 print_address_demangle (gdbarch, address, stream, demangle);
530 if (options->format || options->output_format)
532 struct value_print_options opts = *options;
533 opts.format = (options->format ? options->format
534 : options->output_format);
535 val_print_scalar_formatted (type, valaddr, embedded_offset,
536 original_value, &opts, 0, stream);
540 val = unpack_long (type, valaddr + embedded_offset);
542 fputs_filtered (decorations->false_name, stream);
544 fputs_filtered (decorations->true_name, stream);
546 print_longest (stream, 'd', 0, val);
550 case TYPE_CODE_RANGE:
551 /* FIXME: create_range_type does not set the unsigned bit in a
552 range type (I think it probably should copy it from the
553 target type), so we won't print values which are too large to
554 fit in a signed integer correctly. */
555 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
556 print with the target type, though, because the size of our
557 type and the target type might differ). */
562 if (options->format || options->output_format)
564 struct value_print_options opts = *options;
566 opts.format = (options->format ? options->format
567 : options->output_format);
568 val_print_scalar_formatted (type, valaddr, embedded_offset,
569 original_value, &opts, 0, stream);
572 val_print_type_code_int (type, valaddr + embedded_offset, stream);
576 if (options->format || options->output_format)
578 struct value_print_options opts = *options;
580 opts.format = (options->format ? options->format
581 : options->output_format);
582 val_print_scalar_formatted (type, valaddr, embedded_offset,
583 original_value, &opts, 0, stream);
587 val = unpack_long (type, valaddr + embedded_offset);
588 if (TYPE_UNSIGNED (type))
589 fprintf_filtered (stream, "%u", (unsigned int) val);
591 fprintf_filtered (stream, "%d", (int) val);
592 fputs_filtered (" ", stream);
593 LA_PRINT_CHAR (val, unresolved_type, stream);
600 val_print_scalar_formatted (type, valaddr, embedded_offset,
601 original_value, options, 0, stream);
605 print_floating (valaddr + embedded_offset, type, stream);
609 case TYPE_CODE_DECFLOAT:
611 val_print_scalar_formatted (type, valaddr, embedded_offset,
612 original_value, options, 0, stream);
614 print_decimal_floating (valaddr + embedded_offset,
619 fputs_filtered (decorations->void_name, stream);
622 case TYPE_CODE_ERROR:
623 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
626 case TYPE_CODE_UNDEF:
627 /* This happens (without TYPE_FLAG_STUB set) on systems which
628 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
629 "struct foo *bar" and no complete type for struct foo in that
631 fprintf_filtered (stream, _("<incomplete type>"));
634 case TYPE_CODE_COMPLEX:
635 fprintf_filtered (stream, "%s", decorations->complex_prefix);
637 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
638 valaddr, embedded_offset,
639 original_value, options, 0, stream);
641 print_floating (valaddr + embedded_offset,
642 TYPE_TARGET_TYPE (type),
644 fprintf_filtered (stream, "%s", decorations->complex_infix);
646 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
649 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
653 print_floating (valaddr + embedded_offset
654 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
655 TYPE_TARGET_TYPE (type),
657 fprintf_filtered (stream, "%s", decorations->complex_suffix);
660 case TYPE_CODE_UNION:
661 case TYPE_CODE_STRUCT:
662 case TYPE_CODE_METHODPTR:
664 error (_("Unhandled type code %d in symbol table."),
670 /* Print using the given LANGUAGE the data of type TYPE located at
671 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
672 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
673 STREAM according to OPTIONS. VAL is the whole object that came
674 from ADDRESS. VALADDR must point to the head of VAL's contents
677 The language printers will pass down an adjusted EMBEDDED_OFFSET to
678 further helper subroutines as subfields of TYPE are printed. In
679 such cases, VALADDR is passed down unadjusted, as well as VAL, so
680 that VAL can be queried for metadata about the contents data being
681 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
682 buffer. For example: "has this field been optimized out", or "I'm
683 printing an object while inspecting a traceframe; has this
684 particular piece of data been collected?".
686 RECURSE indicates the amount of indentation to supply before
687 continuation lines; this amount is roughly twice the value of
691 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
692 CORE_ADDR address, struct ui_file *stream, int recurse,
693 const struct value *val,
694 const struct value_print_options *options,
695 const struct language_defn *language)
697 volatile struct gdb_exception except;
699 struct value_print_options local_opts = *options;
700 struct type *real_type = check_typedef (type);
702 if (local_opts.pretty == Val_pretty_default)
703 local_opts.pretty = (local_opts.prettyprint_structs
704 ? Val_prettyprint : Val_no_prettyprint);
708 /* Ensure that the type is complete and not just a stub. If the type is
709 only a stub and we can't find and substitute its complete type, then
710 print appropriate string and return. */
712 if (TYPE_STUB (real_type))
714 fprintf_filtered (stream, _("<incomplete type>"));
719 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
724 ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
725 address, stream, recurse,
726 val, options, language);
731 /* Handle summary mode. If the value is a scalar, print it;
732 otherwise, print an ellipsis. */
733 if (options->summary && !scalar_type_p (type))
735 fprintf_filtered (stream, "...");
739 TRY_CATCH (except, RETURN_MASK_ERROR)
741 language->la_val_print (type, valaddr, embedded_offset, address,
742 stream, recurse, val,
745 if (except.reason < 0)
746 fprintf_filtered (stream, _("<error reading variable>"));
749 /* Check whether the value VAL is printable. Return 1 if it is;
750 return 0 and print an appropriate error message to STREAM according to
751 OPTIONS if it is not. */
754 value_check_printable (struct value *val, struct ui_file *stream,
755 const struct value_print_options *options)
759 fprintf_filtered (stream, _("<address of value unknown>"));
763 if (value_entirely_optimized_out (val))
765 if (options->summary && !scalar_type_p (value_type (val)))
766 fprintf_filtered (stream, "...");
768 val_print_optimized_out (stream);
772 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
774 fprintf_filtered (stream, _("<internal function %s>"),
775 value_internal_function_name (val));
782 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
785 This is a preferable interface to val_print, above, because it uses
786 GDB's value mechanism. */
789 common_val_print (struct value *val, struct ui_file *stream, int recurse,
790 const struct value_print_options *options,
791 const struct language_defn *language)
793 if (!value_check_printable (val, stream, options))
796 if (language->la_language == language_ada)
797 /* The value might have a dynamic type, which would cause trouble
798 below when trying to extract the value contents (since the value
799 size is determined from the type size which is unknown). So
800 get a fixed representation of our value. */
801 val = ada_to_fixed_value (val);
803 val_print (value_type (val), value_contents_for_printing (val),
804 value_embedded_offset (val), value_address (val),
806 val, options, language);
809 /* Print on stream STREAM the value VAL according to OPTIONS. The value
810 is printed using the current_language syntax. */
813 value_print (struct value *val, struct ui_file *stream,
814 const struct value_print_options *options)
816 if (!value_check_printable (val, stream, options))
821 int r = apply_val_pretty_printer (value_type (val),
822 value_contents_for_printing (val),
823 value_embedded_offset (val),
826 val, options, current_language);
832 LA_VALUE_PRINT (val, stream, options);
835 /* Called by various <lang>_val_print routines to print
836 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
837 value. STREAM is where to print the value. */
840 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
841 struct ui_file *stream)
843 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
845 if (TYPE_LENGTH (type) > sizeof (LONGEST))
849 if (TYPE_UNSIGNED (type)
850 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
853 print_longest (stream, 'u', 0, val);
857 /* Signed, or we couldn't turn an unsigned value into a
858 LONGEST. For signed values, one could assume two's
859 complement (a reasonable assumption, I think) and do
861 print_hex_chars (stream, (unsigned char *) valaddr,
862 TYPE_LENGTH (type), byte_order);
867 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
868 unpack_long (type, valaddr));
873 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
874 struct ui_file *stream)
876 ULONGEST val = unpack_long (type, valaddr);
877 int bitpos, nfields = TYPE_NFIELDS (type);
879 fputs_filtered ("[ ", stream);
880 for (bitpos = 0; bitpos < nfields; bitpos++)
882 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
883 && (val & ((ULONGEST)1 << bitpos)))
885 if (TYPE_FIELD_NAME (type, bitpos))
886 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
888 fprintf_filtered (stream, "#%d ", bitpos);
891 fputs_filtered ("]", stream);
894 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
895 according to OPTIONS and SIZE on STREAM. Format i is not supported
898 This is how the elements of an array or structure are printed
902 val_print_scalar_formatted (struct type *type,
903 const gdb_byte *valaddr, int embedded_offset,
904 const struct value *val,
905 const struct value_print_options *options,
907 struct ui_file *stream)
909 gdb_assert (val != NULL);
910 gdb_assert (valaddr == value_contents_for_printing_const (val));
912 /* If we get here with a string format, try again without it. Go
913 all the way back to the language printers, which may call us
915 if (options->format == 's')
917 struct value_print_options opts = *options;
920 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts,
925 /* A scalar object that does not have all bits available can't be
926 printed, because all bits contribute to its representation. */
927 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
928 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
929 val_print_optimized_out (stream);
930 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
931 val_print_unavailable (stream);
933 print_scalar_formatted (valaddr + embedded_offset, type,
934 options, size, stream);
937 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
938 The raison d'etre of this function is to consolidate printing of
939 LONG_LONG's into this one function. The format chars b,h,w,g are
940 from print_scalar_formatted(). Numbers are printed using C
943 USE_C_FORMAT means to use C format in all cases. Without it,
944 'o' and 'x' format do not include the standard C radix prefix
947 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
948 and was intended to request formating according to the current
949 language and would be used for most integers that GDB prints. The
950 exceptional cases were things like protocols where the format of
951 the integer is a protocol thing, not a user-visible thing). The
952 parameter remains to preserve the information of what things might
953 be printed with language-specific format, should we ever resurrect
957 print_longest (struct ui_file *stream, int format, int use_c_format,
965 val = int_string (val_long, 10, 1, 0, 1); break;
967 val = int_string (val_long, 10, 0, 0, 1); break;
969 val = int_string (val_long, 16, 0, 0, use_c_format); break;
971 val = int_string (val_long, 16, 0, 2, 1); break;
973 val = int_string (val_long, 16, 0, 4, 1); break;
975 val = int_string (val_long, 16, 0, 8, 1); break;
977 val = int_string (val_long, 16, 0, 16, 1); break;
980 val = int_string (val_long, 8, 0, 0, use_c_format); break;
982 internal_error (__FILE__, __LINE__,
983 _("failed internal consistency check"));
985 fputs_filtered (val, stream);
988 /* This used to be a macro, but I don't think it is called often enough
989 to merit such treatment. */
990 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
991 arguments to a function, number in a value history, register number, etc.)
992 where the value must not be larger than can fit in an int. */
995 longest_to_int (LONGEST arg)
997 /* Let the compiler do the work. */
998 int rtnval = (int) arg;
1000 /* Check for overflows or underflows. */
1001 if (sizeof (LONGEST) > sizeof (int))
1005 error (_("Value out of range."));
1011 /* Print a floating point value of type TYPE (not always a
1012 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1015 print_floating (const gdb_byte *valaddr, struct type *type,
1016 struct ui_file *stream)
1020 const struct floatformat *fmt = NULL;
1021 unsigned len = TYPE_LENGTH (type);
1022 enum float_kind kind;
1024 /* If it is a floating-point, check for obvious problems. */
1025 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1026 fmt = floatformat_from_type (type);
1029 kind = floatformat_classify (fmt, valaddr);
1030 if (kind == float_nan)
1032 if (floatformat_is_negative (fmt, valaddr))
1033 fprintf_filtered (stream, "-");
1034 fprintf_filtered (stream, "nan(");
1035 fputs_filtered ("0x", stream);
1036 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
1037 fprintf_filtered (stream, ")");
1040 else if (kind == float_infinite)
1042 if (floatformat_is_negative (fmt, valaddr))
1043 fputs_filtered ("-", stream);
1044 fputs_filtered ("inf", stream);
1049 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1050 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1051 needs to be used as that takes care of any necessary type
1052 conversions. Such conversions are of course direct to DOUBLEST
1053 and disregard any possible target floating point limitations.
1054 For instance, a u64 would be converted and displayed exactly on a
1055 host with 80 bit DOUBLEST but with loss of information on a host
1056 with 64 bit DOUBLEST. */
1058 doub = unpack_double (type, valaddr, &inv);
1061 fprintf_filtered (stream, "<invalid float value>");
1065 /* FIXME: kettenis/2001-01-20: The following code makes too much
1066 assumptions about the host and target floating point format. */
1068 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1069 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1070 instead uses the type's length to determine the precision of the
1071 floating-point value being printed. */
1073 if (len < sizeof (double))
1074 fprintf_filtered (stream, "%.9g", (double) doub);
1075 else if (len == sizeof (double))
1076 fprintf_filtered (stream, "%.17g", (double) doub);
1078 #ifdef PRINTF_HAS_LONG_DOUBLE
1079 fprintf_filtered (stream, "%.35Lg", doub);
1081 /* This at least wins with values that are representable as
1083 fprintf_filtered (stream, "%.17g", (double) doub);
1088 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
1089 struct ui_file *stream)
1091 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
1092 char decstr[MAX_DECIMAL_STRING];
1093 unsigned len = TYPE_LENGTH (type);
1095 decimal_to_string (valaddr, len, byte_order, decstr);
1096 fputs_filtered (decstr, stream);
1101 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
1102 unsigned len, enum bfd_endian byte_order)
1105 #define BITS_IN_BYTES 8
1111 /* Declared "int" so it will be signed.
1112 This ensures that right shift will shift in zeros. */
1114 const int mask = 0x080;
1116 /* FIXME: We should be not printing leading zeroes in most cases. */
1118 if (byte_order == BFD_ENDIAN_BIG)
1124 /* Every byte has 8 binary characters; peel off
1125 and print from the MSB end. */
1127 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1129 if (*p & (mask >> i))
1134 fprintf_filtered (stream, "%1d", b);
1140 for (p = valaddr + len - 1;
1144 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1146 if (*p & (mask >> i))
1151 fprintf_filtered (stream, "%1d", b);
1157 /* VALADDR points to an integer of LEN bytes.
1158 Print it in octal on stream or format it in buf. */
1161 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1162 unsigned len, enum bfd_endian byte_order)
1165 unsigned char octa1, octa2, octa3, carry;
1168 /* FIXME: We should be not printing leading zeroes in most cases. */
1171 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1172 * the extra bits, which cycle every three bytes:
1174 * Byte side: 0 1 2 3
1176 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1178 * Octal side: 0 1 carry 3 4 carry ...
1180 * Cycle number: 0 1 2
1182 * But of course we are printing from the high side, so we have to
1183 * figure out where in the cycle we are so that we end up with no
1184 * left over bits at the end.
1186 #define BITS_IN_OCTAL 3
1187 #define HIGH_ZERO 0340
1188 #define LOW_ZERO 0016
1189 #define CARRY_ZERO 0003
1190 #define HIGH_ONE 0200
1191 #define MID_ONE 0160
1192 #define LOW_ONE 0016
1193 #define CARRY_ONE 0001
1194 #define HIGH_TWO 0300
1195 #define MID_TWO 0070
1196 #define LOW_TWO 0007
1198 /* For 32 we start in cycle 2, with two bits and one bit carry;
1199 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1201 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
1204 fputs_filtered ("0", stream);
1205 if (byte_order == BFD_ENDIAN_BIG)
1214 /* No carry in, carry out two bits. */
1216 octa1 = (HIGH_ZERO & *p) >> 5;
1217 octa2 = (LOW_ZERO & *p) >> 2;
1218 carry = (CARRY_ZERO & *p);
1219 fprintf_filtered (stream, "%o", octa1);
1220 fprintf_filtered (stream, "%o", octa2);
1224 /* Carry in two bits, carry out one bit. */
1226 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1227 octa2 = (MID_ONE & *p) >> 4;
1228 octa3 = (LOW_ONE & *p) >> 1;
1229 carry = (CARRY_ONE & *p);
1230 fprintf_filtered (stream, "%o", octa1);
1231 fprintf_filtered (stream, "%o", octa2);
1232 fprintf_filtered (stream, "%o", octa3);
1236 /* Carry in one bit, no carry out. */
1238 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1239 octa2 = (MID_TWO & *p) >> 3;
1240 octa3 = (LOW_TWO & *p);
1242 fprintf_filtered (stream, "%o", octa1);
1243 fprintf_filtered (stream, "%o", octa2);
1244 fprintf_filtered (stream, "%o", octa3);
1248 error (_("Internal error in octal conversion;"));
1252 cycle = cycle % BITS_IN_OCTAL;
1257 for (p = valaddr + len - 1;
1264 /* Carry out, no carry in */
1266 octa1 = (HIGH_ZERO & *p) >> 5;
1267 octa2 = (LOW_ZERO & *p) >> 2;
1268 carry = (CARRY_ZERO & *p);
1269 fprintf_filtered (stream, "%o", octa1);
1270 fprintf_filtered (stream, "%o", octa2);
1274 /* Carry in, carry out */
1276 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1277 octa2 = (MID_ONE & *p) >> 4;
1278 octa3 = (LOW_ONE & *p) >> 1;
1279 carry = (CARRY_ONE & *p);
1280 fprintf_filtered (stream, "%o", octa1);
1281 fprintf_filtered (stream, "%o", octa2);
1282 fprintf_filtered (stream, "%o", octa3);
1286 /* Carry in, no carry out */
1288 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1289 octa2 = (MID_TWO & *p) >> 3;
1290 octa3 = (LOW_TWO & *p);
1292 fprintf_filtered (stream, "%o", octa1);
1293 fprintf_filtered (stream, "%o", octa2);
1294 fprintf_filtered (stream, "%o", octa3);
1298 error (_("Internal error in octal conversion;"));
1302 cycle = cycle % BITS_IN_OCTAL;
1308 /* VALADDR points to an integer of LEN bytes.
1309 Print it in decimal on stream or format it in buf. */
1312 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1313 unsigned len, enum bfd_endian byte_order)
1316 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1317 #define CARRY_LEFT( x ) ((x) % TEN)
1318 #define SHIFT( x ) ((x) << 4)
1319 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1320 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1323 unsigned char *digits;
1326 int i, j, decimal_digits;
1330 /* Base-ten number is less than twice as many digits
1331 as the base 16 number, which is 2 digits per byte. */
1333 decimal_len = len * 2 * 2;
1334 digits = xmalloc (decimal_len);
1336 for (i = 0; i < decimal_len; i++)
1341 /* Ok, we have an unknown number of bytes of data to be printed in
1344 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1345 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1346 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1348 * The trick is that "digits" holds a base-10 number, but sometimes
1349 * the individual digits are > 10.
1351 * Outer loop is per nibble (hex digit) of input, from MSD end to
1354 decimal_digits = 0; /* Number of decimal digits so far */
1355 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
1357 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
1360 * Multiply current base-ten number by 16 in place.
1361 * Each digit was between 0 and 9, now is between
1364 for (j = 0; j < decimal_digits; j++)
1366 digits[j] = SHIFT (digits[j]);
1369 /* Take the next nibble off the input and add it to what
1370 * we've got in the LSB position. Bottom 'digit' is now
1371 * between 0 and 159.
1373 * "flip" is used to run this loop twice for each byte.
1377 /* Take top nibble. */
1379 digits[0] += HIGH_NIBBLE (*p);
1384 /* Take low nibble and bump our pointer "p". */
1386 digits[0] += LOW_NIBBLE (*p);
1387 if (byte_order == BFD_ENDIAN_BIG)
1394 /* Re-decimalize. We have to do this often enough
1395 * that we don't overflow, but once per nibble is
1396 * overkill. Easier this way, though. Note that the
1397 * carry is often larger than 10 (e.g. max initial
1398 * carry out of lowest nibble is 15, could bubble all
1399 * the way up greater than 10). So we have to do
1400 * the carrying beyond the last current digit.
1403 for (j = 0; j < decimal_len - 1; j++)
1407 /* "/" won't handle an unsigned char with
1408 * a value that if signed would be negative.
1409 * So extend to longword int via "dummy".
1412 carry = CARRY_OUT (dummy);
1413 digits[j] = CARRY_LEFT (dummy);
1415 if (j >= decimal_digits && carry == 0)
1418 * All higher digits are 0 and we
1419 * no longer have a carry.
1421 * Note: "j" is 0-based, "decimal_digits" is
1424 decimal_digits = j + 1;
1430 /* Ok, now "digits" is the decimal representation, with
1431 the "decimal_digits" actual digits. Print! */
1433 for (i = decimal_digits - 1; i >= 0; i--)
1435 fprintf_filtered (stream, "%1d", digits[i]);
1440 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1443 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
1444 unsigned len, enum bfd_endian byte_order)
1448 /* FIXME: We should be not printing leading zeroes in most cases. */
1450 fputs_filtered ("0x", stream);
1451 if (byte_order == BFD_ENDIAN_BIG)
1457 fprintf_filtered (stream, "%02x", *p);
1462 for (p = valaddr + len - 1;
1466 fprintf_filtered (stream, "%02x", *p);
1471 /* VALADDR points to a char integer of LEN bytes.
1472 Print it out in appropriate language form on stream.
1473 Omit any leading zero chars. */
1476 print_char_chars (struct ui_file *stream, struct type *type,
1477 const gdb_byte *valaddr,
1478 unsigned len, enum bfd_endian byte_order)
1482 if (byte_order == BFD_ENDIAN_BIG)
1485 while (p < valaddr + len - 1 && *p == 0)
1488 while (p < valaddr + len)
1490 LA_EMIT_CHAR (*p, type, stream, '\'');
1496 p = valaddr + len - 1;
1497 while (p > valaddr && *p == 0)
1500 while (p >= valaddr)
1502 LA_EMIT_CHAR (*p, type, stream, '\'');
1508 /* Print function pointer with inferior address ADDRESS onto stdio
1512 print_function_pointer_address (struct gdbarch *gdbarch,
1514 struct ui_file *stream,
1518 = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
1521 /* If the function pointer is represented by a description, print
1522 the address of the description. */
1523 if (addressprint && func_addr != address)
1525 fputs_filtered ("@", stream);
1526 fputs_filtered (paddress (gdbarch, address), stream);
1527 fputs_filtered (": ", stream);
1529 print_address_demangle (gdbarch, func_addr, stream, demangle);
1533 /* Print on STREAM using the given OPTIONS the index for the element
1534 at INDEX of an array whose index type is INDEX_TYPE. */
1537 maybe_print_array_index (struct type *index_type, LONGEST index,
1538 struct ui_file *stream,
1539 const struct value_print_options *options)
1541 struct value *index_value;
1543 if (!options->print_array_indexes)
1546 index_value = value_from_longest (index_type, index);
1548 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1551 /* Called by various <lang>_val_print routines to print elements of an
1552 array in the form "<elem1>, <elem2>, <elem3>, ...".
1554 (FIXME?) Assumes array element separator is a comma, which is correct
1555 for all languages currently handled.
1556 (FIXME?) Some languages have a notation for repeated array elements,
1557 perhaps we should try to use that notation when appropriate. */
1560 val_print_array_elements (struct type *type,
1561 const gdb_byte *valaddr, int embedded_offset,
1562 CORE_ADDR address, struct ui_file *stream,
1564 const struct value *val,
1565 const struct value_print_options *options,
1568 unsigned int things_printed = 0;
1570 struct type *elttype, *index_type;
1572 /* Position of the array element we are examining to see
1573 whether it is repeated. */
1575 /* Number of repetitions we have detected so far. */
1577 LONGEST low_bound, high_bound;
1579 elttype = TYPE_TARGET_TYPE (type);
1580 eltlen = TYPE_LENGTH (check_typedef (elttype));
1581 index_type = TYPE_INDEX_TYPE (type);
1583 if (get_array_bounds (type, &low_bound, &high_bound))
1585 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1586 But we have to be a little extra careful, because some languages
1587 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1588 empty arrays. In that situation, the array length is just zero,
1590 if (low_bound > high_bound)
1593 len = high_bound - low_bound + 1;
1597 warning (_("unable to get bounds of array, assuming null array"));
1602 annotate_array_section_begin (i, elttype);
1604 for (; i < len && things_printed < options->print_max; i++)
1608 if (options->prettyprint_arrays)
1610 fprintf_filtered (stream, ",\n");
1611 print_spaces_filtered (2 + 2 * recurse, stream);
1615 fprintf_filtered (stream, ", ");
1618 wrap_here (n_spaces (2 + 2 * recurse));
1619 maybe_print_array_index (index_type, i + low_bound,
1624 /* Only check for reps if repeat_count_threshold is not set to
1625 UINT_MAX (unlimited). */
1626 if (options->repeat_count_threshold < UINT_MAX)
1629 && value_available_contents_eq (val,
1630 embedded_offset + i * eltlen,
1641 if (reps > options->repeat_count_threshold)
1643 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1644 address, stream, recurse + 1, val, options,
1646 annotate_elt_rep (reps);
1647 fprintf_filtered (stream, " <repeats %u times>", reps);
1648 annotate_elt_rep_end ();
1651 things_printed += options->repeat_count_threshold;
1655 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1657 stream, recurse + 1, val, options, current_language);
1662 annotate_array_section_end ();
1665 fprintf_filtered (stream, "...");
1669 /* Read LEN bytes of target memory at address MEMADDR, placing the
1670 results in GDB's memory at MYADDR. Returns a count of the bytes
1671 actually read, and optionally an errno value in the location
1672 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1674 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1675 function be eliminated. */
1678 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
1679 int len, int *errnoptr)
1681 int nread; /* Number of bytes actually read. */
1682 int errcode; /* Error from last read. */
1684 /* First try a complete read. */
1685 errcode = target_read_memory (memaddr, myaddr, len);
1693 /* Loop, reading one byte at a time until we get as much as we can. */
1694 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1696 errcode = target_read_memory (memaddr++, myaddr++, 1);
1698 /* If an error, the last read was unsuccessful, so adjust count. */
1704 if (errnoptr != NULL)
1706 *errnoptr = errcode;
1711 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1712 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1713 allocated buffer containing the string, which the caller is responsible to
1714 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1715 success, or errno on failure.
1717 If LEN > 0, reads exactly LEN characters (including eventual NULs in
1718 the middle or end of the string). If LEN is -1, stops at the first
1719 null character (not necessarily the first null byte) up to a maximum
1720 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many
1721 characters as possible from the string.
1723 Unless an exception is thrown, BUFFER will always be allocated, even on
1724 failure. In this case, some characters might have been read before the
1725 failure happened. Check BYTES_READ to recognize this situation.
1727 Note: There was a FIXME asking to make this code use target_read_string,
1728 but this function is more general (can read past null characters, up to
1729 given LEN). Besides, it is used much more often than target_read_string
1730 so it is more tested. Perhaps callers of target_read_string should use
1731 this function instead? */
1734 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
1735 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
1737 int found_nul; /* Non-zero if we found the nul char. */
1738 int errcode; /* Errno returned from bad reads. */
1739 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1740 unsigned int chunksize; /* Size of each fetch, in chars. */
1741 gdb_byte *bufptr; /* Pointer to next available byte in
1743 gdb_byte *limit; /* First location past end of fetch buffer. */
1744 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1746 /* Decide how large of chunks to try to read in one operation. This
1747 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1748 so we might as well read them all in one operation. If LEN is -1, we
1749 are looking for a NUL terminator to end the fetching, so we might as
1750 well read in blocks that are large enough to be efficient, but not so
1751 large as to be slow if fetchlimit happens to be large. So we choose the
1752 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1753 200 is way too big for remote debugging over a serial line. */
1755 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1757 /* Loop until we either have all the characters, or we encounter
1758 some error, such as bumping into the end of the address space. */
1763 old_chain = make_cleanup (free_current_contents, buffer);
1767 *buffer = (gdb_byte *) xmalloc (len * width);
1770 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1772 addr += nfetch * width;
1773 bufptr += nfetch * width;
1777 unsigned long bufsize = 0;
1782 nfetch = min (chunksize, fetchlimit - bufsize);
1784 if (*buffer == NULL)
1785 *buffer = (gdb_byte *) xmalloc (nfetch * width);
1787 *buffer = (gdb_byte *) xrealloc (*buffer,
1788 (nfetch + bufsize) * width);
1790 bufptr = *buffer + bufsize * width;
1793 /* Read as much as we can. */
1794 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1797 /* Scan this chunk for the null character that terminates the string
1798 to print. If found, we don't need to fetch any more. Note
1799 that bufptr is explicitly left pointing at the next character
1800 after the null character, or at the next character after the end
1803 limit = bufptr + nfetch * width;
1804 while (bufptr < limit)
1808 c = extract_unsigned_integer (bufptr, width, byte_order);
1813 /* We don't care about any error which happened after
1814 the NUL terminator. */
1821 while (errcode == 0 /* no error */
1822 && bufptr - *buffer < fetchlimit * width /* no overrun */
1823 && !found_nul); /* haven't found NUL yet */
1826 { /* Length of string is really 0! */
1827 /* We always allocate *buffer. */
1828 *buffer = bufptr = xmalloc (1);
1832 /* bufptr and addr now point immediately beyond the last byte which we
1833 consider part of the string (including a '\0' which ends the string). */
1834 *bytes_read = bufptr - *buffer;
1838 discard_cleanups (old_chain);
1843 /* Return true if print_wchar can display W without resorting to a
1844 numeric escape, false otherwise. */
1847 wchar_printable (gdb_wchar_t w)
1849 return (gdb_iswprint (w)
1850 || w == LCST ('\a') || w == LCST ('\b')
1851 || w == LCST ('\f') || w == LCST ('\n')
1852 || w == LCST ('\r') || w == LCST ('\t')
1853 || w == LCST ('\v'));
1856 /* A helper function that converts the contents of STRING to wide
1857 characters and then appends them to OUTPUT. */
1860 append_string_as_wide (const char *string,
1861 struct obstack *output)
1863 for (; *string; ++string)
1865 gdb_wchar_t w = gdb_btowc (*string);
1866 obstack_grow (output, &w, sizeof (gdb_wchar_t));
1870 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1871 original (target) bytes representing the character, ORIG_LEN is the
1872 number of valid bytes. WIDTH is the number of bytes in a base
1873 characters of the type. OUTPUT is an obstack to which wide
1874 characters are emitted. QUOTER is a (narrow) character indicating
1875 the style of quotes surrounding the character to be printed.
1876 NEED_ESCAPE is an in/out flag which is used to track numeric
1877 escapes across calls. */
1880 print_wchar (gdb_wint_t w, const gdb_byte *orig,
1881 int orig_len, int width,
1882 enum bfd_endian byte_order,
1883 struct obstack *output,
1884 int quoter, int *need_escapep)
1886 int need_escape = *need_escapep;
1889 if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
1891 && w != LCST ('9'))))
1893 gdb_wchar_t wchar = w;
1895 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
1896 obstack_grow_wstr (output, LCST ("\\"));
1897 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
1904 obstack_grow_wstr (output, LCST ("\\a"));
1907 obstack_grow_wstr (output, LCST ("\\b"));
1910 obstack_grow_wstr (output, LCST ("\\f"));
1913 obstack_grow_wstr (output, LCST ("\\n"));
1916 obstack_grow_wstr (output, LCST ("\\r"));
1919 obstack_grow_wstr (output, LCST ("\\t"));
1922 obstack_grow_wstr (output, LCST ("\\v"));
1928 for (i = 0; i + width <= orig_len; i += width)
1933 value = extract_unsigned_integer (&orig[i], width,
1935 /* If the value fits in 3 octal digits, print it that
1936 way. Otherwise, print it as a hex escape. */
1938 sprintf (octal, "\\%.3o", (int) (value & 0777));
1940 sprintf (octal, "\\x%lx", (long) value);
1941 append_string_as_wide (octal, output);
1943 /* If we somehow have extra bytes, print them now. */
1944 while (i < orig_len)
1948 sprintf (octal, "\\%.3o", orig[i] & 0xff);
1949 append_string_as_wide (octal, output);
1960 /* Print the character C on STREAM as part of the contents of a
1961 literal string whose delimiter is QUOTER. ENCODING names the
1965 generic_emit_char (int c, struct type *type, struct ui_file *stream,
1966 int quoter, const char *encoding)
1968 enum bfd_endian byte_order
1969 = gdbarch_byte_order (get_type_arch (type));
1970 struct obstack wchar_buf, output;
1971 struct cleanup *cleanups;
1973 struct wchar_iterator *iter;
1974 int need_escape = 0;
1976 buf = alloca (TYPE_LENGTH (type));
1977 pack_long (buf, type, c);
1979 iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
1980 encoding, TYPE_LENGTH (type));
1981 cleanups = make_cleanup_wchar_iterator (iter);
1983 /* This holds the printable form of the wchar_t data. */
1984 obstack_init (&wchar_buf);
1985 make_cleanup_obstack_free (&wchar_buf);
1991 const gdb_byte *buf;
1993 int print_escape = 1;
1994 enum wchar_iterate_result result;
1996 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
2001 /* If all characters are printable, print them. Otherwise,
2002 we're going to have to print an escape sequence. We
2003 check all characters because we want to print the target
2004 bytes in the escape sequence, and we don't know character
2005 boundaries there. */
2009 for (i = 0; i < num_chars; ++i)
2010 if (!wchar_printable (chars[i]))
2018 for (i = 0; i < num_chars; ++i)
2019 print_wchar (chars[i], buf, buflen,
2020 TYPE_LENGTH (type), byte_order,
2021 &wchar_buf, quoter, &need_escape);
2025 /* This handles the NUM_CHARS == 0 case as well. */
2027 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
2028 byte_order, &wchar_buf, quoter, &need_escape);
2031 /* The output in the host encoding. */
2032 obstack_init (&output);
2033 make_cleanup_obstack_free (&output);
2035 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2036 obstack_base (&wchar_buf),
2037 obstack_object_size (&wchar_buf),
2038 1, &output, translit_char);
2039 obstack_1grow (&output, '\0');
2041 fputs_filtered (obstack_base (&output), stream);
2043 do_cleanups (cleanups);
2046 /* Print the character string STRING, printing at most LENGTH
2047 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2048 the type of each character. OPTIONS holds the printing options;
2049 printing stops early if the number hits print_max; repeat counts
2050 are printed as appropriate. Print ellipses at the end if we had to
2051 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2052 QUOTE_CHAR is the character to print at each end of the string. If
2053 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2057 generic_printstr (struct ui_file *stream, struct type *type,
2058 const gdb_byte *string, unsigned int length,
2059 const char *encoding, int force_ellipses,
2060 int quote_char, int c_style_terminator,
2061 const struct value_print_options *options)
2063 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2065 unsigned int things_printed = 0;
2068 int width = TYPE_LENGTH (type);
2069 struct obstack wchar_buf, output;
2070 struct cleanup *cleanup;
2071 struct wchar_iterator *iter;
2073 int need_escape = 0;
2074 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
2078 unsigned long current_char = 1;
2080 for (i = 0; current_char; ++i)
2083 current_char = extract_unsigned_integer (string + i * width,
2089 /* If the string was not truncated due to `set print elements', and
2090 the last byte of it is a null, we don't print that, in
2091 traditional C style. */
2092 if (c_style_terminator
2095 && (extract_unsigned_integer (string + (length - 1) * width,
2096 width, byte_order) == 0))
2101 fputs_filtered ("\"\"", stream);
2105 /* Arrange to iterate over the characters, in wchar_t form. */
2106 iter = make_wchar_iterator (string, length * width, encoding, width);
2107 cleanup = make_cleanup_wchar_iterator (iter);
2109 /* WCHAR_BUF is the obstack we use to represent the string in
2111 obstack_init (&wchar_buf);
2112 make_cleanup_obstack_free (&wchar_buf);
2114 while (!finished && things_printed < options->print_max)
2117 enum wchar_iterate_result result;
2119 const gdb_byte *buf;
2126 obstack_grow_wstr (&wchar_buf, LCST (", "));
2130 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
2131 /* We only look at repetitions when we were able to convert a
2132 single character in isolation. This makes the code simpler
2133 and probably does the sensible thing in the majority of
2135 while (num_chars == 1 && things_printed < options->print_max)
2137 /* Count the number of repetitions. */
2138 unsigned int reps = 0;
2139 gdb_wchar_t current_char = chars[0];
2140 const gdb_byte *orig_buf = buf;
2141 int orig_len = buflen;
2145 obstack_grow_wstr (&wchar_buf, LCST (", "));
2149 while (num_chars == 1 && current_char == chars[0])
2151 num_chars = wchar_iterate (iter, &result, &chars,
2156 /* Emit CURRENT_CHAR according to the repetition count and
2158 if (reps > options->repeat_count_threshold)
2162 if (options->inspect_it)
2163 obstack_grow_wstr (&wchar_buf, LCST ("\\"));
2164 obstack_grow (&wchar_buf, &wide_quote_char,
2165 sizeof (gdb_wchar_t));
2166 obstack_grow_wstr (&wchar_buf, LCST (", "));
2169 obstack_grow_wstr (&wchar_buf, LCST ("'"));
2171 print_wchar (current_char, orig_buf, orig_len, width,
2172 byte_order, &wchar_buf, '\'', &need_escape);
2173 obstack_grow_wstr (&wchar_buf, LCST ("'"));
2175 /* Painful gyrations. */
2177 char *s = xstrprintf (_(" <repeats %u times>"), reps);
2179 for (j = 0; s[j]; ++j)
2181 gdb_wchar_t w = gdb_btowc (s[j]);
2182 obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
2186 things_printed += options->repeat_count_threshold;
2191 /* Saw the character one or more times, but fewer than
2192 the repetition threshold. */
2195 if (options->inspect_it)
2196 obstack_grow_wstr (&wchar_buf, LCST ("\\"));
2197 obstack_grow (&wchar_buf, &wide_quote_char,
2198 sizeof (gdb_wchar_t));
2205 print_wchar (current_char, orig_buf,
2207 byte_order, &wchar_buf,
2208 quote_char, &need_escape);
2214 /* NUM_CHARS and the other outputs from wchar_iterate are valid
2215 here regardless of which branch was taken above. */
2225 case wchar_iterate_invalid:
2228 if (options->inspect_it)
2229 obstack_grow_wstr (&wchar_buf, LCST ("\\"));
2230 obstack_grow (&wchar_buf, &wide_quote_char,
2231 sizeof (gdb_wchar_t));
2235 print_wchar (gdb_WEOF, buf, buflen, width, byte_order,
2236 &wchar_buf, quote_char, &need_escape);
2239 case wchar_iterate_incomplete:
2242 if (options->inspect_it)
2243 obstack_grow_wstr (&wchar_buf, LCST ("\\"));
2244 obstack_grow (&wchar_buf, &wide_quote_char,
2245 sizeof (gdb_wchar_t));
2246 obstack_grow_wstr (&wchar_buf, LCST (","));
2249 obstack_grow_wstr (&wchar_buf,
2250 LCST (" <incomplete sequence "));
2251 print_wchar (gdb_WEOF, buf, buflen, width,
2252 byte_order, &wchar_buf,
2254 obstack_grow_wstr (&wchar_buf, LCST (">"));
2260 /* Terminate the quotes if necessary. */
2263 if (options->inspect_it)
2264 obstack_grow_wstr (&wchar_buf, LCST ("\\"));
2265 obstack_grow (&wchar_buf, &wide_quote_char,
2266 sizeof (gdb_wchar_t));
2269 if (force_ellipses || !finished)
2270 obstack_grow_wstr (&wchar_buf, LCST ("..."));
2272 /* OUTPUT is where we collect `char's for printing. */
2273 obstack_init (&output);
2274 make_cleanup_obstack_free (&output);
2276 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2277 obstack_base (&wchar_buf),
2278 obstack_object_size (&wchar_buf),
2279 1, &output, translit_char);
2280 obstack_1grow (&output, '\0');
2282 fputs_filtered (obstack_base (&output), stream);
2284 do_cleanups (cleanup);
2287 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2288 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2289 stops at the first null byte, otherwise printing proceeds (including null
2290 bytes) until either print_max or LEN characters have been printed,
2291 whichever is smaller. ENCODING is the name of the string's
2292 encoding. It can be NULL, in which case the target encoding is
2296 val_print_string (struct type *elttype, const char *encoding,
2297 CORE_ADDR addr, int len,
2298 struct ui_file *stream,
2299 const struct value_print_options *options)
2301 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
2302 int errcode; /* Errno returned from bad reads. */
2303 int found_nul; /* Non-zero if we found the nul char. */
2304 unsigned int fetchlimit; /* Maximum number of chars to print. */
2306 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
2307 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2308 struct gdbarch *gdbarch = get_type_arch (elttype);
2309 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2310 int width = TYPE_LENGTH (elttype);
2312 /* First we need to figure out the limit on the number of characters we are
2313 going to attempt to fetch and print. This is actually pretty simple. If
2314 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2315 LEN is -1, then the limit is print_max. This is true regardless of
2316 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2317 because finding the null byte (or available memory) is what actually
2318 limits the fetch. */
2320 fetchlimit = (len == -1 ? options->print_max : min (len,
2321 options->print_max));
2323 errcode = read_string (addr, len, width, fetchlimit, byte_order,
2324 &buffer, &bytes_read);
2325 old_chain = make_cleanup (xfree, buffer);
2329 /* We now have either successfully filled the buffer to fetchlimit,
2330 or terminated early due to an error or finding a null char when
2333 /* Determine found_nul by looking at the last character read. */
2334 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
2336 if (len == -1 && !found_nul)
2340 /* We didn't find a NUL terminator we were looking for. Attempt
2341 to peek at the next character. If not successful, or it is not
2342 a null byte, then force ellipsis to be printed. */
2344 peekbuf = (gdb_byte *) alloca (width);
2346 if (target_read_memory (addr, peekbuf, width) == 0
2347 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
2350 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
2352 /* Getting an error when we have a requested length, or fetching less
2353 than the number of characters actually requested, always make us
2358 /* If we get an error before fetching anything, don't print a string.
2359 But if we fetch something and then get an error, print the string
2360 and then the error message. */
2361 if (errcode == 0 || bytes_read > 0)
2363 if (options->addressprint)
2365 fputs_filtered (" ", stream);
2367 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
2368 encoding, force_ellipsis, options);
2375 fprintf_filtered (stream, " <Address ");
2376 fputs_filtered (paddress (gdbarch, addr), stream);
2377 fprintf_filtered (stream, " out of bounds>");
2381 fprintf_filtered (stream, " <Error reading address ");
2382 fputs_filtered (paddress (gdbarch, addr), stream);
2383 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
2388 do_cleanups (old_chain);
2390 return (bytes_read / width);
2394 /* The 'set input-radix' command writes to this auxiliary variable.
2395 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2396 it is left unchanged. */
2398 static unsigned input_radix_1 = 10;
2400 /* Validate an input or output radix setting, and make sure the user
2401 knows what they really did here. Radix setting is confusing, e.g.
2402 setting the input radix to "10" never changes it! */
2405 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
2407 set_input_radix_1 (from_tty, input_radix_1);
2411 set_input_radix_1 (int from_tty, unsigned radix)
2413 /* We don't currently disallow any input radix except 0 or 1, which don't
2414 make any mathematical sense. In theory, we can deal with any input
2415 radix greater than 1, even if we don't have unique digits for every
2416 value from 0 to radix-1, but in practice we lose on large radix values.
2417 We should either fix the lossage or restrict the radix range more.
2422 input_radix_1 = input_radix;
2423 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2426 input_radix_1 = input_radix = radix;
2429 printf_filtered (_("Input radix now set to "
2430 "decimal %u, hex %x, octal %o.\n"),
2431 radix, radix, radix);
2435 /* The 'set output-radix' command writes to this auxiliary variable.
2436 If the requested radix is valid, OUTPUT_RADIX is updated,
2437 otherwise, it is left unchanged. */
2439 static unsigned output_radix_1 = 10;
2442 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
2444 set_output_radix_1 (from_tty, output_radix_1);
2448 set_output_radix_1 (int from_tty, unsigned radix)
2450 /* Validate the radix and disallow ones that we aren't prepared to
2451 handle correctly, leaving the radix unchanged. */
2455 user_print_options.output_format = 'x'; /* hex */
2458 user_print_options.output_format = 0; /* decimal */
2461 user_print_options.output_format = 'o'; /* octal */
2464 output_radix_1 = output_radix;
2465 error (_("Unsupported output radix ``decimal %u''; "
2466 "output radix unchanged."),
2469 output_radix_1 = output_radix = radix;
2472 printf_filtered (_("Output radix now set to "
2473 "decimal %u, hex %x, octal %o.\n"),
2474 radix, radix, radix);
2478 /* Set both the input and output radix at once. Try to set the output radix
2479 first, since it has the most restrictive range. An radix that is valid as
2480 an output radix is also valid as an input radix.
2482 It may be useful to have an unusual input radix. If the user wishes to
2483 set an input radix that is not valid as an output radix, he needs to use
2484 the 'set input-radix' command. */
2487 set_radix (char *arg, int from_tty)
2491 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
2492 set_output_radix_1 (0, radix);
2493 set_input_radix_1 (0, radix);
2496 printf_filtered (_("Input and output radices now set to "
2497 "decimal %u, hex %x, octal %o.\n"),
2498 radix, radix, radix);
2502 /* Show both the input and output radices. */
2505 show_radix (char *arg, int from_tty)
2509 if (input_radix == output_radix)
2511 printf_filtered (_("Input and output radices set to "
2512 "decimal %u, hex %x, octal %o.\n"),
2513 input_radix, input_radix, input_radix);
2517 printf_filtered (_("Input radix set to decimal "
2518 "%u, hex %x, octal %o.\n"),
2519 input_radix, input_radix, input_radix);
2520 printf_filtered (_("Output radix set to decimal "
2521 "%u, hex %x, octal %o.\n"),
2522 output_radix, output_radix, output_radix);
2529 set_print (char *arg, int from_tty)
2532 "\"set print\" must be followed by the name of a print subcommand.\n");
2533 help_list (setprintlist, "set print ", -1, gdb_stdout);
2537 show_print (char *args, int from_tty)
2539 cmd_show_list (showprintlist, from_tty, "");
2543 _initialize_valprint (void)
2545 add_prefix_cmd ("print", no_class, set_print,
2546 _("Generic command for setting how things print."),
2547 &setprintlist, "set print ", 0, &setlist);
2548 add_alias_cmd ("p", "print", no_class, 1, &setlist);
2549 /* Prefer set print to set prompt. */
2550 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
2552 add_prefix_cmd ("print", no_class, show_print,
2553 _("Generic command for showing print settings."),
2554 &showprintlist, "show print ", 0, &showlist);
2555 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2556 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
2558 add_setshow_uinteger_cmd ("elements", no_class,
2559 &user_print_options.print_max, _("\
2560 Set limit on string chars or array elements to print."), _("\
2561 Show limit on string chars or array elements to print."), _("\
2562 \"set print elements 0\" causes there to be no limit."),
2565 &setprintlist, &showprintlist);
2567 add_setshow_boolean_cmd ("null-stop", no_class,
2568 &user_print_options.stop_print_at_null, _("\
2569 Set printing of char arrays to stop at first null char."), _("\
2570 Show printing of char arrays to stop at first null char."), NULL,
2572 show_stop_print_at_null,
2573 &setprintlist, &showprintlist);
2575 add_setshow_uinteger_cmd ("repeats", no_class,
2576 &user_print_options.repeat_count_threshold, _("\
2577 Set threshold for repeated print elements."), _("\
2578 Show threshold for repeated print elements."), _("\
2579 \"set print repeats 0\" causes all elements to be individually printed."),
2581 show_repeat_count_threshold,
2582 &setprintlist, &showprintlist);
2584 add_setshow_boolean_cmd ("pretty", class_support,
2585 &user_print_options.prettyprint_structs, _("\
2586 Set prettyprinting of structures."), _("\
2587 Show prettyprinting of structures."), NULL,
2589 show_prettyprint_structs,
2590 &setprintlist, &showprintlist);
2592 add_setshow_boolean_cmd ("union", class_support,
2593 &user_print_options.unionprint, _("\
2594 Set printing of unions interior to structures."), _("\
2595 Show printing of unions interior to structures."), NULL,
2598 &setprintlist, &showprintlist);
2600 add_setshow_boolean_cmd ("array", class_support,
2601 &user_print_options.prettyprint_arrays, _("\
2602 Set prettyprinting of arrays."), _("\
2603 Show prettyprinting of arrays."), NULL,
2605 show_prettyprint_arrays,
2606 &setprintlist, &showprintlist);
2608 add_setshow_boolean_cmd ("address", class_support,
2609 &user_print_options.addressprint, _("\
2610 Set printing of addresses."), _("\
2611 Show printing of addresses."), NULL,
2614 &setprintlist, &showprintlist);
2616 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
2618 Set default input radix for entering numbers."), _("\
2619 Show default input radix for entering numbers."), NULL,
2622 &setlist, &showlist);
2624 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
2626 Set default output radix for printing of values."), _("\
2627 Show default output radix for printing of values."), NULL,
2630 &setlist, &showlist);
2632 /* The "set radix" and "show radix" commands are special in that
2633 they are like normal set and show commands but allow two normally
2634 independent variables to be either set or shown with a single
2635 command. So the usual deprecated_add_set_cmd() and [deleted]
2636 add_show_from_set() commands aren't really appropriate. */
2637 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2638 longer true - show can display anything. */
2639 add_cmd ("radix", class_support, set_radix, _("\
2640 Set default input and output number radices.\n\
2641 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2642 Without an argument, sets both radices back to the default value of 10."),
2644 add_cmd ("radix", class_support, show_radix, _("\
2645 Show the default input and output number radices.\n\
2646 Use 'show input-radix' or 'show output-radix' to independently show each."),
2649 add_setshow_boolean_cmd ("array-indexes", class_support,
2650 &user_print_options.print_array_indexes, _("\
2651 Set printing of array indexes."), _("\
2652 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
2653 &setprintlist, &showprintlist);