2011-01-11 Michael Snyder <msnyder@vmware.com>
[deliverable/binutils-gdb.git] / gdb / valprint.c
CommitLineData
c906108c 1/* Print values for GDB, the GNU debugger.
5c1c87f0 2
6aba47ca 3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
0fb0cc75 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7b6bb8da 5 2009, 2010, 2011 Free Software Foundation, Inc.
c906108c 6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
c5aa993b 12 (at your option) any later version.
c906108c 13
c5aa993b
JM
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b 19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
21
22#include "defs.h"
23#include "gdb_string.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "value.h"
27#include "gdbcore.h"
28#include "gdbcmd.h"
29#include "target.h"
c906108c 30#include "language.h"
c906108c
SS
31#include "annotate.h"
32#include "valprint.h"
39424bef 33#include "floatformat.h"
d16aafd8 34#include "doublest.h"
19ca80ba 35#include "exceptions.h"
7678ef8f 36#include "dfp.h"
a6bac58e 37#include "python/python.h"
0c3acc09 38#include "ada-lang.h"
c906108c
SS
39
40#include <errno.h>
41
42/* Prototypes for local functions */
43
777ea8f1 44static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
917317f4
JM
45 int len, int *errnoptr);
46
a14ed312 47static void show_print (char *, int);
c906108c 48
a14ed312 49static void set_print (char *, int);
c906108c 50
a14ed312 51static void set_radix (char *, int);
c906108c 52
a14ed312 53static void show_radix (char *, int);
c906108c 54
a14ed312 55static void set_input_radix (char *, int, struct cmd_list_element *);
c906108c 56
a14ed312 57static void set_input_radix_1 (int, unsigned);
c906108c 58
a14ed312 59static void set_output_radix (char *, int, struct cmd_list_element *);
c906108c 60
a14ed312 61static void set_output_radix_1 (int, unsigned);
c906108c 62
a14ed312 63void _initialize_valprint (void);
c906108c 64
581e13c1 65#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
79a45b7d
TT
66
67struct value_print_options user_print_options =
68{
69 Val_pretty_default, /* pretty */
70 0, /* prettyprint_arrays */
71 0, /* prettyprint_structs */
72 0, /* vtblprint */
73 1, /* unionprint */
74 1, /* addressprint */
75 0, /* objectprint */
76 PRINT_MAX_DEFAULT, /* print_max */
77 10, /* repeat_count_threshold */
78 0, /* output_format */
79 0, /* format */
80 0, /* stop_print_at_null */
81 0, /* inspect_it */
82 0, /* print_array_indexes */
83 0, /* deref_ref */
84 1, /* static_field_print */
a6bac58e
TT
85 1, /* pascal_static_field_print */
86 0, /* raw */
87 0 /* summary */
79a45b7d
TT
88};
89
90/* Initialize *OPTS to be a copy of the user print options. */
91void
92get_user_print_options (struct value_print_options *opts)
93{
94 *opts = user_print_options;
95}
96
97/* Initialize *OPTS to be a copy of the user print options, but with
98 pretty-printing disabled. */
99void
100get_raw_print_options (struct value_print_options *opts)
101{
102 *opts = user_print_options;
103 opts->pretty = Val_no_prettyprint;
104}
105
106/* Initialize *OPTS to be a copy of the user print options, but using
107 FORMAT as the formatting option. */
108void
109get_formatted_print_options (struct value_print_options *opts,
110 char format)
111{
112 *opts = user_print_options;
113 opts->format = format;
114}
115
920d2a44
AC
116static void
117show_print_max (struct ui_file *file, int from_tty,
118 struct cmd_list_element *c, const char *value)
119{
3e43a32a
MS
120 fprintf_filtered (file,
121 _("Limit on string chars or array "
122 "elements to print is %s.\n"),
920d2a44
AC
123 value);
124}
125
c906108c
SS
126
127/* Default input and output radixes, and output format letter. */
128
129unsigned input_radix = 10;
920d2a44
AC
130static void
131show_input_radix (struct ui_file *file, int from_tty,
132 struct cmd_list_element *c, const char *value)
133{
3e43a32a
MS
134 fprintf_filtered (file,
135 _("Default input radix for entering numbers is %s.\n"),
920d2a44
AC
136 value);
137}
138
c906108c 139unsigned output_radix = 10;
920d2a44
AC
140static void
141show_output_radix (struct ui_file *file, int from_tty,
142 struct cmd_list_element *c, const char *value)
143{
3e43a32a
MS
144 fprintf_filtered (file,
145 _("Default output radix for printing of values is %s.\n"),
920d2a44
AC
146 value);
147}
c906108c 148
e79af960
JB
149/* By default we print arrays without printing the index of each element in
150 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
151
e79af960
JB
152static void
153show_print_array_indexes (struct ui_file *file, int from_tty,
154 struct cmd_list_element *c, const char *value)
155{
156 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
157}
158
c906108c
SS
159/* Print repeat counts if there are more than this many repetitions of an
160 element in an array. Referenced by the low level language dependent
581e13c1 161 print routines. */
c906108c 162
920d2a44
AC
163static void
164show_repeat_count_threshold (struct ui_file *file, int from_tty,
165 struct cmd_list_element *c, const char *value)
166{
167 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
168 value);
169}
c906108c 170
581e13c1 171/* If nonzero, stops printing of char arrays at first null. */
c906108c 172
920d2a44
AC
173static void
174show_stop_print_at_null (struct ui_file *file, int from_tty,
175 struct cmd_list_element *c, const char *value)
176{
3e43a32a
MS
177 fprintf_filtered (file,
178 _("Printing of char arrays to stop "
179 "at first null char is %s.\n"),
920d2a44
AC
180 value);
181}
c906108c 182
581e13c1 183/* Controls pretty printing of structures. */
c906108c 184
920d2a44
AC
185static void
186show_prettyprint_structs (struct ui_file *file, int from_tty,
187 struct cmd_list_element *c, const char *value)
188{
189 fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
190}
c906108c
SS
191
192/* Controls pretty printing of arrays. */
193
920d2a44
AC
194static void
195show_prettyprint_arrays (struct ui_file *file, int from_tty,
196 struct cmd_list_element *c, const char *value)
197{
198 fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
199}
c906108c
SS
200
201/* If nonzero, causes unions inside structures or other unions to be
581e13c1 202 printed. */
c906108c 203
920d2a44
AC
204static void
205show_unionprint (struct ui_file *file, int from_tty,
206 struct cmd_list_element *c, const char *value)
207{
3e43a32a
MS
208 fprintf_filtered (file,
209 _("Printing of unions interior to structures is %s.\n"),
920d2a44
AC
210 value);
211}
c906108c 212
581e13c1 213/* If nonzero, causes machine addresses to be printed in certain contexts. */
c906108c 214
920d2a44
AC
215static void
216show_addressprint (struct ui_file *file, int from_tty,
217 struct cmd_list_element *c, const char *value)
218{
219 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
220}
c906108c 221\f
c5aa993b 222
a6bac58e
TT
223/* A helper function for val_print. When printing in "summary" mode,
224 we want to print scalar arguments, but not aggregate arguments.
225 This function distinguishes between the two. */
226
227static int
228scalar_type_p (struct type *type)
229{
230 CHECK_TYPEDEF (type);
231 while (TYPE_CODE (type) == TYPE_CODE_REF)
232 {
233 type = TYPE_TARGET_TYPE (type);
234 CHECK_TYPEDEF (type);
235 }
236 switch (TYPE_CODE (type))
237 {
238 case TYPE_CODE_ARRAY:
239 case TYPE_CODE_STRUCT:
240 case TYPE_CODE_UNION:
241 case TYPE_CODE_SET:
242 case TYPE_CODE_STRING:
243 case TYPE_CODE_BITSTRING:
244 return 0;
245 default:
246 return 1;
247 }
248}
249
0e03807e
TT
250/* Helper function to check the validity of some bits of a value.
251
252 If TYPE represents some aggregate type (e.g., a structure), return 1.
253
254 Otherwise, any of the bytes starting at OFFSET and extending for
255 TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
256 return 0. The checking is done using FUNCS.
257
258 Otherwise, return 1. */
259
260static int
261valprint_check_validity (struct ui_file *stream,
262 struct type *type,
263 int offset,
264 const struct value *val)
265{
266 CHECK_TYPEDEF (type);
267
268 if (TYPE_CODE (type) != TYPE_CODE_UNION
269 && TYPE_CODE (type) != TYPE_CODE_STRUCT
270 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
271 {
272 if (! value_bits_valid (val, TARGET_CHAR_BIT * offset,
273 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
274 {
275 fprintf_filtered (stream, _("<value optimized out>"));
276 return 0;
277 }
8cf6f0b1
TT
278
279 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * offset,
280 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
281 {
282 fputs_filtered (_("<synthetic pointer>"), stream);
283 return 0;
284 }
0e03807e
TT
285 }
286
287 return 1;
288}
289
d8ca156b
JB
290/* Print using the given LANGUAGE the data of type TYPE located at VALADDR
291 (within GDB), which came from the inferior at address ADDRESS, onto
79a45b7d 292 stdio stream STREAM according to OPTIONS.
c906108c
SS
293
294 If the data are a string pointer, returns the number of string characters
295 printed.
296
297 FIXME: The data at VALADDR is in target byte order. If gdb is ever
298 enhanced to be able to debug more than the single target it was compiled
299 for (specific CPU type and thus specific target byte ordering), then
300 either the print routines are going to have to take this into account,
301 or the data is going to have to be passed into here already converted
581e13c1 302 to the host byte ordering, whichever is more convenient. */
c906108c
SS
303
304
305int
fc1a4b47 306val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
79a45b7d 307 CORE_ADDR address, struct ui_file *stream, int recurse,
0e03807e 308 const struct value *val,
79a45b7d 309 const struct value_print_options *options,
d8ca156b 310 const struct language_defn *language)
c906108c 311{
19ca80ba
DJ
312 volatile struct gdb_exception except;
313 int ret = 0;
79a45b7d 314 struct value_print_options local_opts = *options;
c906108c 315 struct type *real_type = check_typedef (type);
79a45b7d
TT
316
317 if (local_opts.pretty == Val_pretty_default)
318 local_opts.pretty = (local_opts.prettyprint_structs
319 ? Val_prettyprint : Val_no_prettyprint);
c5aa993b 320
c906108c
SS
321 QUIT;
322
323 /* Ensure that the type is complete and not just a stub. If the type is
324 only a stub and we can't find and substitute its complete type, then
325 print appropriate string and return. */
326
74a9bb82 327 if (TYPE_STUB (real_type))
c906108c 328 {
0e03807e 329 fprintf_filtered (stream, _("<incomplete type>"));
c906108c
SS
330 gdb_flush (stream);
331 return (0);
332 }
c5aa993b 333
0e03807e
TT
334 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
335 return 0;
336
a6bac58e
TT
337 if (!options->raw)
338 {
339 ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
0e03807e
TT
340 address, stream, recurse,
341 val, options, language);
a6bac58e
TT
342 if (ret)
343 return ret;
344 }
345
346 /* Handle summary mode. If the value is a scalar, print it;
347 otherwise, print an ellipsis. */
348 if (options->summary && !scalar_type_p (type))
349 {
350 fprintf_filtered (stream, "...");
351 return 0;
352 }
353
19ca80ba
DJ
354 TRY_CATCH (except, RETURN_MASK_ERROR)
355 {
d8ca156b 356 ret = language->la_val_print (type, valaddr, embedded_offset, address,
0e03807e
TT
357 stream, recurse, val,
358 &local_opts);
19ca80ba
DJ
359 }
360 if (except.reason < 0)
361 fprintf_filtered (stream, _("<error reading variable>"));
362
363 return ret;
c906108c
SS
364}
365
806048c6
DJ
366/* Check whether the value VAL is printable. Return 1 if it is;
367 return 0 and print an appropriate error message to STREAM if it
368 is not. */
c906108c 369
806048c6
DJ
370static int
371value_check_printable (struct value *val, struct ui_file *stream)
c906108c
SS
372{
373 if (val == 0)
374 {
806048c6 375 fprintf_filtered (stream, _("<address of value unknown>"));
c906108c
SS
376 return 0;
377 }
806048c6 378
0e03807e 379 if (value_entirely_optimized_out (val))
c906108c 380 {
806048c6 381 fprintf_filtered (stream, _("<value optimized out>"));
c906108c
SS
382 return 0;
383 }
806048c6 384
bc3b79fd
TJB
385 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
386 {
387 fprintf_filtered (stream, _("<internal function %s>"),
388 value_internal_function_name (val));
389 return 0;
390 }
391
806048c6
DJ
392 return 1;
393}
394
d8ca156b 395/* Print using the given LANGUAGE the value VAL onto stream STREAM according
79a45b7d 396 to OPTIONS.
806048c6
DJ
397
398 If the data are a string pointer, returns the number of string characters
399 printed.
400
401 This is a preferable interface to val_print, above, because it uses
402 GDB's value mechanism. */
403
404int
79a45b7d
TT
405common_val_print (struct value *val, struct ui_file *stream, int recurse,
406 const struct value_print_options *options,
d8ca156b 407 const struct language_defn *language)
806048c6
DJ
408{
409 if (!value_check_printable (val, stream))
410 return 0;
411
0c3acc09
JB
412 if (language->la_language == language_ada)
413 /* The value might have a dynamic type, which would cause trouble
414 below when trying to extract the value contents (since the value
415 size is determined from the type size which is unknown). So
416 get a fixed representation of our value. */
417 val = ada_to_fixed_value (val);
418
0e03807e 419 return val_print (value_type (val), value_contents_for_printing (val),
42ae5230 420 value_embedded_offset (val), value_address (val),
0e03807e
TT
421 stream, recurse,
422 val, options, language);
806048c6
DJ
423}
424
7348c5e1
JB
425/* Print on stream STREAM the value VAL according to OPTIONS. The value
426 is printed using the current_language syntax.
427
428 If the object printed is a string pointer, return the number of string
429 bytes printed. */
806048c6
DJ
430
431int
79a45b7d
TT
432value_print (struct value *val, struct ui_file *stream,
433 const struct value_print_options *options)
806048c6
DJ
434{
435 if (!value_check_printable (val, stream))
436 return 0;
437
a6bac58e
TT
438 if (!options->raw)
439 {
440 int r = apply_val_pretty_printer (value_type (val),
0e03807e 441 value_contents_for_printing (val),
a6bac58e
TT
442 value_embedded_offset (val),
443 value_address (val),
0e03807e
TT
444 stream, 0,
445 val, options, current_language);
a109c7c1 446
a6bac58e
TT
447 if (r)
448 return r;
449 }
450
79a45b7d 451 return LA_VALUE_PRINT (val, stream, options);
c906108c
SS
452}
453
454/* Called by various <lang>_val_print routines to print
455 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
456 value. STREAM is where to print the value. */
457
458void
fc1a4b47 459val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
fba45db2 460 struct ui_file *stream)
c906108c 461{
50810684 462 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
d44e8473 463
c906108c
SS
464 if (TYPE_LENGTH (type) > sizeof (LONGEST))
465 {
466 LONGEST val;
467
468 if (TYPE_UNSIGNED (type)
469 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
e17a4113 470 byte_order, &val))
c906108c
SS
471 {
472 print_longest (stream, 'u', 0, val);
473 }
474 else
475 {
476 /* Signed, or we couldn't turn an unsigned value into a
477 LONGEST. For signed values, one could assume two's
478 complement (a reasonable assumption, I think) and do
479 better than this. */
480 print_hex_chars (stream, (unsigned char *) valaddr,
d44e8473 481 TYPE_LENGTH (type), byte_order);
c906108c
SS
482 }
483 }
484 else
485 {
c906108c
SS
486 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
487 unpack_long (type, valaddr));
c906108c
SS
488 }
489}
490
4f2aea11
MK
491void
492val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
493 struct ui_file *stream)
494{
befae759 495 ULONGEST val = unpack_long (type, valaddr);
4f2aea11
MK
496 int bitpos, nfields = TYPE_NFIELDS (type);
497
498 fputs_filtered ("[ ", stream);
499 for (bitpos = 0; bitpos < nfields; bitpos++)
500 {
316703b9
MK
501 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
502 && (val & ((ULONGEST)1 << bitpos)))
4f2aea11
MK
503 {
504 if (TYPE_FIELD_NAME (type, bitpos))
505 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
506 else
507 fprintf_filtered (stream, "#%d ", bitpos);
508 }
509 }
510 fputs_filtered ("]", stream);
511}
512
c906108c
SS
513/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
514 The raison d'etre of this function is to consolidate printing of
581e13c1 515 LONG_LONG's into this one function. The format chars b,h,w,g are
bb599908 516 from print_scalar_formatted(). Numbers are printed using C
581e13c1 517 format.
bb599908
PH
518
519 USE_C_FORMAT means to use C format in all cases. Without it,
520 'o' and 'x' format do not include the standard C radix prefix
521 (leading 0 or 0x).
522
523 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
524 and was intended to request formating according to the current
525 language and would be used for most integers that GDB prints. The
526 exceptional cases were things like protocols where the format of
527 the integer is a protocol thing, not a user-visible thing). The
528 parameter remains to preserve the information of what things might
529 be printed with language-specific format, should we ever resurrect
581e13c1 530 that capability. */
c906108c
SS
531
532void
bb599908 533print_longest (struct ui_file *stream, int format, int use_c_format,
fba45db2 534 LONGEST val_long)
c906108c 535{
2bfb72ee
AC
536 const char *val;
537
c906108c
SS
538 switch (format)
539 {
540 case 'd':
bb599908 541 val = int_string (val_long, 10, 1, 0, 1); break;
c906108c 542 case 'u':
bb599908 543 val = int_string (val_long, 10, 0, 0, 1); break;
c906108c 544 case 'x':
bb599908 545 val = int_string (val_long, 16, 0, 0, use_c_format); break;
c906108c 546 case 'b':
bb599908 547 val = int_string (val_long, 16, 0, 2, 1); break;
c906108c 548 case 'h':
bb599908 549 val = int_string (val_long, 16, 0, 4, 1); break;
c906108c 550 case 'w':
bb599908 551 val = int_string (val_long, 16, 0, 8, 1); break;
c906108c 552 case 'g':
bb599908 553 val = int_string (val_long, 16, 0, 16, 1); break;
c906108c
SS
554 break;
555 case 'o':
bb599908 556 val = int_string (val_long, 8, 0, 0, use_c_format); break;
c906108c 557 default:
3e43a32a
MS
558 internal_error (__FILE__, __LINE__,
559 _("failed internal consistency check"));
bb599908 560 }
2bfb72ee 561 fputs_filtered (val, stream);
c906108c
SS
562}
563
c906108c
SS
564/* This used to be a macro, but I don't think it is called often enough
565 to merit such treatment. */
566/* Convert a LONGEST to an int. This is used in contexts (e.g. number of
567 arguments to a function, number in a value history, register number, etc.)
568 where the value must not be larger than can fit in an int. */
569
570int
fba45db2 571longest_to_int (LONGEST arg)
c906108c 572{
581e13c1 573 /* Let the compiler do the work. */
c906108c
SS
574 int rtnval = (int) arg;
575
581e13c1 576 /* Check for overflows or underflows. */
c906108c
SS
577 if (sizeof (LONGEST) > sizeof (int))
578 {
579 if (rtnval != arg)
580 {
8a3fe4f8 581 error (_("Value out of range."));
c906108c
SS
582 }
583 }
584 return (rtnval);
585}
586
a73c86fb
AC
587/* Print a floating point value of type TYPE (not always a
588 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
c906108c
SS
589
590void
fc1a4b47 591print_floating (const gdb_byte *valaddr, struct type *type,
c84141d6 592 struct ui_file *stream)
c906108c
SS
593{
594 DOUBLEST doub;
595 int inv;
a73c86fb 596 const struct floatformat *fmt = NULL;
c906108c 597 unsigned len = TYPE_LENGTH (type);
20389057 598 enum float_kind kind;
c5aa993b 599
a73c86fb
AC
600 /* If it is a floating-point, check for obvious problems. */
601 if (TYPE_CODE (type) == TYPE_CODE_FLT)
602 fmt = floatformat_from_type (type);
20389057 603 if (fmt != NULL)
39424bef 604 {
20389057
DJ
605 kind = floatformat_classify (fmt, valaddr);
606 if (kind == float_nan)
607 {
608 if (floatformat_is_negative (fmt, valaddr))
609 fprintf_filtered (stream, "-");
610 fprintf_filtered (stream, "nan(");
611 fputs_filtered ("0x", stream);
612 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
613 fprintf_filtered (stream, ")");
614 return;
615 }
616 else if (kind == float_infinite)
617 {
618 if (floatformat_is_negative (fmt, valaddr))
619 fputs_filtered ("-", stream);
620 fputs_filtered ("inf", stream);
621 return;
622 }
7355ddba 623 }
c906108c 624
a73c86fb
AC
625 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
626 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
627 needs to be used as that takes care of any necessary type
628 conversions. Such conversions are of course direct to DOUBLEST
629 and disregard any possible target floating point limitations.
630 For instance, a u64 would be converted and displayed exactly on a
631 host with 80 bit DOUBLEST but with loss of information on a host
632 with 64 bit DOUBLEST. */
c2f05ac9 633
c906108c
SS
634 doub = unpack_double (type, valaddr, &inv);
635 if (inv)
636 {
637 fprintf_filtered (stream, "<invalid float value>");
638 return;
639 }
640
39424bef
MK
641 /* FIXME: kettenis/2001-01-20: The following code makes too much
642 assumptions about the host and target floating point format. */
643
a73c86fb 644 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
c41b8590 645 not necessarily be a TYPE_CODE_FLT, the below ignores that and
a73c86fb
AC
646 instead uses the type's length to determine the precision of the
647 floating-point value being printed. */
c2f05ac9 648
c906108c 649 if (len < sizeof (double))
c5aa993b 650 fprintf_filtered (stream, "%.9g", (double) doub);
c906108c 651 else if (len == sizeof (double))
c5aa993b 652 fprintf_filtered (stream, "%.17g", (double) doub);
c906108c
SS
653 else
654#ifdef PRINTF_HAS_LONG_DOUBLE
655 fprintf_filtered (stream, "%.35Lg", doub);
656#else
39424bef
MK
657 /* This at least wins with values that are representable as
658 doubles. */
c906108c
SS
659 fprintf_filtered (stream, "%.17g", (double) doub);
660#endif
661}
662
7678ef8f
TJB
663void
664print_decimal_floating (const gdb_byte *valaddr, struct type *type,
665 struct ui_file *stream)
666{
e17a4113 667 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
7678ef8f
TJB
668 char decstr[MAX_DECIMAL_STRING];
669 unsigned len = TYPE_LENGTH (type);
670
e17a4113 671 decimal_to_string (valaddr, len, byte_order, decstr);
7678ef8f
TJB
672 fputs_filtered (decstr, stream);
673 return;
674}
675
c5aa993b 676void
fc1a4b47 677print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 678 unsigned len, enum bfd_endian byte_order)
c906108c
SS
679{
680
681#define BITS_IN_BYTES 8
682
fc1a4b47 683 const gdb_byte *p;
745b8ca0 684 unsigned int i;
c5aa993b 685 int b;
c906108c
SS
686
687 /* Declared "int" so it will be signed.
581e13c1
MS
688 This ensures that right shift will shift in zeros. */
689
c5aa993b 690 const int mask = 0x080;
c906108c
SS
691
692 /* FIXME: We should be not printing leading zeroes in most cases. */
693
d44e8473 694 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
695 {
696 for (p = valaddr;
697 p < valaddr + len;
698 p++)
699 {
c5aa993b 700 /* Every byte has 8 binary characters; peel off
581e13c1
MS
701 and print from the MSB end. */
702
c5aa993b
JM
703 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
704 {
705 if (*p & (mask >> i))
706 b = 1;
707 else
708 b = 0;
709
710 fprintf_filtered (stream, "%1d", b);
711 }
c906108c
SS
712 }
713 }
714 else
715 {
716 for (p = valaddr + len - 1;
717 p >= valaddr;
718 p--)
719 {
c5aa993b
JM
720 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
721 {
722 if (*p & (mask >> i))
723 b = 1;
724 else
725 b = 0;
726
727 fprintf_filtered (stream, "%1d", b);
728 }
c906108c
SS
729 }
730 }
c906108c
SS
731}
732
733/* VALADDR points to an integer of LEN bytes.
581e13c1
MS
734 Print it in octal on stream or format it in buf. */
735
c906108c 736void
fc1a4b47 737print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 738 unsigned len, enum bfd_endian byte_order)
c906108c 739{
fc1a4b47 740 const gdb_byte *p;
c906108c 741 unsigned char octa1, octa2, octa3, carry;
c5aa993b
JM
742 int cycle;
743
c906108c
SS
744 /* FIXME: We should be not printing leading zeroes in most cases. */
745
746
747 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
748 * the extra bits, which cycle every three bytes:
749 *
750 * Byte side: 0 1 2 3
751 * | | | |
752 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
753 *
754 * Octal side: 0 1 carry 3 4 carry ...
755 *
756 * Cycle number: 0 1 2
757 *
758 * But of course we are printing from the high side, so we have to
759 * figure out where in the cycle we are so that we end up with no
760 * left over bits at the end.
761 */
762#define BITS_IN_OCTAL 3
763#define HIGH_ZERO 0340
764#define LOW_ZERO 0016
765#define CARRY_ZERO 0003
766#define HIGH_ONE 0200
767#define MID_ONE 0160
768#define LOW_ONE 0016
769#define CARRY_ONE 0001
770#define HIGH_TWO 0300
771#define MID_TWO 0070
772#define LOW_TWO 0007
773
774 /* For 32 we start in cycle 2, with two bits and one bit carry;
581e13c1
MS
775 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
776
c906108c
SS
777 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
778 carry = 0;
c5aa993b 779
bb599908 780 fputs_filtered ("0", stream);
d44e8473 781 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
782 {
783 for (p = valaddr;
784 p < valaddr + len;
785 p++)
786 {
c5aa993b
JM
787 switch (cycle)
788 {
789 case 0:
581e13c1
MS
790 /* No carry in, carry out two bits. */
791
c5aa993b
JM
792 octa1 = (HIGH_ZERO & *p) >> 5;
793 octa2 = (LOW_ZERO & *p) >> 2;
794 carry = (CARRY_ZERO & *p);
795 fprintf_filtered (stream, "%o", octa1);
796 fprintf_filtered (stream, "%o", octa2);
797 break;
798
799 case 1:
581e13c1
MS
800 /* Carry in two bits, carry out one bit. */
801
c5aa993b
JM
802 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
803 octa2 = (MID_ONE & *p) >> 4;
804 octa3 = (LOW_ONE & *p) >> 1;
805 carry = (CARRY_ONE & *p);
806 fprintf_filtered (stream, "%o", octa1);
807 fprintf_filtered (stream, "%o", octa2);
808 fprintf_filtered (stream, "%o", octa3);
809 break;
810
811 case 2:
581e13c1
MS
812 /* Carry in one bit, no carry out. */
813
c5aa993b
JM
814 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
815 octa2 = (MID_TWO & *p) >> 3;
816 octa3 = (LOW_TWO & *p);
817 carry = 0;
818 fprintf_filtered (stream, "%o", octa1);
819 fprintf_filtered (stream, "%o", octa2);
820 fprintf_filtered (stream, "%o", octa3);
821 break;
822
823 default:
8a3fe4f8 824 error (_("Internal error in octal conversion;"));
c5aa993b
JM
825 }
826
827 cycle++;
828 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
829 }
830 }
831 else
832 {
833 for (p = valaddr + len - 1;
834 p >= valaddr;
835 p--)
836 {
c5aa993b
JM
837 switch (cycle)
838 {
839 case 0:
840 /* Carry out, no carry in */
581e13c1 841
c5aa993b
JM
842 octa1 = (HIGH_ZERO & *p) >> 5;
843 octa2 = (LOW_ZERO & *p) >> 2;
844 carry = (CARRY_ZERO & *p);
845 fprintf_filtered (stream, "%o", octa1);
846 fprintf_filtered (stream, "%o", octa2);
847 break;
848
849 case 1:
850 /* Carry in, carry out */
581e13c1 851
c5aa993b
JM
852 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
853 octa2 = (MID_ONE & *p) >> 4;
854 octa3 = (LOW_ONE & *p) >> 1;
855 carry = (CARRY_ONE & *p);
856 fprintf_filtered (stream, "%o", octa1);
857 fprintf_filtered (stream, "%o", octa2);
858 fprintf_filtered (stream, "%o", octa3);
859 break;
860
861 case 2:
862 /* Carry in, no carry out */
581e13c1 863
c5aa993b
JM
864 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
865 octa2 = (MID_TWO & *p) >> 3;
866 octa3 = (LOW_TWO & *p);
867 carry = 0;
868 fprintf_filtered (stream, "%o", octa1);
869 fprintf_filtered (stream, "%o", octa2);
870 fprintf_filtered (stream, "%o", octa3);
871 break;
872
873 default:
8a3fe4f8 874 error (_("Internal error in octal conversion;"));
c5aa993b
JM
875 }
876
877 cycle++;
878 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
879 }
880 }
881
c906108c
SS
882}
883
884/* VALADDR points to an integer of LEN bytes.
581e13c1
MS
885 Print it in decimal on stream or format it in buf. */
886
c906108c 887void
fc1a4b47 888print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 889 unsigned len, enum bfd_endian byte_order)
c906108c
SS
890{
891#define TEN 10
c5aa993b 892#define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
c906108c
SS
893#define CARRY_LEFT( x ) ((x) % TEN)
894#define SHIFT( x ) ((x) << 4)
c906108c
SS
895#define LOW_NIBBLE( x ) ( (x) & 0x00F)
896#define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
897
fc1a4b47 898 const gdb_byte *p;
c906108c 899 unsigned char *digits;
c5aa993b
JM
900 int carry;
901 int decimal_len;
902 int i, j, decimal_digits;
903 int dummy;
904 int flip;
905
c906108c 906 /* Base-ten number is less than twice as many digits
581e13c1
MS
907 as the base 16 number, which is 2 digits per byte. */
908
c906108c 909 decimal_len = len * 2 * 2;
3c37485b 910 digits = xmalloc (decimal_len);
c906108c 911
c5aa993b
JM
912 for (i = 0; i < decimal_len; i++)
913 {
c906108c 914 digits[i] = 0;
c5aa993b 915 }
c906108c 916
c906108c
SS
917 /* Ok, we have an unknown number of bytes of data to be printed in
918 * decimal.
919 *
920 * Given a hex number (in nibbles) as XYZ, we start by taking X and
921 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
922 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
923 *
924 * The trick is that "digits" holds a base-10 number, but sometimes
581e13c1 925 * the individual digits are > 10.
c906108c
SS
926 *
927 * Outer loop is per nibble (hex digit) of input, from MSD end to
928 * LSD end.
929 */
c5aa993b 930 decimal_digits = 0; /* Number of decimal digits so far */
d44e8473 931 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
c906108c 932 flip = 0;
d44e8473 933 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
c5aa993b 934 {
c906108c
SS
935 /*
936 * Multiply current base-ten number by 16 in place.
937 * Each digit was between 0 and 9, now is between
938 * 0 and 144.
939 */
c5aa993b
JM
940 for (j = 0; j < decimal_digits; j++)
941 {
942 digits[j] = SHIFT (digits[j]);
943 }
944
c906108c
SS
945 /* Take the next nibble off the input and add it to what
946 * we've got in the LSB position. Bottom 'digit' is now
947 * between 0 and 159.
948 *
949 * "flip" is used to run this loop twice for each byte.
950 */
c5aa993b
JM
951 if (flip == 0)
952 {
581e13c1
MS
953 /* Take top nibble. */
954
c5aa993b
JM
955 digits[0] += HIGH_NIBBLE (*p);
956 flip = 1;
957 }
958 else
959 {
581e13c1
MS
960 /* Take low nibble and bump our pointer "p". */
961
c5aa993b 962 digits[0] += LOW_NIBBLE (*p);
d44e8473
MD
963 if (byte_order == BFD_ENDIAN_BIG)
964 p++;
965 else
966 p--;
c5aa993b
JM
967 flip = 0;
968 }
c906108c
SS
969
970 /* Re-decimalize. We have to do this often enough
971 * that we don't overflow, but once per nibble is
972 * overkill. Easier this way, though. Note that the
973 * carry is often larger than 10 (e.g. max initial
974 * carry out of lowest nibble is 15, could bubble all
975 * the way up greater than 10). So we have to do
976 * the carrying beyond the last current digit.
977 */
978 carry = 0;
c5aa993b
JM
979 for (j = 0; j < decimal_len - 1; j++)
980 {
981 digits[j] += carry;
982
983 /* "/" won't handle an unsigned char with
984 * a value that if signed would be negative.
985 * So extend to longword int via "dummy".
986 */
987 dummy = digits[j];
988 carry = CARRY_OUT (dummy);
989 digits[j] = CARRY_LEFT (dummy);
990
991 if (j >= decimal_digits && carry == 0)
992 {
993 /*
994 * All higher digits are 0 and we
995 * no longer have a carry.
996 *
997 * Note: "j" is 0-based, "decimal_digits" is
998 * 1-based.
999 */
1000 decimal_digits = j + 1;
1001 break;
1002 }
1003 }
1004 }
c906108c
SS
1005
1006 /* Ok, now "digits" is the decimal representation, with
581e13c1
MS
1007 the "decimal_digits" actual digits. Print! */
1008
c5aa993b
JM
1009 for (i = decimal_digits - 1; i >= 0; i--)
1010 {
1011 fprintf_filtered (stream, "%1d", digits[i]);
1012 }
b8c9b27d 1013 xfree (digits);
c906108c
SS
1014}
1015
1016/* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1017
6b9acc27 1018void
fc1a4b47 1019print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
d44e8473 1020 unsigned len, enum bfd_endian byte_order)
c906108c 1021{
fc1a4b47 1022 const gdb_byte *p;
c906108c
SS
1023
1024 /* FIXME: We should be not printing leading zeroes in most cases. */
1025
bb599908 1026 fputs_filtered ("0x", stream);
d44e8473 1027 if (byte_order == BFD_ENDIAN_BIG)
c906108c
SS
1028 {
1029 for (p = valaddr;
1030 p < valaddr + len;
1031 p++)
1032 {
1033 fprintf_filtered (stream, "%02x", *p);
1034 }
1035 }
1036 else
1037 {
1038 for (p = valaddr + len - 1;
1039 p >= valaddr;
1040 p--)
1041 {
1042 fprintf_filtered (stream, "%02x", *p);
1043 }
1044 }
c906108c
SS
1045}
1046
3e43a32a 1047/* VALADDR points to a char integer of LEN bytes.
581e13c1 1048 Print it out in appropriate language form on stream.
6b9acc27
JJ
1049 Omit any leading zero chars. */
1050
1051void
6c7a06a3
TT
1052print_char_chars (struct ui_file *stream, struct type *type,
1053 const gdb_byte *valaddr,
d44e8473 1054 unsigned len, enum bfd_endian byte_order)
6b9acc27 1055{
fc1a4b47 1056 const gdb_byte *p;
6b9acc27 1057
d44e8473 1058 if (byte_order == BFD_ENDIAN_BIG)
6b9acc27
JJ
1059 {
1060 p = valaddr;
1061 while (p < valaddr + len - 1 && *p == 0)
1062 ++p;
1063
1064 while (p < valaddr + len)
1065 {
6c7a06a3 1066 LA_EMIT_CHAR (*p, type, stream, '\'');
6b9acc27
JJ
1067 ++p;
1068 }
1069 }
1070 else
1071 {
1072 p = valaddr + len - 1;
1073 while (p > valaddr && *p == 0)
1074 --p;
1075
1076 while (p >= valaddr)
1077 {
6c7a06a3 1078 LA_EMIT_CHAR (*p, type, stream, '\'');
6b9acc27
JJ
1079 --p;
1080 }
1081 }
1082}
1083
79a45b7d 1084/* Print on STREAM using the given OPTIONS the index for the element
e79af960
JB
1085 at INDEX of an array whose index type is INDEX_TYPE. */
1086
1087void
1088maybe_print_array_index (struct type *index_type, LONGEST index,
79a45b7d
TT
1089 struct ui_file *stream,
1090 const struct value_print_options *options)
e79af960
JB
1091{
1092 struct value *index_value;
1093
79a45b7d 1094 if (!options->print_array_indexes)
e79af960
JB
1095 return;
1096
1097 index_value = value_from_longest (index_type, index);
1098
79a45b7d
TT
1099 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1100}
e79af960 1101
c906108c 1102/* Called by various <lang>_val_print routines to print elements of an
c5aa993b 1103 array in the form "<elem1>, <elem2>, <elem3>, ...".
c906108c 1104
c5aa993b
JM
1105 (FIXME?) Assumes array element separator is a comma, which is correct
1106 for all languages currently handled.
1107 (FIXME?) Some languages have a notation for repeated array elements,
581e13c1 1108 perhaps we should try to use that notation when appropriate. */
c906108c
SS
1109
1110void
fc1a4b47 1111val_print_array_elements (struct type *type, const gdb_byte *valaddr,
a2bd3dcd 1112 CORE_ADDR address, struct ui_file *stream,
79a45b7d 1113 int recurse,
0e03807e 1114 const struct value *val,
79a45b7d 1115 const struct value_print_options *options,
fba45db2 1116 unsigned int i)
c906108c
SS
1117{
1118 unsigned int things_printed = 0;
1119 unsigned len;
e79af960 1120 struct type *elttype, *index_type;
c906108c
SS
1121 unsigned eltlen;
1122 /* Position of the array element we are examining to see
1123 whether it is repeated. */
1124 unsigned int rep1;
1125 /* Number of repetitions we have detected so far. */
1126 unsigned int reps;
dbc98a8b 1127 LONGEST low_bound, high_bound;
c5aa993b 1128
c906108c
SS
1129 elttype = TYPE_TARGET_TYPE (type);
1130 eltlen = TYPE_LENGTH (check_typedef (elttype));
e79af960 1131 index_type = TYPE_INDEX_TYPE (type);
c906108c 1132
dbc98a8b 1133 if (get_array_bounds (type, &low_bound, &high_bound))
75be741b
JB
1134 {
1135 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1136 But we have to be a little extra careful, because some languages
1137 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1138 empty arrays. In that situation, the array length is just zero,
1139 not negative! */
1140 if (low_bound > high_bound)
1141 len = 0;
1142 else
1143 len = high_bound - low_bound + 1;
1144 }
e936309c
JB
1145 else
1146 {
dbc98a8b
KW
1147 warning (_("unable to get bounds of array, assuming null array"));
1148 low_bound = 0;
1149 len = 0;
168de233
JB
1150 }
1151
c906108c
SS
1152 annotate_array_section_begin (i, elttype);
1153
79a45b7d 1154 for (; i < len && things_printed < options->print_max; i++)
c906108c
SS
1155 {
1156 if (i != 0)
1157 {
79a45b7d 1158 if (options->prettyprint_arrays)
c906108c
SS
1159 {
1160 fprintf_filtered (stream, ",\n");
1161 print_spaces_filtered (2 + 2 * recurse, stream);
1162 }
1163 else
1164 {
1165 fprintf_filtered (stream, ", ");
1166 }
1167 }
1168 wrap_here (n_spaces (2 + 2 * recurse));
dbc98a8b 1169 maybe_print_array_index (index_type, i + low_bound,
79a45b7d 1170 stream, options);
c906108c
SS
1171
1172 rep1 = i + 1;
1173 reps = 1;
c5aa993b 1174 while ((rep1 < len) &&
c906108c
SS
1175 !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1176 {
1177 ++reps;
1178 ++rep1;
1179 }
1180
79a45b7d 1181 if (reps > options->repeat_count_threshold)
c906108c 1182 {
f9e31323 1183 val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
0e03807e 1184 stream, recurse + 1, val, options, current_language);
c906108c
SS
1185 annotate_elt_rep (reps);
1186 fprintf_filtered (stream, " <repeats %u times>", reps);
1187 annotate_elt_rep_end ();
1188
1189 i = rep1 - 1;
79a45b7d 1190 things_printed += options->repeat_count_threshold;
c906108c
SS
1191 }
1192 else
1193 {
f9e31323 1194 val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
0e03807e 1195 stream, recurse + 1, val, options, current_language);
c906108c
SS
1196 annotate_elt ();
1197 things_printed++;
1198 }
1199 }
1200 annotate_array_section_end ();
1201 if (i < len)
1202 {
1203 fprintf_filtered (stream, "...");
1204 }
1205}
1206
917317f4
JM
1207/* Read LEN bytes of target memory at address MEMADDR, placing the
1208 results in GDB's memory at MYADDR. Returns a count of the bytes
1209 actually read, and optionally an errno value in the location
581e13c1 1210 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
917317f4
JM
1211
1212/* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1213 function be eliminated. */
1214
1215static int
3e43a32a
MS
1216partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
1217 int len, int *errnoptr)
917317f4 1218{
581e13c1
MS
1219 int nread; /* Number of bytes actually read. */
1220 int errcode; /* Error from last read. */
917317f4 1221
581e13c1 1222 /* First try a complete read. */
917317f4
JM
1223 errcode = target_read_memory (memaddr, myaddr, len);
1224 if (errcode == 0)
1225 {
581e13c1 1226 /* Got it all. */
917317f4
JM
1227 nread = len;
1228 }
1229 else
1230 {
581e13c1 1231 /* Loop, reading one byte at a time until we get as much as we can. */
917317f4
JM
1232 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1233 {
1234 errcode = target_read_memory (memaddr++, myaddr++, 1);
1235 }
581e13c1 1236 /* If an error, the last read was unsuccessful, so adjust count. */
917317f4
JM
1237 if (errcode != 0)
1238 {
1239 nread--;
1240 }
1241 }
1242 if (errnoptr != NULL)
1243 {
1244 *errnoptr = errcode;
1245 }
1246 return (nread);
1247}
1248
ae6a3a4c
TJB
1249/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1250 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1251 allocated buffer containing the string, which the caller is responsible to
1252 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1253 success, or errno on failure.
1254
1255 If LEN > 0, reads exactly LEN characters (including eventual NULs in
1256 the middle or end of the string). If LEN is -1, stops at the first
1257 null character (not necessarily the first null byte) up to a maximum
1258 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many
1259 characters as possible from the string.
1260
1261 Unless an exception is thrown, BUFFER will always be allocated, even on
1262 failure. In this case, some characters might have been read before the
1263 failure happened. Check BYTES_READ to recognize this situation.
1264
1265 Note: There was a FIXME asking to make this code use target_read_string,
1266 but this function is more general (can read past null characters, up to
581e13c1 1267 given LEN). Besides, it is used much more often than target_read_string
ae6a3a4c
TJB
1268 so it is more tested. Perhaps callers of target_read_string should use
1269 this function instead? */
c906108c
SS
1270
1271int
ae6a3a4c 1272read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
e17a4113 1273 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
c906108c 1274{
ae6a3a4c
TJB
1275 int found_nul; /* Non-zero if we found the nul char. */
1276 int errcode; /* Errno returned from bad reads. */
1277 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1278 unsigned int chunksize; /* Size of each fetch, in chars. */
3e43a32a
MS
1279 gdb_byte *bufptr; /* Pointer to next available byte in
1280 buffer. */
ae6a3a4c
TJB
1281 gdb_byte *limit; /* First location past end of fetch buffer. */
1282 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1283
1284 /* Decide how large of chunks to try to read in one operation. This
c906108c
SS
1285 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1286 so we might as well read them all in one operation. If LEN is -1, we
ae6a3a4c 1287 are looking for a NUL terminator to end the fetching, so we might as
c906108c
SS
1288 well read in blocks that are large enough to be efficient, but not so
1289 large as to be slow if fetchlimit happens to be large. So we choose the
1290 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1291 200 is way too big for remote debugging over a serial line. */
1292
1293 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1294
ae6a3a4c
TJB
1295 /* Loop until we either have all the characters, or we encounter
1296 some error, such as bumping into the end of the address space. */
c906108c
SS
1297
1298 found_nul = 0;
b5096abe
PM
1299 *buffer = NULL;
1300
1301 old_chain = make_cleanup (free_current_contents, buffer);
c906108c
SS
1302
1303 if (len > 0)
1304 {
ae6a3a4c
TJB
1305 *buffer = (gdb_byte *) xmalloc (len * width);
1306 bufptr = *buffer;
c906108c 1307
917317f4 1308 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
c906108c
SS
1309 / width;
1310 addr += nfetch * width;
1311 bufptr += nfetch * width;
1312 }
1313 else if (len == -1)
1314 {
1315 unsigned long bufsize = 0;
ae6a3a4c 1316
c906108c
SS
1317 do
1318 {
1319 QUIT;
1320 nfetch = min (chunksize, fetchlimit - bufsize);
1321
ae6a3a4c
TJB
1322 if (*buffer == NULL)
1323 *buffer = (gdb_byte *) xmalloc (nfetch * width);
c906108c 1324 else
b5096abe
PM
1325 *buffer = (gdb_byte *) xrealloc (*buffer,
1326 (nfetch + bufsize) * width);
c906108c 1327
ae6a3a4c 1328 bufptr = *buffer + bufsize * width;
c906108c
SS
1329 bufsize += nfetch;
1330
ae6a3a4c 1331 /* Read as much as we can. */
917317f4 1332 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
ae6a3a4c 1333 / width;
c906108c 1334
ae6a3a4c 1335 /* Scan this chunk for the null character that terminates the string
c906108c
SS
1336 to print. If found, we don't need to fetch any more. Note
1337 that bufptr is explicitly left pointing at the next character
ae6a3a4c
TJB
1338 after the null character, or at the next character after the end
1339 of the buffer. */
c906108c
SS
1340
1341 limit = bufptr + nfetch * width;
1342 while (bufptr < limit)
1343 {
1344 unsigned long c;
1345
e17a4113 1346 c = extract_unsigned_integer (bufptr, width, byte_order);
c906108c
SS
1347 addr += width;
1348 bufptr += width;
1349 if (c == 0)
1350 {
1351 /* We don't care about any error which happened after
ae6a3a4c 1352 the NUL terminator. */
c906108c
SS
1353 errcode = 0;
1354 found_nul = 1;
1355 break;
1356 }
1357 }
1358 }
c5aa993b 1359 while (errcode == 0 /* no error */
ae6a3a4c
TJB
1360 && bufptr - *buffer < fetchlimit * width /* no overrun */
1361 && !found_nul); /* haven't found NUL yet */
c906108c
SS
1362 }
1363 else
ae6a3a4c
TJB
1364 { /* Length of string is really 0! */
1365 /* We always allocate *buffer. */
1366 *buffer = bufptr = xmalloc (1);
c906108c
SS
1367 errcode = 0;
1368 }
1369
1370 /* bufptr and addr now point immediately beyond the last byte which we
1371 consider part of the string (including a '\0' which ends the string). */
ae6a3a4c
TJB
1372 *bytes_read = bufptr - *buffer;
1373
1374 QUIT;
1375
1376 discard_cleanups (old_chain);
1377
1378 return errcode;
1379}
1380
1381/* Print a string from the inferior, starting at ADDR and printing up to LEN
1382 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1383 stops at the first null byte, otherwise printing proceeds (including null
1384 bytes) until either print_max or LEN characters have been printed,
09ca9e2e
TT
1385 whichever is smaller. ENCODING is the name of the string's
1386 encoding. It can be NULL, in which case the target encoding is
1387 assumed. */
ae6a3a4c
TJB
1388
1389int
09ca9e2e
TT
1390val_print_string (struct type *elttype, const char *encoding,
1391 CORE_ADDR addr, int len,
6c7a06a3 1392 struct ui_file *stream,
ae6a3a4c
TJB
1393 const struct value_print_options *options)
1394{
1395 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
1396 int errcode; /* Errno returned from bad reads. */
581e13c1 1397 int found_nul; /* Non-zero if we found the nul char. */
ae6a3a4c
TJB
1398 unsigned int fetchlimit; /* Maximum number of chars to print. */
1399 int bytes_read;
1400 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
1401 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
5af949e3 1402 struct gdbarch *gdbarch = get_type_arch (elttype);
e17a4113 1403 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
6c7a06a3 1404 int width = TYPE_LENGTH (elttype);
ae6a3a4c
TJB
1405
1406 /* First we need to figure out the limit on the number of characters we are
1407 going to attempt to fetch and print. This is actually pretty simple. If
1408 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1409 LEN is -1, then the limit is print_max. This is true regardless of
1410 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1411 because finding the null byte (or available memory) is what actually
1412 limits the fetch. */
1413
3e43a32a
MS
1414 fetchlimit = (len == -1 ? options->print_max : min (len,
1415 options->print_max));
ae6a3a4c 1416
e17a4113
UW
1417 errcode = read_string (addr, len, width, fetchlimit, byte_order,
1418 &buffer, &bytes_read);
ae6a3a4c
TJB
1419 old_chain = make_cleanup (xfree, buffer);
1420
1421 addr += bytes_read;
c906108c 1422
3e43a32a
MS
1423 /* We now have either successfully filled the buffer to fetchlimit,
1424 or terminated early due to an error or finding a null char when
1425 LEN is -1. */
ae6a3a4c
TJB
1426
1427 /* Determine found_nul by looking at the last character read. */
e17a4113
UW
1428 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
1429 byte_order) == 0;
c906108c
SS
1430 if (len == -1 && !found_nul)
1431 {
777ea8f1 1432 gdb_byte *peekbuf;
c906108c 1433
ae6a3a4c 1434 /* We didn't find a NUL terminator we were looking for. Attempt
c5aa993b
JM
1435 to peek at the next character. If not successful, or it is not
1436 a null byte, then force ellipsis to be printed. */
c906108c 1437
777ea8f1 1438 peekbuf = (gdb_byte *) alloca (width);
c906108c
SS
1439
1440 if (target_read_memory (addr, peekbuf, width) == 0
e17a4113 1441 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
c906108c
SS
1442 force_ellipsis = 1;
1443 }
ae6a3a4c 1444 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
c906108c
SS
1445 {
1446 /* Getting an error when we have a requested length, or fetching less
c5aa993b 1447 than the number of characters actually requested, always make us
ae6a3a4c 1448 print ellipsis. */
c906108c
SS
1449 force_ellipsis = 1;
1450 }
1451
c906108c
SS
1452 /* If we get an error before fetching anything, don't print a string.
1453 But if we fetch something and then get an error, print the string
1454 and then the error message. */
ae6a3a4c 1455 if (errcode == 0 || bytes_read > 0)
c906108c 1456 {
79a45b7d 1457 if (options->addressprint)
c906108c
SS
1458 {
1459 fputs_filtered (" ", stream);
1460 }
be759fcf 1461 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
3a772aa4 1462 encoding, force_ellipsis, options);
c906108c
SS
1463 }
1464
1465 if (errcode != 0)
1466 {
1467 if (errcode == EIO)
1468 {
1469 fprintf_filtered (stream, " <Address ");
5af949e3 1470 fputs_filtered (paddress (gdbarch, addr), stream);
c906108c
SS
1471 fprintf_filtered (stream, " out of bounds>");
1472 }
1473 else
1474 {
1475 fprintf_filtered (stream, " <Error reading address ");
5af949e3 1476 fputs_filtered (paddress (gdbarch, addr), stream);
c906108c
SS
1477 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1478 }
1479 }
ae6a3a4c 1480
c906108c
SS
1481 gdb_flush (stream);
1482 do_cleanups (old_chain);
ae6a3a4c
TJB
1483
1484 return (bytes_read / width);
c906108c 1485}
c906108c 1486\f
c5aa993b 1487
09e6485f
PA
1488/* The 'set input-radix' command writes to this auxiliary variable.
1489 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
1490 it is left unchanged. */
1491
1492static unsigned input_radix_1 = 10;
1493
c906108c
SS
1494/* Validate an input or output radix setting, and make sure the user
1495 knows what they really did here. Radix setting is confusing, e.g.
1496 setting the input radix to "10" never changes it! */
1497
c906108c 1498static void
fba45db2 1499set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
c906108c 1500{
09e6485f 1501 set_input_radix_1 (from_tty, input_radix_1);
c906108c
SS
1502}
1503
c906108c 1504static void
fba45db2 1505set_input_radix_1 (int from_tty, unsigned radix)
c906108c
SS
1506{
1507 /* We don't currently disallow any input radix except 0 or 1, which don't
1508 make any mathematical sense. In theory, we can deal with any input
1509 radix greater than 1, even if we don't have unique digits for every
1510 value from 0 to radix-1, but in practice we lose on large radix values.
1511 We should either fix the lossage or restrict the radix range more.
581e13c1 1512 (FIXME). */
c906108c
SS
1513
1514 if (radix < 2)
1515 {
09e6485f 1516 input_radix_1 = input_radix;
8a3fe4f8 1517 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
c906108c
SS
1518 radix);
1519 }
09e6485f 1520 input_radix_1 = input_radix = radix;
c906108c
SS
1521 if (from_tty)
1522 {
3e43a32a
MS
1523 printf_filtered (_("Input radix now set to "
1524 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
1525 radix, radix, radix);
1526 }
1527}
1528
09e6485f
PA
1529/* The 'set output-radix' command writes to this auxiliary variable.
1530 If the requested radix is valid, OUTPUT_RADIX is updated,
1531 otherwise, it is left unchanged. */
1532
1533static unsigned output_radix_1 = 10;
1534
c906108c 1535static void
fba45db2 1536set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
c906108c 1537{
09e6485f 1538 set_output_radix_1 (from_tty, output_radix_1);
c906108c
SS
1539}
1540
1541static void
fba45db2 1542set_output_radix_1 (int from_tty, unsigned radix)
c906108c
SS
1543{
1544 /* Validate the radix and disallow ones that we aren't prepared to
581e13c1 1545 handle correctly, leaving the radix unchanged. */
c906108c
SS
1546 switch (radix)
1547 {
1548 case 16:
79a45b7d 1549 user_print_options.output_format = 'x'; /* hex */
c906108c
SS
1550 break;
1551 case 10:
79a45b7d 1552 user_print_options.output_format = 0; /* decimal */
c906108c
SS
1553 break;
1554 case 8:
79a45b7d 1555 user_print_options.output_format = 'o'; /* octal */
c906108c
SS
1556 break;
1557 default:
09e6485f 1558 output_radix_1 = output_radix;
3e43a32a
MS
1559 error (_("Unsupported output radix ``decimal %u''; "
1560 "output radix unchanged."),
c906108c
SS
1561 radix);
1562 }
09e6485f 1563 output_radix_1 = output_radix = radix;
c906108c
SS
1564 if (from_tty)
1565 {
3e43a32a
MS
1566 printf_filtered (_("Output radix now set to "
1567 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
1568 radix, radix, radix);
1569 }
1570}
1571
1572/* Set both the input and output radix at once. Try to set the output radix
1573 first, since it has the most restrictive range. An radix that is valid as
1574 an output radix is also valid as an input radix.
1575
1576 It may be useful to have an unusual input radix. If the user wishes to
1577 set an input radix that is not valid as an output radix, he needs to use
581e13c1 1578 the 'set input-radix' command. */
c906108c
SS
1579
1580static void
fba45db2 1581set_radix (char *arg, int from_tty)
c906108c
SS
1582{
1583 unsigned radix;
1584
bb518678 1585 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
c906108c
SS
1586 set_output_radix_1 (0, radix);
1587 set_input_radix_1 (0, radix);
1588 if (from_tty)
1589 {
3e43a32a
MS
1590 printf_filtered (_("Input and output radices now set to "
1591 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
1592 radix, radix, radix);
1593 }
1594}
1595
581e13c1 1596/* Show both the input and output radices. */
c906108c 1597
c906108c 1598static void
fba45db2 1599show_radix (char *arg, int from_tty)
c906108c
SS
1600{
1601 if (from_tty)
1602 {
1603 if (input_radix == output_radix)
1604 {
3e43a32a
MS
1605 printf_filtered (_("Input and output radices set to "
1606 "decimal %u, hex %x, octal %o.\n"),
c906108c
SS
1607 input_radix, input_radix, input_radix);
1608 }
1609 else
1610 {
3e43a32a
MS
1611 printf_filtered (_("Input radix set to decimal "
1612 "%u, hex %x, octal %o.\n"),
c906108c 1613 input_radix, input_radix, input_radix);
3e43a32a
MS
1614 printf_filtered (_("Output radix set to decimal "
1615 "%u, hex %x, octal %o.\n"),
c906108c
SS
1616 output_radix, output_radix, output_radix);
1617 }
1618 }
1619}
c906108c 1620\f
c5aa993b 1621
c906108c 1622static void
fba45db2 1623set_print (char *arg, int from_tty)
c906108c
SS
1624{
1625 printf_unfiltered (
c5aa993b 1626 "\"set print\" must be followed by the name of a print subcommand.\n");
c906108c
SS
1627 help_list (setprintlist, "set print ", -1, gdb_stdout);
1628}
1629
c906108c 1630static void
fba45db2 1631show_print (char *args, int from_tty)
c906108c
SS
1632{
1633 cmd_show_list (showprintlist, from_tty, "");
1634}
1635\f
1636void
fba45db2 1637_initialize_valprint (void)
c906108c 1638{
c906108c 1639 add_prefix_cmd ("print", no_class, set_print,
1bedd215 1640 _("Generic command for setting how things print."),
c906108c 1641 &setprintlist, "set print ", 0, &setlist);
c5aa993b 1642 add_alias_cmd ("p", "print", no_class, 1, &setlist);
581e13c1 1643 /* Prefer set print to set prompt. */
c906108c
SS
1644 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1645
1646 add_prefix_cmd ("print", no_class, show_print,
1bedd215 1647 _("Generic command for showing print settings."),
c906108c 1648 &showprintlist, "show print ", 0, &showlist);
c5aa993b
JM
1649 add_alias_cmd ("p", "print", no_class, 1, &showlist);
1650 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
c906108c 1651
79a45b7d
TT
1652 add_setshow_uinteger_cmd ("elements", no_class,
1653 &user_print_options.print_max, _("\
35096d9d
AC
1654Set limit on string chars or array elements to print."), _("\
1655Show limit on string chars or array elements to print."), _("\
1656\"set print elements 0\" causes there to be no limit."),
1657 NULL,
920d2a44 1658 show_print_max,
35096d9d 1659 &setprintlist, &showprintlist);
c906108c 1660
79a45b7d
TT
1661 add_setshow_boolean_cmd ("null-stop", no_class,
1662 &user_print_options.stop_print_at_null, _("\
5bf193a2
AC
1663Set printing of char arrays to stop at first null char."), _("\
1664Show printing of char arrays to stop at first null char."), NULL,
1665 NULL,
920d2a44 1666 show_stop_print_at_null,
5bf193a2 1667 &setprintlist, &showprintlist);
c906108c 1668
35096d9d 1669 add_setshow_uinteger_cmd ("repeats", no_class,
79a45b7d 1670 &user_print_options.repeat_count_threshold, _("\
35096d9d
AC
1671Set threshold for repeated print elements."), _("\
1672Show threshold for repeated print elements."), _("\
1673\"set print repeats 0\" causes all elements to be individually printed."),
1674 NULL,
920d2a44 1675 show_repeat_count_threshold,
35096d9d 1676 &setprintlist, &showprintlist);
c906108c 1677
79a45b7d
TT
1678 add_setshow_boolean_cmd ("pretty", class_support,
1679 &user_print_options.prettyprint_structs, _("\
5bf193a2
AC
1680Set prettyprinting of structures."), _("\
1681Show prettyprinting of structures."), NULL,
1682 NULL,
920d2a44 1683 show_prettyprint_structs,
5bf193a2
AC
1684 &setprintlist, &showprintlist);
1685
79a45b7d
TT
1686 add_setshow_boolean_cmd ("union", class_support,
1687 &user_print_options.unionprint, _("\
5bf193a2
AC
1688Set printing of unions interior to structures."), _("\
1689Show printing of unions interior to structures."), NULL,
1690 NULL,
920d2a44 1691 show_unionprint,
5bf193a2
AC
1692 &setprintlist, &showprintlist);
1693
79a45b7d
TT
1694 add_setshow_boolean_cmd ("array", class_support,
1695 &user_print_options.prettyprint_arrays, _("\
5bf193a2
AC
1696Set prettyprinting of arrays."), _("\
1697Show prettyprinting of arrays."), NULL,
1698 NULL,
920d2a44 1699 show_prettyprint_arrays,
5bf193a2
AC
1700 &setprintlist, &showprintlist);
1701
79a45b7d
TT
1702 add_setshow_boolean_cmd ("address", class_support,
1703 &user_print_options.addressprint, _("\
5bf193a2
AC
1704Set printing of addresses."), _("\
1705Show printing of addresses."), NULL,
1706 NULL,
920d2a44 1707 show_addressprint,
5bf193a2 1708 &setprintlist, &showprintlist);
c906108c 1709
1e8fb976
PA
1710 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
1711 _("\
35096d9d
AC
1712Set default input radix for entering numbers."), _("\
1713Show default input radix for entering numbers."), NULL,
1e8fb976
PA
1714 set_input_radix,
1715 show_input_radix,
1716 &setlist, &showlist);
35096d9d 1717
1e8fb976
PA
1718 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
1719 _("\
35096d9d
AC
1720Set default output radix for printing of values."), _("\
1721Show default output radix for printing of values."), NULL,
1e8fb976
PA
1722 set_output_radix,
1723 show_output_radix,
1724 &setlist, &showlist);
c906108c 1725
cb1a6d5f
AC
1726 /* The "set radix" and "show radix" commands are special in that
1727 they are like normal set and show commands but allow two normally
1728 independent variables to be either set or shown with a single
b66df561 1729 command. So the usual deprecated_add_set_cmd() and [deleted]
581e13c1 1730 add_show_from_set() commands aren't really appropriate. */
b66df561
AC
1731 /* FIXME: i18n: With the new add_setshow_integer command, that is no
1732 longer true - show can display anything. */
1a966eab
AC
1733 add_cmd ("radix", class_support, set_radix, _("\
1734Set default input and output number radices.\n\
c906108c 1735Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1a966eab 1736Without an argument, sets both radices back to the default value of 10."),
c906108c 1737 &setlist);
1a966eab
AC
1738 add_cmd ("radix", class_support, show_radix, _("\
1739Show the default input and output number radices.\n\
1740Use 'show input-radix' or 'show output-radix' to independently show each."),
c906108c
SS
1741 &showlist);
1742
e79af960 1743 add_setshow_boolean_cmd ("array-indexes", class_support,
79a45b7d 1744 &user_print_options.print_array_indexes, _("\
e79af960
JB
1745Set printing of array indexes."), _("\
1746Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
1747 &setprintlist, &showprintlist);
c906108c 1748}
This page took 1.188237 seconds and 4 git commands to generate.