Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / printcmd.c
CommitLineData
5796c8dc
SS
1/* Print values for GNU debugger GDB.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "gdb_string.h"
22#include "frame.h"
23#include "symtab.h"
24#include "gdbtypes.h"
25#include "value.h"
26#include "language.h"
27#include "expression.h"
28#include "gdbcore.h"
29#include "gdbcmd.h"
30#include "target.h"
31#include "breakpoint.h"
32#include "demangle.h"
a45ae5f8 33#include "gdb-demangle.h"
5796c8dc
SS
34#include "valprint.h"
35#include "annotate.h"
36#include "symfile.h" /* for overlay functions */
37#include "objfiles.h" /* ditto */
38#include "completer.h" /* for completion functions */
39#include "ui-out.h"
40#include "gdb_assert.h"
41#include "block.h"
42#include "disasm.h"
43#include "dfp.h"
44#include "valprint.h"
45#include "exceptions.h"
46#include "observer.h"
47#include "solist.h"
5796c8dc
SS
48#include "parser-defs.h"
49#include "charset.h"
cf7f2e2d 50#include "arch-utils.h"
c50c785c 51#include "cli/cli-utils.h"
ef5ccd6c
JM
52#include "format.h"
53#include "source.h"
5796c8dc
SS
54
55#ifdef TUI
c50c785c 56#include "tui/tui.h" /* For tui_active et al. */
5796c8dc
SS
57#endif
58
5796c8dc
SS
59struct format_data
60 {
61 int count;
62 char format;
63 char size;
64
65 /* True if the value should be printed raw -- that is, bypassing
66 python-based formatters. */
67 unsigned char raw;
68 };
69
70/* Last specified output format. */
71
72static char last_format = 0;
73
74/* Last specified examination size. 'b', 'h', 'w' or `q'. */
75
76static char last_size = 'w';
77
78/* Default address to examine next, and associated architecture. */
79
80static struct gdbarch *next_gdbarch;
81static CORE_ADDR next_address;
82
83/* Number of delay instructions following current disassembled insn. */
84
85static int branch_delay_insns;
86
87/* Last address examined. */
88
89static CORE_ADDR last_examine_address;
90
91/* Contents of last address examined.
92 This is not valid past the end of the `x' command! */
93
94static struct value *last_examine_value;
95
96/* Largest offset between a symbolic value and an address, that will be
97 printed as `0x1234 <symbol+offset>'. */
98
99static unsigned int max_symbolic_offset = UINT_MAX;
100static void
101show_max_symbolic_offset (struct ui_file *file, int from_tty,
102 struct cmd_list_element *c, const char *value)
103{
c50c785c
JM
104 fprintf_filtered (file,
105 _("The largest offset that will be "
106 "printed in <symbol+1234> form is %s.\n"),
5796c8dc
SS
107 value);
108}
109
110/* Append the source filename and linenumber of the symbol when
111 printing a symbolic value as `<symbol at filename:linenum>' if set. */
112static int print_symbol_filename = 0;
113static void
114show_print_symbol_filename (struct ui_file *file, int from_tty,
115 struct cmd_list_element *c, const char *value)
116{
c50c785c
JM
117 fprintf_filtered (file, _("Printing of source filename and "
118 "line number with <symbol> is %s.\n"),
5796c8dc
SS
119 value);
120}
121
122/* Number of auto-display expression currently being displayed.
a45ae5f8 123 So that we can disable it if we get a signal within it.
5796c8dc
SS
124 -1 when not doing one. */
125
ef5ccd6c 126static int current_display_number;
5796c8dc
SS
127
128struct display
129 {
130 /* Chain link to next auto-display item. */
131 struct display *next;
cf7f2e2d 132
5796c8dc
SS
133 /* The expression as the user typed it. */
134 char *exp_string;
cf7f2e2d 135
5796c8dc
SS
136 /* Expression to be evaluated and displayed. */
137 struct expression *exp;
cf7f2e2d 138
5796c8dc
SS
139 /* Item number of this auto-display item. */
140 int number;
cf7f2e2d 141
5796c8dc
SS
142 /* Display format specified. */
143 struct format_data format;
cf7f2e2d
JM
144
145 /* Program space associated with `block'. */
146 struct program_space *pspace;
147
c50c785c 148 /* Innermost block required by this expression when evaluated. */
ef5ccd6c 149 const struct block *block;
cf7f2e2d 150
c50c785c 151 /* Status of this display (enabled or disabled). */
5796c8dc
SS
152 int enabled_p;
153 };
154
155/* Chain of expressions whose values should be displayed
156 automatically each time the program stops. */
157
158static struct display *display_chain;
159
160static int display_number;
161
c50c785c
JM
162/* Walk the following statement or block through all displays.
163 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
164 display. */
165
166#define ALL_DISPLAYS(B) \
167 for (B = display_chain; B; B = B->next)
168
169#define ALL_DISPLAYS_SAFE(B,TMP) \
170 for (B = display_chain; \
171 B ? (TMP = B->next, 1): 0; \
172 B = TMP)
173
174/* Prototypes for exported functions. */
5796c8dc 175
5796c8dc
SS
176void _initialize_printcmd (void);
177
c50c785c 178/* Prototypes for local functions. */
5796c8dc
SS
179
180static void do_one_display (struct display *);
181\f
182
183/* Decode a format specification. *STRING_PTR should point to it.
184 OFORMAT and OSIZE are used as defaults for the format and size
185 if none are given in the format specification.
186 If OSIZE is zero, then the size field of the returned value
187 should be set only if a size is explicitly specified by the
188 user.
189 The structure returned describes all the data
190 found in the specification. In addition, *STRING_PTR is advanced
191 past the specification and past all whitespace following it. */
192
193static struct format_data
194decode_format (char **string_ptr, int oformat, int osize)
195{
196 struct format_data val;
197 char *p = *string_ptr;
198
199 val.format = '?';
200 val.size = '?';
201 val.count = 1;
202 val.raw = 0;
203
204 if (*p >= '0' && *p <= '9')
205 val.count = atoi (p);
206 while (*p >= '0' && *p <= '9')
207 p++;
208
209 /* Now process size or format letters that follow. */
210
211 while (1)
212 {
213 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
214 val.size = *p++;
215 else if (*p == 'r')
216 {
217 val.raw = 1;
218 p++;
219 }
220 else if (*p >= 'a' && *p <= 'z')
221 val.format = *p++;
222 else
223 break;
224 }
225
226 while (*p == ' ' || *p == '\t')
227 p++;
228 *string_ptr = p;
229
230 /* Set defaults for format and size if not specified. */
231 if (val.format == '?')
232 {
233 if (val.size == '?')
234 {
235 /* Neither has been specified. */
236 val.format = oformat;
237 val.size = osize;
238 }
239 else
240 /* If a size is specified, any format makes a reasonable
241 default except 'i'. */
242 val.format = oformat == 'i' ? 'x' : oformat;
243 }
244 else if (val.size == '?')
245 switch (val.format)
246 {
247 case 'a':
248 /* Pick the appropriate size for an address. This is deferred
249 until do_examine when we know the actual architecture to use.
250 A special size value of 'a' is used to indicate this case. */
251 val.size = osize ? 'a' : osize;
252 break;
253 case 'f':
254 /* Floating point has to be word or giantword. */
255 if (osize == 'w' || osize == 'g')
256 val.size = osize;
257 else
258 /* Default it to giantword if the last used size is not
259 appropriate. */
260 val.size = osize ? 'g' : osize;
261 break;
262 case 'c':
263 /* Characters default to one byte. */
264 val.size = osize ? 'b' : osize;
265 break;
cf7f2e2d 266 case 's':
c50c785c
JM
267 /* Display strings with byte size chars unless explicitly
268 specified. */
cf7f2e2d
JM
269 val.size = '\0';
270 break;
271
5796c8dc
SS
272 default:
273 /* The default is the size most recently specified. */
274 val.size = osize;
275 }
276
277 return val;
278}
279\f
280/* Print value VAL on stream according to OPTIONS.
281 Do not end with a newline.
282 SIZE is the letter for the size of datum being printed.
283 This is used to pad hex numbers so they line up. SIZE is 0
284 for print / output and set for examine. */
285
286static void
287print_formatted (struct value *val, int size,
288 const struct value_print_options *options,
289 struct ui_file *stream)
290{
291 struct type *type = check_typedef (value_type (val));
292 int len = TYPE_LENGTH (type);
293
294 if (VALUE_LVAL (val) == lval_memory)
295 next_address = value_address (val) + len;
296
297 if (size)
298 {
299 switch (options->format)
300 {
301 case 's':
302 {
303 struct type *elttype = value_type (val);
cf7f2e2d 304
5796c8dc 305 next_address = (value_address (val)
c50c785c 306 + val_print_string (elttype, NULL,
5796c8dc 307 value_address (val), -1,
cf7f2e2d 308 stream, options) * len);
5796c8dc
SS
309 }
310 return;
311
312 case 'i':
313 /* We often wrap here if there are long symbolic names. */
314 wrap_here (" ");
315 next_address = (value_address (val)
316 + gdb_print_insn (get_type_arch (type),
317 value_address (val), stream,
318 &branch_delay_insns));
319 return;
320 }
321 }
322
323 if (options->format == 0 || options->format == 's'
324 || TYPE_CODE (type) == TYPE_CODE_REF
325 || TYPE_CODE (type) == TYPE_CODE_ARRAY
326 || TYPE_CODE (type) == TYPE_CODE_STRING
327 || TYPE_CODE (type) == TYPE_CODE_STRUCT
328 || TYPE_CODE (type) == TYPE_CODE_UNION
329 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
330 value_print (val, stream, options);
331 else
c50c785c
JM
332 /* User specified format, so don't look to the type to tell us
333 what to do. */
334 val_print_scalar_formatted (type,
335 value_contents_for_printing (val),
336 value_embedded_offset (val),
337 val,
338 options, size, stream);
5796c8dc
SS
339}
340
341/* Return builtin floating point type of same length as TYPE.
342 If no such type is found, return TYPE itself. */
343static struct type *
344float_type_from_length (struct type *type)
345{
346 struct gdbarch *gdbarch = get_type_arch (type);
347 const struct builtin_type *builtin = builtin_type (gdbarch);
5796c8dc 348
ef5ccd6c 349 if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
5796c8dc 350 type = builtin->builtin_float;
ef5ccd6c 351 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
5796c8dc 352 type = builtin->builtin_double;
ef5ccd6c 353 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
5796c8dc
SS
354 type = builtin->builtin_long_double;
355
356 return type;
357}
358
359/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
c50c785c
JM
360 according to OPTIONS and SIZE on STREAM. Formats s and i are not
361 supported at this level. */
5796c8dc
SS
362
363void
364print_scalar_formatted (const void *valaddr, struct type *type,
365 const struct value_print_options *options,
366 int size, struct ui_file *stream)
367{
368 struct gdbarch *gdbarch = get_type_arch (type);
369 LONGEST val_long = 0;
370 unsigned int len = TYPE_LENGTH (type);
371 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
372
c50c785c
JM
373 /* String printing should go through val_print_scalar_formatted. */
374 gdb_assert (options->format != 's');
5796c8dc
SS
375
376 if (len > sizeof(LONGEST) &&
377 (TYPE_CODE (type) == TYPE_CODE_INT
378 || TYPE_CODE (type) == TYPE_CODE_ENUM))
379 {
380 switch (options->format)
381 {
382 case 'o':
383 print_octal_chars (stream, valaddr, len, byte_order);
384 return;
385 case 'u':
386 case 'd':
387 print_decimal_chars (stream, valaddr, len, byte_order);
388 return;
389 case 't':
390 print_binary_chars (stream, valaddr, len, byte_order);
391 return;
392 case 'x':
393 print_hex_chars (stream, valaddr, len, byte_order);
394 return;
395 case 'c':
396 print_char_chars (stream, type, valaddr, len, byte_order);
397 return;
398 default:
399 break;
400 };
401 }
402
403 if (options->format != 'f')
404 val_long = unpack_long (type, valaddr);
405
406 /* If the value is a pointer, and pointers and addresses are not the
407 same, then at this point, the value's length (in target bytes) is
408 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
409 if (TYPE_CODE (type) == TYPE_CODE_PTR)
410 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
411
412 /* If we are printing it as unsigned, truncate it in case it is actually
413 a negative signed value (e.g. "print/u (short)-1" should print 65535
414 (if shorts are 16 bits) instead of 4294967295). */
415 if (options->format != 'd' || TYPE_UNSIGNED (type))
416 {
417 if (len < sizeof (LONGEST))
418 val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
419 }
420
421 switch (options->format)
422 {
423 case 'x':
424 if (!size)
425 {
426 /* No size specified, like in print. Print varying # of digits. */
427 print_longest (stream, 'x', 1, val_long);
428 }
429 else
430 switch (size)
431 {
432 case 'b':
433 case 'h':
434 case 'w':
435 case 'g':
436 print_longest (stream, size, 1, val_long);
437 break;
438 default:
439 error (_("Undefined output size \"%c\"."), size);
440 }
441 break;
442
443 case 'd':
444 print_longest (stream, 'd', 1, val_long);
445 break;
446
447 case 'u':
448 print_longest (stream, 'u', 0, val_long);
449 break;
450
451 case 'o':
452 if (val_long)
453 print_longest (stream, 'o', 1, val_long);
454 else
455 fprintf_filtered (stream, "0");
456 break;
457
458 case 'a':
459 {
460 CORE_ADDR addr = unpack_pointer (type, valaddr);
cf7f2e2d 461
5796c8dc
SS
462 print_address (gdbarch, addr, stream);
463 }
464 break;
465
466 case 'c':
467 {
468 struct value_print_options opts = *options;
5796c8dc 469
cf7f2e2d 470 opts.format = 0;
5796c8dc
SS
471 if (TYPE_UNSIGNED (type))
472 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
473 else
474 type = builtin_type (gdbarch)->builtin_true_char;
475
476 value_print (value_from_longest (type, val_long), stream, &opts);
477 }
478 break;
479
480 case 'f':
481 type = float_type_from_length (type);
482 print_floating (valaddr, type, stream);
483 break;
484
485 case 0:
486 internal_error (__FILE__, __LINE__,
487 _("failed internal consistency check"));
488
489 case 't':
490 /* Binary; 't' stands for "two". */
491 {
492 char bits[8 * (sizeof val_long) + 1];
493 char buf[8 * (sizeof val_long) + 32];
494 char *cp = bits;
495 int width;
496
497 if (!size)
498 width = 8 * (sizeof val_long);
499 else
500 switch (size)
501 {
502 case 'b':
503 width = 8;
504 break;
505 case 'h':
506 width = 16;
507 break;
508 case 'w':
509 width = 32;
510 break;
511 case 'g':
512 width = 64;
513 break;
514 default:
515 error (_("Undefined output size \"%c\"."), size);
516 }
517
518 bits[width] = '\0';
519 while (width-- > 0)
520 {
521 bits[width] = (val_long & 1) ? '1' : '0';
522 val_long >>= 1;
523 }
524 if (!size)
525 {
526 while (*cp && *cp == '0')
527 cp++;
528 if (*cp == '\0')
529 cp--;
530 }
c50c785c 531 strncpy (buf, cp, sizeof (bits));
5796c8dc
SS
532 fputs_filtered (buf, stream);
533 }
534 break;
535
536 default:
537 error (_("Undefined output format \"%c\"."), options->format);
538 }
539}
540
541/* Specify default address for `x' command.
542 The `info lines' command uses this. */
543
544void
545set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
546{
547 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
548
549 next_gdbarch = gdbarch;
550 next_address = addr;
551
552 /* Make address available to the user as $_. */
553 set_internalvar (lookup_internalvar ("_"),
554 value_from_pointer (ptr_type, addr));
555}
556
557/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
558 after LEADIN. Print nothing if no symbolic name is found nearby.
559 Optionally also print source file and line number, if available.
560 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
561 or to interpret it as a possible C++ name and convert it back to source
562 form. However note that DO_DEMANGLE can be overridden by the specific
ef5ccd6c
JM
563 settings of the demangle and asm_demangle variables. Returns
564 non-zero if anything was printed; zero otherwise. */
5796c8dc 565
ef5ccd6c 566int
cf7f2e2d
JM
567print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
568 struct ui_file *stream,
5796c8dc
SS
569 int do_demangle, char *leadin)
570{
571 char *name = NULL;
572 char *filename = NULL;
573 int unmapped = 0;
574 int offset = 0;
575 int line = 0;
576
577 /* Throw away both name and filename. */
578 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
579 make_cleanup (free_current_contents, &filename);
580
cf7f2e2d 581 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
5796c8dc
SS
582 &filename, &line, &unmapped))
583 {
584 do_cleanups (cleanup_chain);
ef5ccd6c 585 return 0;
5796c8dc
SS
586 }
587
588 fputs_filtered (leadin, stream);
589 if (unmapped)
590 fputs_filtered ("<*", stream);
591 else
592 fputs_filtered ("<", stream);
593 fputs_filtered (name, stream);
594 if (offset != 0)
595 fprintf_filtered (stream, "+%u", (unsigned int) offset);
596
597 /* Append source filename and line number if desired. Give specific
598 line # of this addr, if we have it; else line # of the nearest symbol. */
599 if (print_symbol_filename && filename != NULL)
600 {
601 if (line != -1)
602 fprintf_filtered (stream, " at %s:%d", filename, line);
603 else
604 fprintf_filtered (stream, " in %s", filename);
605 }
606 if (unmapped)
607 fputs_filtered ("*>", stream);
608 else
609 fputs_filtered (">", stream);
610
611 do_cleanups (cleanup_chain);
ef5ccd6c 612 return 1;
5796c8dc
SS
613}
614
615/* Given an address ADDR return all the elements needed to print the
c50c785c 616 address in a symbolic form. NAME can be mangled or not depending
5796c8dc 617 on DO_DEMANGLE (and also on the asm_demangle global variable,
c50c785c
JM
618 manipulated via ''set print asm-demangle''). Return 0 in case of
619 success, when all the info in the OUT paramters is valid. Return 1
620 otherwise. */
5796c8dc 621int
cf7f2e2d
JM
622build_address_symbolic (struct gdbarch *gdbarch,
623 CORE_ADDR addr, /* IN */
5796c8dc
SS
624 int do_demangle, /* IN */
625 char **name, /* OUT */
626 int *offset, /* OUT */
627 char **filename, /* OUT */
628 int *line, /* OUT */
629 int *unmapped) /* OUT */
630{
631 struct minimal_symbol *msymbol;
632 struct symbol *symbol;
633 CORE_ADDR name_location = 0;
634 struct obj_section *section = NULL;
ef5ccd6c 635 const char *name_temp = "";
5796c8dc
SS
636
637 /* Let's say it is mapped (not unmapped). */
638 *unmapped = 0;
639
640 /* Determine if the address is in an overlay, and whether it is
641 mapped. */
642 if (overlay_debugging)
643 {
644 section = find_pc_overlay (addr);
645 if (pc_in_unmapped_range (addr, section))
646 {
647 *unmapped = 1;
648 addr = overlay_mapped_address (addr, section);
649 }
650 }
651
652 /* First try to find the address in the symbol table, then
653 in the minsyms. Take the closest one. */
654
655 /* This is defective in the sense that it only finds text symbols. So
656 really this is kind of pointless--we should make sure that the
657 minimal symbols have everything we need (by changing that we could
658 save some memory, but for many debug format--ELF/DWARF or
659 anything/stabs--it would be inconvenient to eliminate those minimal
660 symbols anyway). */
661 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
662 symbol = find_pc_sect_function (addr, section);
663
664 if (symbol)
665 {
cf7f2e2d
JM
666 /* If this is a function (i.e. a code address), strip out any
667 non-address bits. For instance, display a pointer to the
668 first instruction of a Thumb function as <function>; the
669 second instruction will be <function+2>, even though the
670 pointer is <function+3>. This matches the ISA behavior. */
671 addr = gdbarch_addr_bits_remove (gdbarch, addr);
672
5796c8dc
SS
673 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
674 if (do_demangle || asm_demangle)
675 name_temp = SYMBOL_PRINT_NAME (symbol);
676 else
677 name_temp = SYMBOL_LINKAGE_NAME (symbol);
678 }
679
ef5ccd6c
JM
680 if (msymbol != NULL
681 && MSYMBOL_HAS_SIZE (msymbol)
682 && MSYMBOL_SIZE (msymbol) == 0
683 && MSYMBOL_TYPE (msymbol) != mst_text
684 && MSYMBOL_TYPE (msymbol) != mst_text_gnu_ifunc
685 && MSYMBOL_TYPE (msymbol) != mst_file_text)
686 msymbol = NULL;
687
5796c8dc
SS
688 if (msymbol != NULL)
689 {
690 if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
691 {
692 /* The msymbol is closer to the address than the symbol;
693 use the msymbol instead. */
694 symbol = 0;
695 name_location = SYMBOL_VALUE_ADDRESS (msymbol);
696 if (do_demangle || asm_demangle)
697 name_temp = SYMBOL_PRINT_NAME (msymbol);
698 else
699 name_temp = SYMBOL_LINKAGE_NAME (msymbol);
700 }
701 }
702 if (symbol == NULL && msymbol == NULL)
703 return 1;
704
705 /* If the nearest symbol is too far away, don't print anything symbolic. */
706
707 /* For when CORE_ADDR is larger than unsigned int, we do math in
708 CORE_ADDR. But when we detect unsigned wraparound in the
709 CORE_ADDR math, we ignore this test and print the offset,
710 because addr+max_symbolic_offset has wrapped through the end
711 of the address space back to the beginning, giving bogus comparison. */
712 if (addr > name_location + max_symbolic_offset
713 && name_location + max_symbolic_offset > name_location)
714 return 1;
715
716 *offset = addr - name_location;
717
718 *name = xstrdup (name_temp);
719
720 if (print_symbol_filename)
721 {
722 struct symtab_and_line sal;
723
724 sal = find_pc_sect_line (addr, section, 0);
725
726 if (sal.symtab)
727 {
ef5ccd6c 728 *filename = xstrdup (symtab_to_filename_for_display (sal.symtab));
5796c8dc
SS
729 *line = sal.line;
730 }
731 }
732 return 0;
733}
734
735
736/* Print address ADDR symbolically on STREAM.
737 First print it as a number. Then perhaps print
738 <SYMBOL + OFFSET> after the number. */
739
740void
741print_address (struct gdbarch *gdbarch,
742 CORE_ADDR addr, struct ui_file *stream)
743{
744 fputs_filtered (paddress (gdbarch, addr), stream);
cf7f2e2d
JM
745 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
746}
747
748/* Return a prefix for instruction address:
749 "=> " for current instruction, else " ". */
750
751const char *
752pc_prefix (CORE_ADDR addr)
753{
754 if (has_stack_frames ())
755 {
756 struct frame_info *frame;
757 CORE_ADDR pc;
758
759 frame = get_selected_frame (NULL);
c50c785c 760 if (get_frame_pc_if_available (frame, &pc) && pc == addr)
cf7f2e2d
JM
761 return "=> ";
762 }
763 return " ";
5796c8dc
SS
764}
765
766/* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
767 controls whether to print the symbolic name "raw" or demangled.
ef5ccd6c 768 Return non-zero if anything was printed; zero otherwise. */
5796c8dc 769
ef5ccd6c
JM
770int
771print_address_demangle (const struct value_print_options *opts,
772 struct gdbarch *gdbarch, CORE_ADDR addr,
5796c8dc
SS
773 struct ui_file *stream, int do_demangle)
774{
ef5ccd6c 775 if (opts->addressprint)
5796c8dc
SS
776 {
777 fputs_filtered (paddress (gdbarch, addr), stream);
cf7f2e2d 778 print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
5796c8dc
SS
779 }
780 else
781 {
ef5ccd6c 782 return print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
5796c8dc 783 }
ef5ccd6c 784 return 1;
5796c8dc
SS
785}
786\f
787
788/* Examine data at address ADDR in format FMT.
789 Fetch it from memory and print on gdb_stdout. */
790
791static void
792do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
793{
794 char format = 0;
795 char size;
796 int count = 1;
797 struct type *val_type = NULL;
798 int i;
799 int maxelts;
800 struct value_print_options opts;
801
802 format = fmt.format;
803 size = fmt.size;
804 count = fmt.count;
805 next_gdbarch = gdbarch;
806 next_address = addr;
807
cf7f2e2d
JM
808 /* Instruction format implies fetch single bytes
809 regardless of the specified size.
810 The case of strings is handled in decode_format, only explicit
811 size operator are not changed to 'b'. */
812 if (format == 'i')
5796c8dc
SS
813 size = 'b';
814
815 if (size == 'a')
816 {
817 /* Pick the appropriate size for an address. */
818 if (gdbarch_ptr_bit (next_gdbarch) == 64)
819 size = 'g';
820 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
821 size = 'w';
822 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
823 size = 'h';
824 else
825 /* Bad value for gdbarch_ptr_bit. */
826 internal_error (__FILE__, __LINE__,
827 _("failed internal consistency check"));
828 }
829
830 if (size == 'b')
831 val_type = builtin_type (next_gdbarch)->builtin_int8;
832 else if (size == 'h')
833 val_type = builtin_type (next_gdbarch)->builtin_int16;
834 else if (size == 'w')
835 val_type = builtin_type (next_gdbarch)->builtin_int32;
836 else if (size == 'g')
837 val_type = builtin_type (next_gdbarch)->builtin_int64;
838
cf7f2e2d
JM
839 if (format == 's')
840 {
841 struct type *char_type = NULL;
842
843 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
844 if type is not found. */
845 if (size == 'h')
846 char_type = builtin_type (next_gdbarch)->builtin_char16;
847 else if (size == 'w')
848 char_type = builtin_type (next_gdbarch)->builtin_char32;
849 if (char_type)
850 val_type = char_type;
851 else
852 {
853 if (size != '\0' && size != 'b')
c50c785c
JM
854 warning (_("Unable to display strings with "
855 "size '%c', using 'b' instead."), size);
cf7f2e2d
JM
856 size = 'b';
857 val_type = builtin_type (next_gdbarch)->builtin_int8;
858 }
859 }
860
5796c8dc
SS
861 maxelts = 8;
862 if (size == 'w')
863 maxelts = 4;
864 if (size == 'g')
865 maxelts = 2;
866 if (format == 's' || format == 'i')
867 maxelts = 1;
868
869 get_formatted_print_options (&opts, format);
870
871 /* Print as many objects as specified in COUNT, at most maxelts per line,
872 with the address of the next one at the start of each line. */
873
874 while (count > 0)
875 {
876 QUIT;
cf7f2e2d
JM
877 if (format == 'i')
878 fputs_filtered (pc_prefix (next_address), gdb_stdout);
5796c8dc
SS
879 print_address (next_gdbarch, next_address, gdb_stdout);
880 printf_filtered (":");
881 for (i = maxelts;
882 i > 0 && count > 0;
883 i--, count--)
884 {
885 printf_filtered ("\t");
886 /* Note that print_formatted sets next_address for the next
887 object. */
888 last_examine_address = next_address;
889
890 if (last_examine_value)
891 value_free (last_examine_value);
892
893 /* The value to be displayed is not fetched greedily.
894 Instead, to avoid the possibility of a fetched value not
895 being used, its retrieval is delayed until the print code
896 uses it. When examining an instruction stream, the
897 disassembler will perform its own memory fetch using just
898 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
899 the disassembler be modified so that LAST_EXAMINE_VALUE
900 is left with the byte sequence from the last complete
c50c785c 901 instruction fetched from memory? */
5796c8dc
SS
902 last_examine_value = value_at_lazy (val_type, next_address);
903
904 if (last_examine_value)
905 release_value (last_examine_value);
906
907 print_formatted (last_examine_value, size, &opts, gdb_stdout);
908
909 /* Display any branch delay slots following the final insn. */
910 if (format == 'i' && count == 1)
911 count += branch_delay_insns;
912 }
913 printf_filtered ("\n");
914 gdb_flush (gdb_stdout);
915 }
916}
917\f
918static void
919validate_format (struct format_data fmt, char *cmdname)
920{
921 if (fmt.size != 0)
922 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
923 if (fmt.count != 1)
924 error (_("Item count other than 1 is meaningless in \"%s\" command."),
925 cmdname);
926 if (fmt.format == 'i')
927 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
928 fmt.format, cmdname);
929}
930
931/* Evaluate string EXP as an expression in the current language and
932 print the resulting value. EXP may contain a format specifier as the
933 first argument ("/x myvar" for example, to print myvar in hex). */
934
935static void
ef5ccd6c 936print_command_1 (char *exp, int voidprint)
5796c8dc
SS
937{
938 struct expression *expr;
939 struct cleanup *old_chain = 0;
940 char format = 0;
941 struct value *val;
942 struct format_data fmt;
943 int cleanup = 0;
944
945 if (exp && *exp == '/')
946 {
947 exp++;
948 fmt = decode_format (&exp, last_format, 0);
949 validate_format (fmt, "print");
950 last_format = format = fmt.format;
951 }
952 else
953 {
954 fmt.count = 1;
955 fmt.format = 0;
956 fmt.size = 0;
957 fmt.raw = 0;
958 }
959
960 if (exp && *exp)
961 {
5796c8dc
SS
962 expr = parse_expression (exp);
963 old_chain = make_cleanup (free_current_contents, &expr);
964 cleanup = 1;
965 val = evaluate_expression (expr);
966 }
967 else
968 val = access_value_history (0);
969
970 if (voidprint || (val && value_type (val) &&
971 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
972 {
973 struct value_print_options opts;
974 int histindex = record_latest_value (val);
975
976 if (histindex >= 0)
977 annotate_value_history_begin (histindex, value_type (val));
978 else
979 annotate_value_begin (value_type (val));
980
ef5ccd6c 981 if (histindex >= 0)
5796c8dc
SS
982 printf_filtered ("$%d = ", histindex);
983
984 if (histindex >= 0)
985 annotate_value_history_value ();
986
987 get_formatted_print_options (&opts, format);
5796c8dc
SS
988 opts.raw = fmt.raw;
989
990 print_formatted (val, fmt.size, &opts, gdb_stdout);
991 printf_filtered ("\n");
992
993 if (histindex >= 0)
994 annotate_value_history_end ();
995 else
996 annotate_value_end ();
5796c8dc
SS
997 }
998
999 if (cleanup)
1000 do_cleanups (old_chain);
1001}
1002
1003static void
1004print_command (char *exp, int from_tty)
1005{
ef5ccd6c 1006 print_command_1 (exp, 1);
5796c8dc
SS
1007}
1008
1009/* Same as print, except it doesn't print void results. */
1010static void
1011call_command (char *exp, int from_tty)
1012{
ef5ccd6c 1013 print_command_1 (exp, 0);
5796c8dc
SS
1014}
1015
1016void
1017output_command (char *exp, int from_tty)
1018{
1019 struct expression *expr;
1020 struct cleanup *old_chain;
1021 char format = 0;
1022 struct value *val;
1023 struct format_data fmt;
1024 struct value_print_options opts;
1025
1026 fmt.size = 0;
1027 fmt.raw = 0;
1028
1029 if (exp && *exp == '/')
1030 {
1031 exp++;
1032 fmt = decode_format (&exp, 0, 0);
1033 validate_format (fmt, "output");
1034 format = fmt.format;
1035 }
1036
1037 expr = parse_expression (exp);
1038 old_chain = make_cleanup (free_current_contents, &expr);
1039
1040 val = evaluate_expression (expr);
1041
1042 annotate_value_begin (value_type (val));
1043
1044 get_formatted_print_options (&opts, format);
1045 opts.raw = fmt.raw;
1046 print_formatted (val, fmt.size, &opts, gdb_stdout);
1047
1048 annotate_value_end ();
1049
1050 wrap_here ("");
1051 gdb_flush (gdb_stdout);
1052
1053 do_cleanups (old_chain);
1054}
1055
1056static void
1057set_command (char *exp, int from_tty)
1058{
1059 struct expression *expr = parse_expression (exp);
1060 struct cleanup *old_chain =
1061 make_cleanup (free_current_contents, &expr);
cf7f2e2d 1062
ef5ccd6c
JM
1063 if (expr->nelts >= 1)
1064 switch (expr->elts[0].opcode)
1065 {
1066 case UNOP_PREINCREMENT:
1067 case UNOP_POSTINCREMENT:
1068 case UNOP_PREDECREMENT:
1069 case UNOP_POSTDECREMENT:
1070 case BINOP_ASSIGN:
1071 case BINOP_ASSIGN_MODIFY:
1072 case BINOP_COMMA:
1073 break;
1074 default:
1075 warning
1076 (_("Expression is not an assignment (and might have no effect)"));
1077 }
1078
5796c8dc
SS
1079 evaluate_expression (expr);
1080 do_cleanups (old_chain);
1081}
1082
1083static void
1084sym_info (char *arg, int from_tty)
1085{
1086 struct minimal_symbol *msymbol;
1087 struct objfile *objfile;
1088 struct obj_section *osect;
1089 CORE_ADDR addr, sect_addr;
1090 int matches = 0;
1091 unsigned int offset;
1092
1093 if (!arg)
1094 error_no_arg (_("address"));
1095
1096 addr = parse_and_eval_address (arg);
1097 ALL_OBJSECTIONS (objfile, osect)
1098 {
1099 /* Only process each object file once, even if there's a separate
1100 debug file. */
1101 if (objfile->separate_debug_objfile_backlink)
1102 continue;
1103
1104 sect_addr = overlay_mapped_address (addr, osect);
1105
1106 if (obj_section_addr (osect) <= sect_addr
1107 && sect_addr < obj_section_endaddr (osect)
1108 && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
1109 {
1110 const char *obj_name, *mapped, *sec_name, *msym_name;
1111 char *loc_string;
1112 struct cleanup *old_chain;
1113
1114 matches = 1;
1115 offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
1116 mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
1117 sec_name = osect->the_bfd_section->name;
1118 msym_name = SYMBOL_PRINT_NAME (msymbol);
1119
1120 /* Don't print the offset if it is zero.
1121 We assume there's no need to handle i18n of "sym + offset". */
1122 if (offset)
1123 loc_string = xstrprintf ("%s + %u", msym_name, offset);
1124 else
1125 loc_string = xstrprintf ("%s", msym_name);
1126
1127 /* Use a cleanup to free loc_string in case the user quits
1128 a pagination request inside printf_filtered. */
1129 old_chain = make_cleanup (xfree, loc_string);
1130
1131 gdb_assert (osect->objfile && osect->objfile->name);
1132 obj_name = osect->objfile->name;
1133
1134 if (MULTI_OBJFILE_P ())
1135 if (pc_in_unmapped_range (addr, osect))
1136 if (section_is_overlay (osect))
1137 printf_filtered (_("%s in load address range of "
1138 "%s overlay section %s of %s\n"),
1139 loc_string, mapped, sec_name, obj_name);
1140 else
1141 printf_filtered (_("%s in load address range of "
1142 "section %s of %s\n"),
1143 loc_string, sec_name, obj_name);
1144 else
1145 if (section_is_overlay (osect))
1146 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1147 loc_string, mapped, sec_name, obj_name);
1148 else
1149 printf_filtered (_("%s in section %s of %s\n"),
1150 loc_string, sec_name, obj_name);
1151 else
1152 if (pc_in_unmapped_range (addr, osect))
1153 if (section_is_overlay (osect))
1154 printf_filtered (_("%s in load address range of %s overlay "
1155 "section %s\n"),
1156 loc_string, mapped, sec_name);
1157 else
1158 printf_filtered (_("%s in load address range of section %s\n"),
1159 loc_string, sec_name);
1160 else
1161 if (section_is_overlay (osect))
1162 printf_filtered (_("%s in %s overlay section %s\n"),
1163 loc_string, mapped, sec_name);
1164 else
1165 printf_filtered (_("%s in section %s\n"),
1166 loc_string, sec_name);
1167
1168 do_cleanups (old_chain);
1169 }
1170 }
1171 if (matches == 0)
1172 printf_filtered (_("No symbol matches %s.\n"), arg);
1173}
1174
1175static void
1176address_info (char *exp, int from_tty)
1177{
1178 struct gdbarch *gdbarch;
1179 int regno;
1180 struct symbol *sym;
1181 struct minimal_symbol *msymbol;
1182 long val;
1183 struct obj_section *section;
cf7f2e2d 1184 CORE_ADDR load_addr, context_pc = 0;
ef5ccd6c 1185 struct field_of_this_result is_a_field_of_this;
5796c8dc
SS
1186
1187 if (exp == 0)
1188 error (_("Argument required."));
1189
cf7f2e2d 1190 sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
5796c8dc
SS
1191 &is_a_field_of_this);
1192 if (sym == NULL)
1193 {
ef5ccd6c 1194 if (is_a_field_of_this.type != NULL)
5796c8dc
SS
1195 {
1196 printf_filtered ("Symbol \"");
1197 fprintf_symbol_filtered (gdb_stdout, exp,
1198 current_language->la_language, DMGL_ANSI);
1199 printf_filtered ("\" is a field of the local class variable ");
1200 if (current_language->la_language == language_objc)
1201 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1202 else
1203 printf_filtered ("`this'\n");
1204 return;
1205 }
1206
1207 msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1208
1209 if (msymbol != NULL)
1210 {
1211 gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
1212 load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1213
1214 printf_filtered ("Symbol \"");
1215 fprintf_symbol_filtered (gdb_stdout, exp,
1216 current_language->la_language, DMGL_ANSI);
1217 printf_filtered ("\" is at ");
1218 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1219 printf_filtered (" in a file compiled without debugging");
1220 section = SYMBOL_OBJ_SECTION (msymbol);
1221 if (section_is_overlay (section))
1222 {
1223 load_addr = overlay_unmapped_address (load_addr, section);
1224 printf_filtered (",\n -- loaded at ");
1225 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1226 printf_filtered (" in overlay section %s",
1227 section->the_bfd_section->name);
1228 }
1229 printf_filtered (".\n");
1230 }
1231 else
1232 error (_("No symbol \"%s\" in current context."), exp);
1233 return;
1234 }
1235
1236 printf_filtered ("Symbol \"");
1237 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
1238 current_language->la_language, DMGL_ANSI);
1239 printf_filtered ("\" is ");
1240 val = SYMBOL_VALUE (sym);
1241 section = SYMBOL_OBJ_SECTION (sym);
1242 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
1243
1244 switch (SYMBOL_CLASS (sym))
1245 {
1246 case LOC_CONST:
1247 case LOC_CONST_BYTES:
1248 printf_filtered ("constant");
1249 break;
1250
1251 case LOC_LABEL:
1252 printf_filtered ("a label at address ");
1253 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1254 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1255 if (section_is_overlay (section))
1256 {
1257 load_addr = overlay_unmapped_address (load_addr, section);
1258 printf_filtered (",\n -- loaded at ");
1259 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1260 printf_filtered (" in overlay section %s",
1261 section->the_bfd_section->name);
1262 }
1263 break;
1264
1265 case LOC_COMPUTED:
1266 /* FIXME: cagney/2004-01-26: It should be possible to
1267 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
1268 Unfortunately DWARF 2 stores the frame-base (instead of the
1269 function) location in a function's symbol. Oops! For the
1270 moment enable this when/where applicable. */
c50c785c
JM
1271 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
1272 gdb_stdout);
5796c8dc
SS
1273 break;
1274
1275 case LOC_REGISTER:
1276 /* GDBARCH is the architecture associated with the objfile the symbol
1277 is defined in; the target architecture may be different, and may
1278 provide additional registers. However, we do not know the target
1279 architecture at this point. We assume the objfile architecture
1280 will contain all the standard registers that occur in debug info
1281 in that objfile. */
1282 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1283
1284 if (SYMBOL_IS_ARGUMENT (sym))
1285 printf_filtered (_("an argument in register %s"),
1286 gdbarch_register_name (gdbarch, regno));
1287 else
1288 printf_filtered (_("a variable in register %s"),
1289 gdbarch_register_name (gdbarch, regno));
1290 break;
1291
1292 case LOC_STATIC:
1293 printf_filtered (_("static storage at address "));
1294 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1295 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1296 if (section_is_overlay (section))
1297 {
1298 load_addr = overlay_unmapped_address (load_addr, section);
1299 printf_filtered (_(",\n -- loaded at "));
1300 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1301 printf_filtered (_(" in overlay section %s"),
1302 section->the_bfd_section->name);
1303 }
1304 break;
1305
1306 case LOC_REGPARM_ADDR:
1307 /* Note comment at LOC_REGISTER. */
1308 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1309 printf_filtered (_("address of an argument in register %s"),
1310 gdbarch_register_name (gdbarch, regno));
1311 break;
1312
1313 case LOC_ARG:
1314 printf_filtered (_("an argument at offset %ld"), val);
1315 break;
1316
1317 case LOC_LOCAL:
1318 printf_filtered (_("a local variable at frame offset %ld"), val);
1319 break;
1320
1321 case LOC_REF_ARG:
1322 printf_filtered (_("a reference argument at offset %ld"), val);
1323 break;
1324
1325 case LOC_TYPEDEF:
1326 printf_filtered (_("a typedef"));
1327 break;
1328
1329 case LOC_BLOCK:
1330 printf_filtered (_("a function at address "));
1331 load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1332 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1333 if (section_is_overlay (section))
1334 {
1335 load_addr = overlay_unmapped_address (load_addr, section);
1336 printf_filtered (_(",\n -- loaded at "));
1337 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1338 printf_filtered (_(" in overlay section %s"),
1339 section->the_bfd_section->name);
1340 }
1341 break;
1342
1343 case LOC_UNRESOLVED:
1344 {
1345 struct minimal_symbol *msym;
1346
1347 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
1348 if (msym == NULL)
1349 printf_filtered ("unresolved");
1350 else
1351 {
1352 section = SYMBOL_OBJ_SECTION (msym);
1353 load_addr = SYMBOL_VALUE_ADDRESS (msym);
1354
1355 if (section
1356 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1357 printf_filtered (_("a thread-local variable at offset %s "
1358 "in the thread-local storage for `%s'"),
1359 paddress (gdbarch, load_addr),
1360 section->objfile->name);
1361 else
1362 {
1363 printf_filtered (_("static storage at address "));
1364 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1365 if (section_is_overlay (section))
1366 {
1367 load_addr = overlay_unmapped_address (load_addr, section);
1368 printf_filtered (_(",\n -- loaded at "));
1369 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1370 printf_filtered (_(" in overlay section %s"),
1371 section->the_bfd_section->name);
1372 }
1373 }
1374 }
1375 }
1376 break;
1377
1378 case LOC_OPTIMIZED_OUT:
1379 printf_filtered (_("optimized out"));
1380 break;
1381
1382 default:
1383 printf_filtered (_("of unknown (botched) type"));
1384 break;
1385 }
1386 printf_filtered (".\n");
1387}
1388\f
1389
1390static void
1391x_command (char *exp, int from_tty)
1392{
1393 struct expression *expr;
1394 struct format_data fmt;
1395 struct cleanup *old_chain;
1396 struct value *val;
1397
1398 fmt.format = last_format ? last_format : 'x';
1399 fmt.size = last_size;
1400 fmt.count = 1;
1401 fmt.raw = 0;
1402
1403 if (exp && *exp == '/')
1404 {
1405 exp++;
1406 fmt = decode_format (&exp, last_format, last_size);
1407 }
1408
1409 /* If we have an expression, evaluate it and use it as the address. */
1410
1411 if (exp != 0 && *exp != 0)
1412 {
1413 expr = parse_expression (exp);
1414 /* Cause expression not to be there any more if this command is
1415 repeated with Newline. But don't clobber a user-defined
1416 command's definition. */
1417 if (from_tty)
1418 *exp = 0;
1419 old_chain = make_cleanup (free_current_contents, &expr);
1420 val = evaluate_expression (expr);
1421 if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
cf7f2e2d 1422 val = coerce_ref (val);
5796c8dc
SS
1423 /* In rvalue contexts, such as this, functions are coerced into
1424 pointers to functions. This makes "x/i main" work. */
1425 if (/* last_format == 'i' && */
1426 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1427 && VALUE_LVAL (val) == lval_memory)
1428 next_address = value_address (val);
1429 else
1430 next_address = value_as_address (val);
1431
1432 next_gdbarch = expr->gdbarch;
1433 do_cleanups (old_chain);
1434 }
1435
1436 if (!next_gdbarch)
1437 error_no_arg (_("starting display address"));
1438
1439 do_examine (fmt, next_gdbarch, next_address);
1440
1441 /* If the examine succeeds, we remember its size and format for next
cf7f2e2d
JM
1442 time. Set last_size to 'b' for strings. */
1443 if (fmt.format == 's')
1444 last_size = 'b';
1445 else
1446 last_size = fmt.size;
5796c8dc
SS
1447 last_format = fmt.format;
1448
c50c785c 1449 /* Set a couple of internal variables if appropriate. */
5796c8dc
SS
1450 if (last_examine_value)
1451 {
1452 /* Make last address examined available to the user as $_. Use
1453 the correct pointer type. */
1454 struct type *pointer_type
1455 = lookup_pointer_type (value_type (last_examine_value));
1456 set_internalvar (lookup_internalvar ("_"),
1457 value_from_pointer (pointer_type,
1458 last_examine_address));
1459
1460 /* Make contents of last address examined available to the user
1461 as $__. If the last value has not been fetched from memory
1462 then don't fetch it now; instead mark it by voiding the $__
1463 variable. */
1464 if (value_lazy (last_examine_value))
1465 clear_internalvar (lookup_internalvar ("__"));
1466 else
1467 set_internalvar (lookup_internalvar ("__"), last_examine_value);
1468 }
1469}
1470\f
1471
1472/* Add an expression to the auto-display chain.
1473 Specify the expression. */
1474
1475static void
1476display_command (char *exp, int from_tty)
1477{
1478 struct format_data fmt;
1479 struct expression *expr;
1480 struct display *new;
1481 int display_it = 1;
1482
1483#if defined(TUI)
1484 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1485 `tui_version'. */
1486 if (tui_active && exp != NULL && *exp == '$')
1487 display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
1488#endif
1489
1490 if (display_it)
1491 {
1492 if (exp == 0)
1493 {
1494 do_displays ();
1495 return;
1496 }
1497
1498 if (*exp == '/')
1499 {
1500 exp++;
1501 fmt = decode_format (&exp, 0, 0);
1502 if (fmt.size && fmt.format == 0)
1503 fmt.format = 'x';
1504 if (fmt.format == 'i' || fmt.format == 's')
1505 fmt.size = 'b';
1506 }
1507 else
1508 {
1509 fmt.format = 0;
1510 fmt.size = 0;
1511 fmt.count = 0;
1512 fmt.raw = 0;
1513 }
1514
1515 innermost_block = NULL;
1516 expr = parse_expression (exp);
1517
1518 new = (struct display *) xmalloc (sizeof (struct display));
1519
1520 new->exp_string = xstrdup (exp);
1521 new->exp = expr;
1522 new->block = innermost_block;
cf7f2e2d 1523 new->pspace = current_program_space;
5796c8dc
SS
1524 new->next = display_chain;
1525 new->number = ++display_number;
1526 new->format = fmt;
1527 new->enabled_p = 1;
1528 display_chain = new;
1529
1530 if (from_tty && target_has_execution)
1531 do_one_display (new);
1532
1533 dont_repeat ();
1534 }
1535}
1536
1537static void
1538free_display (struct display *d)
1539{
1540 xfree (d->exp_string);
1541 xfree (d->exp);
1542 xfree (d);
1543}
1544
1545/* Clear out the display_chain. Done when new symtabs are loaded,
1546 since this invalidates the types stored in many expressions. */
1547
1548void
1549clear_displays (void)
1550{
1551 struct display *d;
1552
1553 while ((d = display_chain) != NULL)
1554 {
1555 display_chain = d->next;
1556 free_display (d);
1557 }
1558}
1559
c50c785c 1560/* Delete the auto-display DISPLAY. */
5796c8dc
SS
1561
1562static void
c50c785c 1563delete_display (struct display *display)
5796c8dc 1564{
c50c785c 1565 struct display *d;
5796c8dc 1566
c50c785c 1567 gdb_assert (display != NULL);
5796c8dc 1568
c50c785c
JM
1569 if (display_chain == display)
1570 display_chain = display->next;
1571
1572 ALL_DISPLAYS (d)
1573 if (d->next == display)
5796c8dc 1574 {
c50c785c
JM
1575 d->next = display->next;
1576 break;
5796c8dc 1577 }
c50c785c
JM
1578
1579 free_display (display);
5796c8dc
SS
1580}
1581
c50c785c
JM
1582/* Call FUNCTION on each of the displays whose numbers are given in
1583 ARGS. DATA is passed unmodified to FUNCTION. */
1584
1585static void
1586map_display_numbers (char *args,
1587 void (*function) (struct display *,
1588 void *),
1589 void *data)
1590{
1591 struct get_number_or_range_state state;
c50c785c
JM
1592 int num;
1593
1594 if (args == NULL)
1595 error_no_arg (_("one or more display numbers"));
1596
1597 init_number_or_range (&state, args);
1598
1599 while (!state.finished)
1600 {
1601 char *p = state.string;
1602
1603 num = get_number_or_range (&state);
1604 if (num == 0)
1605 warning (_("bad display number at or near '%s'"), p);
1606 else
1607 {
1608 struct display *d, *tmp;
1609
1610 ALL_DISPLAYS_SAFE (d, tmp)
1611 if (d->number == num)
1612 break;
1613 if (d == NULL)
1614 printf_unfiltered (_("No display number %d.\n"), num);
1615 else
1616 function (d, data);
1617 }
1618 }
1619}
1620
1621/* Callback for map_display_numbers, that deletes a display. */
1622
1623static void
1624do_delete_display (struct display *d, void *data)
1625{
1626 delete_display (d);
1627}
1628
1629/* "undisplay" command. */
5796c8dc
SS
1630
1631static void
1632undisplay_command (char *args, int from_tty)
1633{
c50c785c 1634 if (args == NULL)
5796c8dc
SS
1635 {
1636 if (query (_("Delete all auto-display expressions? ")))
1637 clear_displays ();
1638 dont_repeat ();
1639 return;
1640 }
1641
c50c785c 1642 map_display_numbers (args, do_delete_display, NULL);
5796c8dc
SS
1643 dont_repeat ();
1644}
1645
1646/* Display a single auto-display.
1647 Do nothing if the display cannot be printed in the current context,
c50c785c 1648 or if the display is disabled. */
5796c8dc
SS
1649
1650static void
1651do_one_display (struct display *d)
1652{
a45ae5f8 1653 struct cleanup *old_chain;
5796c8dc
SS
1654 int within_current_scope;
1655
1656 if (d->enabled_p == 0)
1657 return;
1658
cf7f2e2d
JM
1659 /* The expression carries the architecture that was used at parse time.
1660 This is a problem if the expression depends on architecture features
1661 (e.g. register numbers), and the current architecture is now different.
1662 For example, a display statement like "display/i $pc" is expected to
1663 display the PC register of the current architecture, not the arch at
1664 the time the display command was given. Therefore, we re-parse the
1665 expression if the current architecture has changed. */
1666 if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1667 {
1668 xfree (d->exp);
1669 d->exp = NULL;
1670 d->block = NULL;
1671 }
1672
5796c8dc
SS
1673 if (d->exp == NULL)
1674 {
1675 volatile struct gdb_exception ex;
cf7f2e2d 1676
5796c8dc
SS
1677 TRY_CATCH (ex, RETURN_MASK_ALL)
1678 {
1679 innermost_block = NULL;
1680 d->exp = parse_expression (d->exp_string);
1681 d->block = innermost_block;
1682 }
1683 if (ex.reason < 0)
1684 {
1685 /* Can't re-parse the expression. Disable this display item. */
1686 d->enabled_p = 0;
1687 warning (_("Unable to display \"%s\": %s"),
1688 d->exp_string, ex.message);
1689 return;
1690 }
1691 }
1692
1693 if (d->block)
cf7f2e2d
JM
1694 {
1695 if (d->pspace == current_program_space)
1696 within_current_scope = contained_in (get_selected_block (0), d->block);
1697 else
1698 within_current_scope = 0;
1699 }
5796c8dc
SS
1700 else
1701 within_current_scope = 1;
1702 if (!within_current_scope)
1703 return;
1704
a45ae5f8 1705 old_chain = make_cleanup_restore_integer (&current_display_number);
5796c8dc
SS
1706 current_display_number = d->number;
1707
1708 annotate_display_begin ();
1709 printf_filtered ("%d", d->number);
1710 annotate_display_number_end ();
1711 printf_filtered (": ");
1712 if (d->format.size)
1713 {
a45ae5f8 1714 volatile struct gdb_exception ex;
5796c8dc
SS
1715
1716 annotate_display_format ();
1717
1718 printf_filtered ("x/");
1719 if (d->format.count != 1)
1720 printf_filtered ("%d", d->format.count);
1721 printf_filtered ("%c", d->format.format);
1722 if (d->format.format != 'i' && d->format.format != 's')
1723 printf_filtered ("%c", d->format.size);
1724 printf_filtered (" ");
1725
1726 annotate_display_expression ();
1727
1728 puts_filtered (d->exp_string);
1729 annotate_display_expression_end ();
1730
1731 if (d->format.count != 1 || d->format.format == 'i')
1732 printf_filtered ("\n");
1733 else
1734 printf_filtered (" ");
1735
5796c8dc
SS
1736 annotate_display_value ();
1737
a45ae5f8
JM
1738 TRY_CATCH (ex, RETURN_MASK_ERROR)
1739 {
1740 struct value *val;
1741 CORE_ADDR addr;
1742
1743 val = evaluate_expression (d->exp);
1744 addr = value_as_address (val);
1745 if (d->format.format == 'i')
1746 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1747 do_examine (d->format, d->exp->gdbarch, addr);
1748 }
1749 if (ex.reason < 0)
1750 fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
5796c8dc
SS
1751 }
1752 else
1753 {
1754 struct value_print_options opts;
a45ae5f8 1755 volatile struct gdb_exception ex;
5796c8dc
SS
1756
1757 annotate_display_format ();
1758
1759 if (d->format.format)
1760 printf_filtered ("/%c ", d->format.format);
1761
1762 annotate_display_expression ();
1763
1764 puts_filtered (d->exp_string);
1765 annotate_display_expression_end ();
1766
1767 printf_filtered (" = ");
1768
1769 annotate_display_expression ();
1770
1771 get_formatted_print_options (&opts, d->format.format);
1772 opts.raw = d->format.raw;
a45ae5f8
JM
1773
1774 TRY_CATCH (ex, RETURN_MASK_ERROR)
1775 {
1776 struct value *val;
1777
1778 val = evaluate_expression (d->exp);
1779 print_formatted (val, d->format.size, &opts, gdb_stdout);
1780 }
1781 if (ex.reason < 0)
1782 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
5796c8dc
SS
1783 printf_filtered ("\n");
1784 }
1785
1786 annotate_display_end ();
1787
1788 gdb_flush (gdb_stdout);
a45ae5f8 1789 do_cleanups (old_chain);
5796c8dc
SS
1790}
1791
1792/* Display all of the values on the auto-display chain which can be
1793 evaluated in the current scope. */
1794
1795void
1796do_displays (void)
1797{
1798 struct display *d;
1799
1800 for (d = display_chain; d; d = d->next)
1801 do_one_display (d);
1802}
1803
1804/* Delete the auto-display which we were in the process of displaying.
1805 This is done when there is an error or a signal. */
1806
1807void
1808disable_display (int num)
1809{
1810 struct display *d;
1811
1812 for (d = display_chain; d; d = d->next)
1813 if (d->number == num)
1814 {
1815 d->enabled_p = 0;
1816 return;
1817 }
1818 printf_unfiltered (_("No display number %d.\n"), num);
1819}
1820
1821void
1822disable_current_display (void)
1823{
1824 if (current_display_number >= 0)
1825 {
1826 disable_display (current_display_number);
c50c785c
JM
1827 fprintf_unfiltered (gdb_stderr,
1828 _("Disabling display %d to "
1829 "avoid infinite recursion.\n"),
5796c8dc
SS
1830 current_display_number);
1831 }
1832 current_display_number = -1;
1833}
1834
1835static void
1836display_info (char *ignore, int from_tty)
1837{
1838 struct display *d;
1839
1840 if (!display_chain)
1841 printf_unfiltered (_("There are no auto-display expressions now.\n"));
1842 else
1843 printf_filtered (_("Auto-display expressions now in effect:\n\
1844Num Enb Expression\n"));
1845
1846 for (d = display_chain; d; d = d->next)
1847 {
1848 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
1849 if (d->format.size)
1850 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1851 d->format.format);
1852 else if (d->format.format)
1853 printf_filtered ("/%c ", d->format.format);
1854 puts_filtered (d->exp_string);
1855 if (d->block && !contained_in (get_selected_block (0), d->block))
1856 printf_filtered (_(" (cannot be evaluated in the current context)"));
1857 printf_filtered ("\n");
1858 gdb_flush (gdb_stdout);
1859 }
1860}
1861
c50c785c
JM
1862/* Callback fo map_display_numbers, that enables or disables the
1863 passed in display D. */
1864
5796c8dc 1865static void
c50c785c 1866do_enable_disable_display (struct display *d, void *data)
5796c8dc 1867{
c50c785c
JM
1868 d->enabled_p = *(int *) data;
1869}
5796c8dc 1870
c50c785c
JM
1871/* Implamentation of both the "disable display" and "enable display"
1872 commands. ENABLE decides what to do. */
1873
1874static void
1875enable_disable_display_command (char *args, int from_tty, int enable)
1876{
1877 if (args == NULL)
5796c8dc 1878 {
c50c785c 1879 struct display *d;
5796c8dc 1880
c50c785c
JM
1881 ALL_DISPLAYS (d)
1882 d->enabled_p = enable;
1883 return;
1884 }
5796c8dc 1885
c50c785c 1886 map_display_numbers (args, do_enable_disable_display, &enable);
5796c8dc
SS
1887}
1888
c50c785c
JM
1889/* The "enable display" command. */
1890
5796c8dc 1891static void
c50c785c 1892enable_display_command (char *args, int from_tty)
5796c8dc 1893{
c50c785c
JM
1894 enable_disable_display_command (args, from_tty, 1);
1895}
5796c8dc 1896
c50c785c 1897/* The "disable display" command. */
5796c8dc 1898
c50c785c
JM
1899static void
1900disable_display_command (char *args, int from_tty)
1901{
1902 enable_disable_display_command (args, from_tty, 0);
5796c8dc
SS
1903}
1904
5796c8dc
SS
1905/* display_chain items point to blocks and expressions. Some expressions in
1906 turn may point to symbols.
1907 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1908 obstack_free'd when a shared library is unloaded.
1909 Clear pointers that are about to become dangling.
1910 Both .exp and .block fields will be restored next time we need to display
1911 an item by re-parsing .exp_string field in the new execution context. */
1912
1913static void
1914clear_dangling_display_expressions (struct so_list *solib)
1915{
cf7f2e2d 1916 struct objfile *objfile = solib->objfile;
5796c8dc 1917 struct display *d;
5796c8dc 1918
cf7f2e2d
JM
1919 /* With no symbol file we cannot have a block or expression from it. */
1920 if (objfile == NULL)
1921 return;
1922 if (objfile->separate_debug_objfile_backlink)
1923 objfile = objfile->separate_debug_objfile_backlink;
1924 gdb_assert (objfile->pspace == solib->pspace);
1925
1926 for (d = display_chain; d != NULL; d = d->next)
5796c8dc 1927 {
cf7f2e2d
JM
1928 if (d->pspace != solib->pspace)
1929 continue;
1930
1931 if (lookup_objfile_from_block (d->block) == objfile
1932 || (d->exp && exp_uses_objfile (d->exp, objfile)))
1933 {
1934 xfree (d->exp);
1935 d->exp = NULL;
1936 d->block = NULL;
1937 }
5796c8dc
SS
1938 }
1939}
1940\f
1941
1942/* Print the value in stack frame FRAME of a variable specified by a
1943 struct symbol. NAME is the name to print; if NULL then VAR's print
1944 name will be used. STREAM is the ui_file on which to print the
1945 value. INDENT specifies the number of indent levels to print
ef5ccd6c
JM
1946 before printing the variable name.
1947
1948 This function invalidates FRAME. */
5796c8dc
SS
1949
1950void
1951print_variable_and_value (const char *name, struct symbol *var,
1952 struct frame_info *frame,
1953 struct ui_file *stream, int indent)
1954{
cf7f2e2d 1955 volatile struct gdb_exception except;
5796c8dc
SS
1956
1957 if (!name)
1958 name = SYMBOL_PRINT_NAME (var);
1959
1960 fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
cf7f2e2d
JM
1961 TRY_CATCH (except, RETURN_MASK_ERROR)
1962 {
1963 struct value *val;
1964 struct value_print_options opts;
5796c8dc 1965
cf7f2e2d
JM
1966 val = read_var_value (var, frame);
1967 get_user_print_options (&opts);
a45ae5f8 1968 opts.deref_ref = 1;
cf7f2e2d 1969 common_val_print (val, stream, indent, &opts, current_language);
ef5ccd6c
JM
1970
1971 /* common_val_print invalidates FRAME when a pretty printer calls inferior
1972 function. */
1973 frame = NULL;
cf7f2e2d
JM
1974 }
1975 if (except.reason < 0)
1976 fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
1977 except.message);
5796c8dc
SS
1978 fprintf_filtered (stream, "\n");
1979}
1980
ef5ccd6c
JM
1981/* Subroutine of ui_printf to simplify it.
1982 Print VALUE to STREAM using FORMAT.
1983 VALUE is a C-style string on the target. */
cf7f2e2d 1984
5796c8dc 1985static void
ef5ccd6c
JM
1986printf_c_string (struct ui_file *stream, const char *format,
1987 struct value *value)
5796c8dc 1988{
ef5ccd6c
JM
1989 gdb_byte *str;
1990 CORE_ADDR tem;
1991 int j;
5796c8dc 1992
ef5ccd6c 1993 tem = value_as_address (value);
5796c8dc 1994
ef5ccd6c
JM
1995 /* This is a %s argument. Find the length of the string. */
1996 for (j = 0;; j++)
1997 {
1998 gdb_byte c;
5796c8dc 1999
ef5ccd6c
JM
2000 QUIT;
2001 read_memory (tem + j, &c, 1);
2002 if (c == 0)
2003 break;
2004 }
5796c8dc 2005
ef5ccd6c
JM
2006 /* Copy the string contents into a string inside GDB. */
2007 str = (gdb_byte *) alloca (j + 1);
2008 if (j != 0)
2009 read_memory (tem, str, j);
2010 str[j] = 0;
5796c8dc 2011
ef5ccd6c
JM
2012 fprintf_filtered (stream, format, (char *) str);
2013}
2014
2015/* Subroutine of ui_printf to simplify it.
2016 Print VALUE to STREAM using FORMAT.
2017 VALUE is a wide C-style string on the target. */
2018
2019static void
2020printf_wide_c_string (struct ui_file *stream, const char *format,
2021 struct value *value)
2022{
2023 gdb_byte *str;
2024 CORE_ADDR tem;
2025 int j;
2026 struct gdbarch *gdbarch = get_type_arch (value_type (value));
2027 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2028 struct type *wctype = lookup_typename (current_language, gdbarch,
2029 "wchar_t", NULL, 0);
2030 int wcwidth = TYPE_LENGTH (wctype);
2031 gdb_byte *buf = alloca (wcwidth);
2032 struct obstack output;
2033 struct cleanup *inner_cleanup;
5796c8dc 2034
ef5ccd6c 2035 tem = value_as_address (value);
5796c8dc 2036
ef5ccd6c
JM
2037 /* This is a %s argument. Find the length of the string. */
2038 for (j = 0;; j += wcwidth)
5796c8dc 2039 {
ef5ccd6c
JM
2040 QUIT;
2041 read_memory (tem + j, buf, wcwidth);
2042 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2043 break;
2044 }
5796c8dc 2045
ef5ccd6c
JM
2046 /* Copy the string contents into a string inside GDB. */
2047 str = (gdb_byte *) alloca (j + wcwidth);
2048 if (j != 0)
2049 read_memory (tem, str, j);
2050 memset (&str[j], 0, wcwidth);
5796c8dc 2051
ef5ccd6c
JM
2052 obstack_init (&output);
2053 inner_cleanup = make_cleanup_obstack_free (&output);
2054
2055 convert_between_encodings (target_wide_charset (gdbarch),
2056 host_charset (),
2057 str, j, wcwidth,
2058 &output, translit_char);
2059 obstack_grow_str0 (&output, "");
2060
2061 fprintf_filtered (stream, format, obstack_base (&output));
2062 do_cleanups (inner_cleanup);
2063}
2064
2065/* Subroutine of ui_printf to simplify it.
2066 Print VALUE, a decimal floating point value, to STREAM using FORMAT. */
2067
2068static void
2069printf_decfloat (struct ui_file *stream, const char *format,
2070 struct value *value)
2071{
2072 const gdb_byte *param_ptr = value_contents (value);
2073
2074#if defined (PRINTF_HAS_DECFLOAT)
2075 /* If we have native support for Decimal floating
2076 printing, handle it here. */
2077 fprintf_filtered (stream, format, param_ptr);
2078#else
2079 /* As a workaround until vasprintf has native support for DFP
2080 we convert the DFP values to string and print them using
2081 the %s format specifier. */
2082 const char *p;
2083
2084 /* Parameter data. */
2085 struct type *param_type = value_type (value);
2086 struct gdbarch *gdbarch = get_type_arch (param_type);
2087 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2088
2089 /* DFP output data. */
2090 struct value *dfp_value = NULL;
2091 gdb_byte *dfp_ptr;
2092 int dfp_len = 16;
2093 gdb_byte dec[16];
2094 struct type *dfp_type = NULL;
2095 char decstr[MAX_DECIMAL_STRING];
2096
2097 /* Points to the end of the string so that we can go back
2098 and check for DFP length modifiers. */
2099 p = format + strlen (format);
2100
2101 /* Look for the float/double format specifier. */
2102 while (*p != 'f' && *p != 'e' && *p != 'E'
2103 && *p != 'g' && *p != 'G')
2104 p--;
2105
2106 /* Search for the '%' char and extract the size and type of
2107 the output decimal value based on its modifiers
2108 (%Hf, %Df, %DDf). */
2109 while (*--p != '%')
2110 {
2111 if (*p == 'H')
2112 {
2113 dfp_len = 4;
2114 dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2115 }
2116 else if (*p == 'D' && *(p - 1) == 'D')
2117 {
2118 dfp_len = 16;
2119 dfp_type = builtin_type (gdbarch)->builtin_declong;
2120 p--;
2121 }
2122 else
2123 {
2124 dfp_len = 8;
2125 dfp_type = builtin_type (gdbarch)->builtin_decdouble;
5796c8dc
SS
2126 }
2127 }
2128
ef5ccd6c
JM
2129 /* Conversion between different DFP types. */
2130 if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2131 decimal_convert (param_ptr, TYPE_LENGTH (param_type),
2132 byte_order, dec, dfp_len, byte_order);
2133 else
2134 /* If this is a non-trivial conversion, just output 0.
2135 A correct converted value can be displayed by explicitly
2136 casting to a DFP type. */
2137 decimal_from_string (dec, dfp_len, byte_order, "0");
5796c8dc 2138
ef5ccd6c 2139 dfp_value = value_from_decfloat (dfp_type, dec);
5796c8dc 2140
ef5ccd6c 2141 dfp_ptr = (gdb_byte *) value_contents (dfp_value);
5796c8dc 2142
ef5ccd6c 2143 decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
5796c8dc 2144
ef5ccd6c
JM
2145 /* Print the DFP value. */
2146 fprintf_filtered (stream, "%s", decstr);
2147#endif
2148}
5796c8dc 2149
ef5ccd6c
JM
2150/* Subroutine of ui_printf to simplify it.
2151 Print VALUE, a target pointer, to STREAM using FORMAT. */
5796c8dc 2152
ef5ccd6c
JM
2153static void
2154printf_pointer (struct ui_file *stream, const char *format,
2155 struct value *value)
2156{
2157 /* We avoid the host's %p because pointers are too
2158 likely to be the wrong size. The only interesting
2159 modifier for %p is a width; extract that, and then
2160 handle %p as glibc would: %#x or a literal "(nil)". */
2161
2162 const char *p;
2163 char *fmt, *fmt_p;
2164#ifdef PRINTF_HAS_LONG_LONG
2165 long long val = value_as_long (value);
2166#else
2167 long val = value_as_long (value);
2168#endif
5796c8dc 2169
ef5ccd6c 2170 fmt = alloca (strlen (format) + 5);
5796c8dc 2171
ef5ccd6c
JM
2172 /* Copy up to the leading %. */
2173 p = format;
2174 fmt_p = fmt;
2175 while (*p)
2176 {
2177 int is_percent = (*p == '%');
5796c8dc 2178
ef5ccd6c
JM
2179 *fmt_p++ = *p++;
2180 if (is_percent)
2181 {
2182 if (*p == '%')
2183 *fmt_p++ = *p++;
2184 else
2185 break;
2186 }
2187 }
5796c8dc 2188
ef5ccd6c
JM
2189 if (val != 0)
2190 *fmt_p++ = '#';
5796c8dc 2191
ef5ccd6c
JM
2192 /* Copy any width. */
2193 while (*p >= '0' && *p < '9')
2194 *fmt_p++ = *p++;
5796c8dc 2195
ef5ccd6c
JM
2196 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2197 if (val != 0)
2198 {
2199#ifdef PRINTF_HAS_LONG_LONG
2200 *fmt_p++ = 'l';
2201#endif
2202 *fmt_p++ = 'l';
2203 *fmt_p++ = 'x';
2204 *fmt_p++ = '\0';
2205 fprintf_filtered (stream, fmt, val);
2206 }
2207 else
2208 {
2209 *fmt_p++ = 's';
2210 *fmt_p++ = '\0';
2211 fprintf_filtered (stream, fmt, "(nil)");
2212 }
2213}
5796c8dc 2214
ef5ccd6c 2215/* printf "printf format string" ARG to STREAM. */
5796c8dc 2216
ef5ccd6c
JM
2217static void
2218ui_printf (const char *arg, struct ui_file *stream)
2219{
2220 struct format_piece *fpieces;
2221 const char *s = arg;
2222 struct value **val_args;
2223 int allocated_args = 20;
2224 struct cleanup *old_cleanups;
5796c8dc 2225
ef5ccd6c
JM
2226 val_args = xmalloc (allocated_args * sizeof (struct value *));
2227 old_cleanups = make_cleanup (free_current_contents, &val_args);
5796c8dc 2228
ef5ccd6c
JM
2229 if (s == 0)
2230 error_no_arg (_("format-control string and values to print"));
5796c8dc 2231
ef5ccd6c 2232 s = skip_spaces_const (s);
5796c8dc 2233
ef5ccd6c
JM
2234 /* A format string should follow, enveloped in double quotes. */
2235 if (*s++ != '"')
2236 error (_("Bad format string, missing '\"'."));
5796c8dc 2237
ef5ccd6c 2238 fpieces = parse_format_string (&s);
5796c8dc 2239
ef5ccd6c 2240 make_cleanup (free_format_pieces_cleanup, &fpieces);
5796c8dc 2241
ef5ccd6c
JM
2242 if (*s++ != '"')
2243 error (_("Bad format string, non-terminated '\"'."));
2244
2245 s = skip_spaces_const (s);
5796c8dc 2246
ef5ccd6c
JM
2247 if (*s != ',' && *s != 0)
2248 error (_("Invalid argument syntax"));
cf7f2e2d 2249
ef5ccd6c
JM
2250 if (*s == ',')
2251 s++;
2252 s = skip_spaces_const (s);
2253
2254 {
2255 int nargs = 0;
2256 int nargs_wanted;
2257 int i, fr;
2258 char *current_substring;
2259
2260 nargs_wanted = 0;
2261 for (fr = 0; fpieces[fr].string != NULL; fr++)
2262 if (fpieces[fr].argclass != literal_piece)
2263 ++nargs_wanted;
5796c8dc
SS
2264
2265 /* Now, parse all arguments and evaluate them.
2266 Store the VALUEs in VAL_ARGS. */
2267
2268 while (*s != '\0')
2269 {
ef5ccd6c 2270 const char *s1;
cf7f2e2d 2271
5796c8dc
SS
2272 if (nargs == allocated_args)
2273 val_args = (struct value **) xrealloc ((char *) val_args,
2274 (allocated_args *= 2)
2275 * sizeof (struct value *));
2276 s1 = s;
2277 val_args[nargs] = parse_to_comma_and_eval (&s1);
2278
2279 nargs++;
2280 s = s1;
2281 if (*s == ',')
2282 s++;
2283 }
2284
2285 if (nargs != nargs_wanted)
2286 error (_("Wrong number of arguments for specified format-string"));
2287
2288 /* Now actually print them. */
ef5ccd6c
JM
2289 i = 0;
2290 for (fr = 0; fpieces[fr].string != NULL; fr++)
5796c8dc 2291 {
ef5ccd6c
JM
2292 current_substring = fpieces[fr].string;
2293 switch (fpieces[fr].argclass)
5796c8dc
SS
2294 {
2295 case string_arg:
ef5ccd6c 2296 printf_c_string (stream, current_substring, val_args[i]);
5796c8dc
SS
2297 break;
2298 case wide_string_arg:
ef5ccd6c 2299 printf_wide_c_string (stream, current_substring, val_args[i]);
5796c8dc
SS
2300 break;
2301 case wide_char_arg:
2302 {
2303 struct gdbarch *gdbarch
2304 = get_type_arch (value_type (val_args[i]));
5796c8dc
SS
2305 struct type *wctype = lookup_typename (current_language, gdbarch,
2306 "wchar_t", NULL, 0);
2307 struct type *valtype;
2308 struct obstack output;
2309 struct cleanup *inner_cleanup;
2310 const gdb_byte *bytes;
2311
2312 valtype = value_type (val_args[i]);
2313 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2314 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2315 error (_("expected wchar_t argument for %%lc"));
2316
2317 bytes = value_contents (val_args[i]);
2318
2319 obstack_init (&output);
2320 inner_cleanup = make_cleanup_obstack_free (&output);
2321
cf7f2e2d 2322 convert_between_encodings (target_wide_charset (gdbarch),
5796c8dc
SS
2323 host_charset (),
2324 bytes, TYPE_LENGTH (valtype),
2325 TYPE_LENGTH (valtype),
2326 &output, translit_char);
2327 obstack_grow_str0 (&output, "");
2328
cf7f2e2d
JM
2329 fprintf_filtered (stream, current_substring,
2330 obstack_base (&output));
5796c8dc
SS
2331 do_cleanups (inner_cleanup);
2332 }
2333 break;
2334 case double_arg:
2335 {
2336 struct type *type = value_type (val_args[i]);
2337 DOUBLEST val;
2338 int inv;
2339
2340 /* If format string wants a float, unchecked-convert the value
2341 to floating point of the same size. */
2342 type = float_type_from_length (type);
2343 val = unpack_double (type, value_contents (val_args[i]), &inv);
2344 if (inv)
2345 error (_("Invalid floating value found in program."));
2346
cf7f2e2d 2347 fprintf_filtered (stream, current_substring, (double) val);
5796c8dc
SS
2348 break;
2349 }
2350 case long_double_arg:
2351#ifdef HAVE_LONG_DOUBLE
2352 {
2353 struct type *type = value_type (val_args[i]);
2354 DOUBLEST val;
2355 int inv;
2356
2357 /* If format string wants a float, unchecked-convert the value
2358 to floating point of the same size. */
2359 type = float_type_from_length (type);
2360 val = unpack_double (type, value_contents (val_args[i]), &inv);
2361 if (inv)
2362 error (_("Invalid floating value found in program."));
2363
cf7f2e2d
JM
2364 fprintf_filtered (stream, current_substring,
2365 (long double) val);
5796c8dc
SS
2366 break;
2367 }
2368#else
2369 error (_("long double not supported in printf"));
2370#endif
2371 case long_long_arg:
ef5ccd6c 2372#ifdef PRINTF_HAS_LONG_LONG
5796c8dc
SS
2373 {
2374 long long val = value_as_long (val_args[i]);
cf7f2e2d
JM
2375
2376 fprintf_filtered (stream, current_substring, val);
5796c8dc
SS
2377 break;
2378 }
2379#else
2380 error (_("long long not supported in printf"));
2381#endif
2382 case int_arg:
2383 {
2384 int val = value_as_long (val_args[i]);
cf7f2e2d
JM
2385
2386 fprintf_filtered (stream, current_substring, val);
5796c8dc
SS
2387 break;
2388 }
2389 case long_arg:
2390 {
2391 long val = value_as_long (val_args[i]);
cf7f2e2d
JM
2392
2393 fprintf_filtered (stream, current_substring, val);
5796c8dc
SS
2394 break;
2395 }
5796c8dc 2396 /* Handles decimal floating values. */
ef5ccd6c
JM
2397 case decfloat_arg:
2398 printf_decfloat (stream, current_substring, val_args[i]);
2399 break;
5796c8dc 2400 case ptr_arg:
ef5ccd6c
JM
2401 printf_pointer (stream, current_substring, val_args[i]);
2402 break;
2403 case literal_piece:
2404 /* Print a portion of the format string that has no
2405 directives. Note that this will not include any
2406 ordinary %-specs, but it might include "%%". That is
2407 why we use printf_filtered and not puts_filtered here.
2408 Also, we pass a dummy argument because some platforms
2409 have modified GCC to include -Wformat-security by
2410 default, which will warn here if there is no
2411 argument. */
2412 fprintf_filtered (stream, current_substring, 0);
2413 break;
5796c8dc
SS
2414 default:
2415 internal_error (__FILE__, __LINE__,
2416 _("failed internal consistency check"));
2417 }
ef5ccd6c
JM
2418 /* Maybe advance to the next argument. */
2419 if (fpieces[fr].argclass != literal_piece)
2420 ++i;
5796c8dc 2421 }
5796c8dc
SS
2422 }
2423 do_cleanups (old_cleanups);
2424}
2425
cf7f2e2d
JM
2426/* Implement the "printf" command. */
2427
2428static void
2429printf_command (char *arg, int from_tty)
2430{
2431 ui_printf (arg, gdb_stdout);
2432}
2433
2434/* Implement the "eval" command. */
2435
2436static void
2437eval_command (char *arg, int from_tty)
2438{
2439 struct ui_file *ui_out = mem_fileopen ();
2440 struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
2441 char *expanded;
2442
2443 ui_printf (arg, ui_out);
2444
2445 expanded = ui_file_xstrdup (ui_out, NULL);
2446 make_cleanup (xfree, expanded);
2447
2448 execute_command (expanded, from_tty);
2449
2450 do_cleanups (cleanups);
2451}
2452
5796c8dc
SS
2453void
2454_initialize_printcmd (void)
2455{
2456 struct cmd_list_element *c;
2457
2458 current_display_number = -1;
2459
2460 observer_attach_solib_unloaded (clear_dangling_display_expressions);
2461
2462 add_info ("address", address_info,
2463 _("Describe where symbol SYM is stored."));
2464
2465 add_info ("symbol", sym_info, _("\
2466Describe what symbol is at location ADDR.\n\
2467Only for symbols with fixed locations (global or static scope)."));
2468
2469 add_com ("x", class_vars, x_command, _("\
2470Examine memory: x/FMT ADDRESS.\n\
2471ADDRESS is an expression for the memory address to examine.\n\
2472FMT is a repeat count followed by a format letter and a size letter.\n\
2473Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2474 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2475Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2476The specified number of objects of the specified size are printed\n\
2477according to the format.\n\n\
2478Defaults for format and size letters are those previously used.\n\
2479Default count is 1. Default address is following last thing printed\n\
2480with this command or \"print\"."));
2481
2482#if 0
2483 add_com ("whereis", class_vars, whereis_command,
2484 _("Print line number and file of definition of variable."));
2485#endif
2486
2487 add_info ("display", display_info, _("\
2488Expressions to display when program stops, with code numbers."));
2489
2490 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2491Cancel some expressions to be displayed when program stops.\n\
2492Arguments are the code numbers of the expressions to stop displaying.\n\
2493No argument means cancel all automatic-display expressions.\n\
2494\"delete display\" has the same effect as this command.\n\
2495Do \"info display\" to see current list of code numbers."),
2496 &cmdlist);
2497
2498 add_com ("display", class_vars, display_command, _("\
2499Print value of expression EXP each time the program stops.\n\
2500/FMT may be used before EXP as in the \"print\" command.\n\
2501/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2502as in the \"x\" command, and then EXP is used to get the address to examine\n\
2503and examining is done as in the \"x\" command.\n\n\
2504With no argument, display all currently requested auto-display expressions.\n\
2505Use \"undisplay\" to cancel display requests previously made."));
2506
c50c785c 2507 add_cmd ("display", class_vars, enable_display_command, _("\
5796c8dc
SS
2508Enable some expressions to be displayed when program stops.\n\
2509Arguments are the code numbers of the expressions to resume displaying.\n\
2510No argument means enable all automatic-display expressions.\n\
2511Do \"info display\" to see current list of code numbers."), &enablelist);
2512
2513 add_cmd ("display", class_vars, disable_display_command, _("\
2514Disable some expressions to be displayed when program stops.\n\
2515Arguments are the code numbers of the expressions to stop displaying.\n\
2516No argument means disable all automatic-display expressions.\n\
2517Do \"info display\" to see current list of code numbers."), &disablelist);
2518
2519 add_cmd ("display", class_vars, undisplay_command, _("\
2520Cancel some expressions to be displayed when program stops.\n\
2521Arguments are the code numbers of the expressions to stop displaying.\n\
2522No argument means cancel all automatic-display expressions.\n\
2523Do \"info display\" to see current list of code numbers."), &deletelist);
2524
2525 add_com ("printf", class_vars, printf_command, _("\
2526printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2527This is useful for formatted output in user-defined commands."));
2528
2529 add_com ("output", class_vars, output_command, _("\
2530Like \"print\" but don't put in value history and don't print newline.\n\
2531This is useful in user-defined commands."));
2532
2533 add_prefix_cmd ("set", class_vars, set_command, _("\
2534Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2535syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2536example). VAR may be a debugger \"convenience\" variable (names starting\n\
2537with $), a register (a few standard names starting with $), or an actual\n\
2538variable in the program being debugged. EXP is any valid expression.\n\
2539Use \"set variable\" for variables with names identical to set subcommands.\n\
2540\n\
2541With a subcommand, this command modifies parts of the gdb environment.\n\
2542You can see these environment settings with the \"show\" command."),
2543 &setlist, "set ", 1, &cmdlist);
2544 if (dbx_commands)
2545 add_com ("assign", class_vars, set_command, _("\
2546Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2547syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2548example). VAR may be a debugger \"convenience\" variable (names starting\n\
2549with $), a register (a few standard names starting with $), or an actual\n\
2550variable in the program being debugged. EXP is any valid expression.\n\
2551Use \"set variable\" for variables with names identical to set subcommands.\n\
2552\nWith a subcommand, this command modifies parts of the gdb environment.\n\
2553You can see these environment settings with the \"show\" command."));
2554
c50c785c 2555 /* "call" is the same as "set", but handy for dbx users to call fns. */
5796c8dc
SS
2556 c = add_com ("call", class_vars, call_command, _("\
2557Call a function in the program.\n\
2558The argument is the function name and arguments, in the notation of the\n\
2559current working language. The result is printed and saved in the value\n\
2560history, if it is not void."));
2561 set_cmd_completer (c, expression_completer);
2562
2563 add_cmd ("variable", class_vars, set_command, _("\
2564Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2565syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2566example). VAR may be a debugger \"convenience\" variable (names starting\n\
2567with $), a register (a few standard names starting with $), or an actual\n\
2568variable in the program being debugged. EXP is any valid expression.\n\
2569This may usually be abbreviated to simply \"set\"."),
2570 &setlist);
2571
2572 c = add_com ("print", class_vars, print_command, _("\
2573Print value of expression EXP.\n\
2574Variables accessible are those of the lexical environment of the selected\n\
2575stack frame, plus all those whose scope is global or an entire file.\n\
2576\n\
2577$NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2578$$NUM refers to NUM'th value back from the last one.\n\
2579Names starting with $ refer to registers (with the values they would have\n\
2580if the program were to return to the stack frame now selected, restoring\n\
2581all registers saved by frames farther in) or else to debugger\n\
2582\"convenience\" variables (any such name not a known register).\n\
2583Use assignment expressions to give values to convenience variables.\n\
2584\n\
2585{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2586@ is a binary operator for treating consecutive data objects\n\
2587anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2588element is FOO, whose second element is stored in the space following\n\
2589where FOO is stored, etc. FOO must be an expression whose value\n\
2590resides in memory.\n\
2591\n\
2592EXP may be preceded with /FMT, where FMT is a format letter\n\
2593but no count or size letter (see \"x\" command)."));
2594 set_cmd_completer (c, expression_completer);
2595 add_com_alias ("p", "print", class_vars, 1);
ef5ccd6c 2596 add_com_alias ("inspect", "print", class_vars, 1);
5796c8dc
SS
2597
2598 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2599 &max_symbolic_offset, _("\
2600Set the largest offset that will be printed in <symbol+1234> form."), _("\
2601Show the largest offset that will be printed in <symbol+1234> form."), NULL,
2602 NULL,
2603 show_max_symbolic_offset,
2604 &setprintlist, &showprintlist);
2605 add_setshow_boolean_cmd ("symbol-filename", no_class,
2606 &print_symbol_filename, _("\
2607Set printing of source filename and line number with <symbol>."), _("\
2608Show printing of source filename and line number with <symbol>."), NULL,
2609 NULL,
2610 show_print_symbol_filename,
2611 &setprintlist, &showprintlist);
cf7f2e2d
JM
2612
2613 add_com ("eval", no_class, eval_command, _("\
2614Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2615a command line, and call it."));
5796c8dc 2616}