1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
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
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
29 #include "expression.h"
33 #include "breakpoint.h"
37 #include "symfile.h" /* for overlay functions */
38 #include "objfiles.h" /* ditto */
39 #include "completer.h" /* for completion functions */
41 #include "gdb_assert.h"
46 #include "exceptions.h"
49 #include "parser-defs.h"
51 #include "arch-utils.h"
54 #include "tui/tui.h" /* For tui_active et.al. */
57 #if defined(__MINGW32__) && !defined(PRINTF_HAS_LONG_LONG)
58 # define USE_PRINTF_I64 1
59 # define PRINTF_HAS_LONG_LONG
61 # define USE_PRINTF_I64 0
64 extern int asm_demangle; /* Whether to demangle syms in asm printouts */
72 /* True if the value should be printed raw -- that is, bypassing
73 python-based formatters. */
77 /* Last specified output format. */
79 static char last_format = 0;
81 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
83 static char last_size = 'w';
85 /* Default address to examine next, and associated architecture. */
87 static struct gdbarch *next_gdbarch;
88 static CORE_ADDR next_address;
90 /* Number of delay instructions following current disassembled insn. */
92 static int branch_delay_insns;
94 /* Last address examined. */
96 static CORE_ADDR last_examine_address;
98 /* Contents of last address examined.
99 This is not valid past the end of the `x' command! */
101 static struct value *last_examine_value;
103 /* Largest offset between a symbolic value and an address, that will be
104 printed as `0x1234 <symbol+offset>'. */
106 static unsigned int max_symbolic_offset = UINT_MAX;
108 show_max_symbolic_offset (struct ui_file *file, int from_tty,
109 struct cmd_list_element *c, const char *value)
111 fprintf_filtered (file, _("\
112 The largest offset that will be printed in <symbol+1234> form is %s.\n"),
116 /* Append the source filename and linenumber of the symbol when
117 printing a symbolic value as `<symbol at filename:linenum>' if set. */
118 static int print_symbol_filename = 0;
120 show_print_symbol_filename (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c, const char *value)
123 fprintf_filtered (file, _("\
124 Printing of source filename and line number with <symbol> is %s.\n"),
128 /* Number of auto-display expression currently being displayed.
129 So that we can disable it if we get an error or a signal within it.
130 -1 when not doing one. */
132 int current_display_number;
136 /* Chain link to next auto-display item. */
137 struct display *next;
139 /* The expression as the user typed it. */
142 /* Expression to be evaluated and displayed. */
143 struct expression *exp;
145 /* Item number of this auto-display item. */
148 /* Display format specified. */
149 struct format_data format;
151 /* Program space associated with `block'. */
152 struct program_space *pspace;
154 /* Innermost block required by this expression when evaluated */
157 /* Status of this display (enabled or disabled) */
161 /* Chain of expressions whose values should be displayed
162 automatically each time the program stops. */
164 static struct display *display_chain;
166 static int display_number;
168 /* Prototypes for exported functions. */
170 void output_command (char *, int);
172 void _initialize_printcmd (void);
174 /* Prototypes for local functions. */
176 static void do_one_display (struct display *);
179 /* Decode a format specification. *STRING_PTR should point to it.
180 OFORMAT and OSIZE are used as defaults for the format and size
181 if none are given in the format specification.
182 If OSIZE is zero, then the size field of the returned value
183 should be set only if a size is explicitly specified by the
185 The structure returned describes all the data
186 found in the specification. In addition, *STRING_PTR is advanced
187 past the specification and past all whitespace following it. */
189 static struct format_data
190 decode_format (char **string_ptr, int oformat, int osize)
192 struct format_data val;
193 char *p = *string_ptr;
200 if (*p >= '0' && *p <= '9')
201 val.count = atoi (p);
202 while (*p >= '0' && *p <= '9')
205 /* Now process size or format letters that follow. */
209 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
216 else if (*p >= 'a' && *p <= 'z')
222 while (*p == ' ' || *p == '\t')
226 /* Set defaults for format and size if not specified. */
227 if (val.format == '?')
231 /* Neither has been specified. */
232 val.format = oformat;
236 /* If a size is specified, any format makes a reasonable
237 default except 'i'. */
238 val.format = oformat == 'i' ? 'x' : oformat;
240 else if (val.size == '?')
244 /* Pick the appropriate size for an address. This is deferred
245 until do_examine when we know the actual architecture to use.
246 A special size value of 'a' is used to indicate this case. */
247 val.size = osize ? 'a' : osize;
250 /* Floating point has to be word or giantword. */
251 if (osize == 'w' || osize == 'g')
254 /* Default it to giantword if the last used size is not
256 val.size = osize ? 'g' : osize;
259 /* Characters default to one byte. */
260 val.size = osize ? 'b' : osize;
263 /* Display strings with byte size chars unless explicitly specified. */
268 /* The default is the size most recently specified. */
275 /* Print value VAL on stream according to OPTIONS.
276 Do not end with a newline.
277 SIZE is the letter for the size of datum being printed.
278 This is used to pad hex numbers so they line up. SIZE is 0
279 for print / output and set for examine. */
282 print_formatted (struct value *val, int size,
283 const struct value_print_options *options,
284 struct ui_file *stream)
286 struct type *type = check_typedef (value_type (val));
287 int len = TYPE_LENGTH (type);
289 if (VALUE_LVAL (val) == lval_memory)
290 next_address = value_address (val) + len;
294 switch (options->format)
298 struct type *elttype = value_type (val);
299 next_address = (value_address (val)
300 + val_print_string (elttype,
301 value_address (val), -1,
302 stream, options) * len);
307 /* We often wrap here if there are long symbolic names. */
309 next_address = (value_address (val)
310 + gdb_print_insn (get_type_arch (type),
311 value_address (val), stream,
312 &branch_delay_insns));
317 if (options->format == 0 || options->format == 's'
318 || TYPE_CODE (type) == TYPE_CODE_REF
319 || TYPE_CODE (type) == TYPE_CODE_ARRAY
320 || TYPE_CODE (type) == TYPE_CODE_STRING
321 || TYPE_CODE (type) == TYPE_CODE_STRUCT
322 || TYPE_CODE (type) == TYPE_CODE_UNION
323 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
324 value_print (val, stream, options);
326 /* User specified format, so don't look to the the type to
327 tell us what to do. */
328 print_scalar_formatted (value_contents (val), type,
329 options, size, stream);
332 /* Return builtin floating point type of same length as TYPE.
333 If no such type is found, return TYPE itself. */
335 float_type_from_length (struct type *type)
337 struct gdbarch *gdbarch = get_type_arch (type);
338 const struct builtin_type *builtin = builtin_type (gdbarch);
339 unsigned int len = TYPE_LENGTH (type);
341 if (len == TYPE_LENGTH (builtin->builtin_float))
342 type = builtin->builtin_float;
343 else if (len == TYPE_LENGTH (builtin->builtin_double))
344 type = builtin->builtin_double;
345 else if (len == TYPE_LENGTH (builtin->builtin_long_double))
346 type = builtin->builtin_long_double;
351 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
352 according to OPTIONS and SIZE on STREAM.
353 Formats s and i are not supported at this level.
355 This is how the elements of an array or structure are printed
359 print_scalar_formatted (const void *valaddr, struct type *type,
360 const struct value_print_options *options,
361 int size, struct ui_file *stream)
363 struct gdbarch *gdbarch = get_type_arch (type);
364 LONGEST val_long = 0;
365 unsigned int len = TYPE_LENGTH (type);
366 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
368 /* If we get here with a string format, try again without it. Go
369 all the way back to the language printers, which may call us
371 if (options->format == 's')
373 struct value_print_options opts = *options;
376 val_print (type, valaddr, 0, 0, stream, 0, &opts,
381 if (len > sizeof(LONGEST) &&
382 (TYPE_CODE (type) == TYPE_CODE_INT
383 || TYPE_CODE (type) == TYPE_CODE_ENUM))
385 switch (options->format)
388 print_octal_chars (stream, valaddr, len, byte_order);
392 print_decimal_chars (stream, valaddr, len, byte_order);
395 print_binary_chars (stream, valaddr, len, byte_order);
398 print_hex_chars (stream, valaddr, len, byte_order);
401 print_char_chars (stream, type, valaddr, len, byte_order);
408 if (options->format != 'f')
409 val_long = unpack_long (type, valaddr);
411 /* If the value is a pointer, and pointers and addresses are not the
412 same, then at this point, the value's length (in target bytes) is
413 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
414 if (TYPE_CODE (type) == TYPE_CODE_PTR)
415 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
417 /* If we are printing it as unsigned, truncate it in case it is actually
418 a negative signed value (e.g. "print/u (short)-1" should print 65535
419 (if shorts are 16 bits) instead of 4294967295). */
420 if (options->format != 'd' || TYPE_UNSIGNED (type))
422 if (len < sizeof (LONGEST))
423 val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
426 switch (options->format)
431 /* No size specified, like in print. Print varying # of digits. */
432 print_longest (stream, 'x', 1, val_long);
441 print_longest (stream, size, 1, val_long);
444 error (_("Undefined output size \"%c\"."), size);
449 print_longest (stream, 'd', 1, val_long);
453 print_longest (stream, 'u', 0, val_long);
458 print_longest (stream, 'o', 1, val_long);
460 fprintf_filtered (stream, "0");
465 CORE_ADDR addr = unpack_pointer (type, valaddr);
466 print_address (gdbarch, addr, stream);
472 struct value_print_options opts = *options;
475 if (TYPE_UNSIGNED (type))
476 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
478 type = builtin_type (gdbarch)->builtin_true_char;
480 value_print (value_from_longest (type, val_long), stream, &opts);
485 type = float_type_from_length (type);
486 print_floating (valaddr, type, stream);
490 internal_error (__FILE__, __LINE__,
491 _("failed internal consistency check"));
494 /* Binary; 't' stands for "two". */
496 char bits[8 * (sizeof val_long) + 1];
497 char buf[8 * (sizeof val_long) + 32];
502 width = 8 * (sizeof val_long);
519 error (_("Undefined output size \"%c\"."), size);
525 bits[width] = (val_long & 1) ? '1' : '0';
530 while (*cp && *cp == '0')
536 fputs_filtered (buf, stream);
541 error (_("Undefined output format \"%c\"."), options->format);
545 /* Specify default address for `x' command.
546 The `info lines' command uses this. */
549 set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
551 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
553 next_gdbarch = gdbarch;
556 /* Make address available to the user as $_. */
557 set_internalvar (lookup_internalvar ("_"),
558 value_from_pointer (ptr_type, addr));
561 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
562 after LEADIN. Print nothing if no symbolic name is found nearby.
563 Optionally also print source file and line number, if available.
564 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
565 or to interpret it as a possible C++ name and convert it back to source
566 form. However note that DO_DEMANGLE can be overridden by the specific
567 settings of the demangle and asm_demangle variables. */
570 print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
571 struct ui_file *stream,
572 int do_demangle, char *leadin)
575 char *filename = NULL;
580 /* Throw away both name and filename. */
581 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
582 make_cleanup (free_current_contents, &filename);
584 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
585 &filename, &line, &unmapped))
587 do_cleanups (cleanup_chain);
591 fputs_filtered (leadin, stream);
593 fputs_filtered ("<*", stream);
595 fputs_filtered ("<", stream);
596 fputs_filtered (name, stream);
598 fprintf_filtered (stream, "+%u", (unsigned int) offset);
600 /* Append source filename and line number if desired. Give specific
601 line # of this addr, if we have it; else line # of the nearest symbol. */
602 if (print_symbol_filename && filename != NULL)
605 fprintf_filtered (stream, " at %s:%d", filename, line);
607 fprintf_filtered (stream, " in %s", filename);
610 fputs_filtered ("*>", stream);
612 fputs_filtered (">", stream);
614 do_cleanups (cleanup_chain);
617 /* Given an address ADDR return all the elements needed to print the
618 address in a symbolic form. NAME can be mangled or not depending
619 on DO_DEMANGLE (and also on the asm_demangle global variable,
620 manipulated via ''set print asm-demangle''). Return 0 in case of
621 success, when all the info in the OUT paramters is valid. Return 1
624 build_address_symbolic (struct gdbarch *gdbarch,
625 CORE_ADDR addr, /* IN */
626 int do_demangle, /* IN */
627 char **name, /* OUT */
628 int *offset, /* OUT */
629 char **filename, /* OUT */
631 int *unmapped) /* OUT */
633 struct minimal_symbol *msymbol;
634 struct symbol *symbol;
635 CORE_ADDR name_location = 0;
636 struct obj_section *section = NULL;
637 char *name_temp = "";
639 /* Let's say it is mapped (not unmapped). */
642 /* Determine if the address is in an overlay, and whether it is
644 if (overlay_debugging)
646 section = find_pc_overlay (addr);
647 if (pc_in_unmapped_range (addr, section))
650 addr = overlay_mapped_address (addr, section);
654 /* First try to find the address in the symbol table, then
655 in the minsyms. Take the closest one. */
657 /* This is defective in the sense that it only finds text symbols. So
658 really this is kind of pointless--we should make sure that the
659 minimal symbols have everything we need (by changing that we could
660 save some memory, but for many debug format--ELF/DWARF or
661 anything/stabs--it would be inconvenient to eliminate those minimal
663 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
664 symbol = find_pc_sect_function (addr, section);
668 /* If this is a function (i.e. a code address), strip out any
669 non-address bits. For instance, display a pointer to the
670 first instruction of a Thumb function as <function>; the
671 second instruction will be <function+2>, even though the
672 pointer is <function+3>. This matches the ISA behavior. */
673 addr = gdbarch_addr_bits_remove (gdbarch, addr);
675 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
676 if (do_demangle || asm_demangle)
677 name_temp = SYMBOL_PRINT_NAME (symbol);
679 name_temp = SYMBOL_LINKAGE_NAME (symbol);
684 if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
686 /* The msymbol is closer to the address than the symbol;
687 use the msymbol instead. */
689 name_location = SYMBOL_VALUE_ADDRESS (msymbol);
690 if (do_demangle || asm_demangle)
691 name_temp = SYMBOL_PRINT_NAME (msymbol);
693 name_temp = SYMBOL_LINKAGE_NAME (msymbol);
696 if (symbol == NULL && msymbol == NULL)
699 /* If the nearest symbol is too far away, don't print anything symbolic. */
701 /* For when CORE_ADDR is larger than unsigned int, we do math in
702 CORE_ADDR. But when we detect unsigned wraparound in the
703 CORE_ADDR math, we ignore this test and print the offset,
704 because addr+max_symbolic_offset has wrapped through the end
705 of the address space back to the beginning, giving bogus comparison. */
706 if (addr > name_location + max_symbolic_offset
707 && name_location + max_symbolic_offset > name_location)
710 *offset = addr - name_location;
712 *name = xstrdup (name_temp);
714 if (print_symbol_filename)
716 struct symtab_and_line sal;
718 sal = find_pc_sect_line (addr, section, 0);
722 *filename = xstrdup (sal.symtab->filename);
730 /* Print address ADDR symbolically on STREAM.
731 First print it as a number. Then perhaps print
732 <SYMBOL + OFFSET> after the number. */
735 print_address (struct gdbarch *gdbarch,
736 CORE_ADDR addr, struct ui_file *stream)
738 fputs_filtered (paddress (gdbarch, addr), stream);
739 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
742 /* Return a prefix for instruction address:
743 "=> " for current instruction, else " ". */
746 pc_prefix (CORE_ADDR addr)
748 if (has_stack_frames ())
750 struct frame_info *frame;
753 frame = get_selected_frame (NULL);
754 pc = get_frame_pc (frame);
762 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
763 controls whether to print the symbolic name "raw" or demangled.
764 Global setting "addressprint" controls whether to print hex address
768 print_address_demangle (struct gdbarch *gdbarch, CORE_ADDR addr,
769 struct ui_file *stream, int do_demangle)
771 struct value_print_options opts;
772 get_user_print_options (&opts);
775 fprintf_filtered (stream, "0");
777 else if (opts.addressprint)
779 fputs_filtered (paddress (gdbarch, addr), stream);
780 print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
784 print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
789 /* Examine data at address ADDR in format FMT.
790 Fetch it from memory and print on gdb_stdout. */
793 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
798 struct type *val_type = NULL;
801 struct value_print_options opts;
806 next_gdbarch = gdbarch;
809 /* Instruction format implies fetch single bytes
810 regardless of the specified size.
811 The case of strings is handled in decode_format, only explicit
812 size operator are not changed to 'b'. */
818 /* Pick the appropriate size for an address. */
819 if (gdbarch_ptr_bit (next_gdbarch) == 64)
821 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
823 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
826 /* Bad value for gdbarch_ptr_bit. */
827 internal_error (__FILE__, __LINE__,
828 _("failed internal consistency check"));
832 val_type = builtin_type (next_gdbarch)->builtin_int8;
833 else if (size == 'h')
834 val_type = builtin_type (next_gdbarch)->builtin_int16;
835 else if (size == 'w')
836 val_type = builtin_type (next_gdbarch)->builtin_int32;
837 else if (size == 'g')
838 val_type = builtin_type (next_gdbarch)->builtin_int64;
842 struct type *char_type = NULL;
843 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
844 if type is not found. */
846 char_type = builtin_type (next_gdbarch)->builtin_char16;
847 else if (size == 'w')
848 char_type = builtin_type (next_gdbarch)->builtin_char32;
850 val_type = char_type;
853 if (size != '\0' && size != 'b')
854 warning (_("Unable to display strings with size '%c', using 'b' \
857 val_type = builtin_type (next_gdbarch)->builtin_int8;
866 if (format == 's' || format == 'i')
869 get_formatted_print_options (&opts, format);
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. */
878 fputs_filtered (pc_prefix (next_address), gdb_stdout);
879 print_address (next_gdbarch, next_address, gdb_stdout);
880 printf_filtered (":");
885 printf_filtered ("\t");
886 /* Note that print_formatted sets next_address for the next
888 last_examine_address = next_address;
890 if (last_examine_value)
891 value_free (last_examine_value);
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
901 instruction fetched from memory? */
902 last_examine_value = value_at_lazy (val_type, next_address);
904 if (last_examine_value)
905 release_value (last_examine_value);
907 print_formatted (last_examine_value, size, &opts, gdb_stdout);
909 /* Display any branch delay slots following the final insn. */
910 if (format == 'i' && count == 1)
911 count += branch_delay_insns;
913 printf_filtered ("\n");
914 gdb_flush (gdb_stdout);
919 validate_format (struct format_data fmt, char *cmdname)
922 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
924 error (_("Item count other than 1 is meaningless in \"%s\" command."),
926 if (fmt.format == 'i')
927 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
928 fmt.format, cmdname);
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). */
936 print_command_1 (char *exp, int inspect, int voidprint)
938 struct expression *expr;
939 struct cleanup *old_chain = 0;
942 struct format_data fmt;
945 if (exp && *exp == '/')
948 fmt = decode_format (&exp, last_format, 0);
949 validate_format (fmt, "print");
950 last_format = format = fmt.format;
963 expr = parse_expression (exp);
964 old_chain = make_cleanup (free_current_contents, &expr);
966 val = evaluate_expression (expr);
969 val = access_value_history (0);
971 if (voidprint || (val && value_type (val) &&
972 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
974 struct value_print_options opts;
975 int histindex = record_latest_value (val);
978 annotate_value_history_begin (histindex, value_type (val));
980 annotate_value_begin (value_type (val));
983 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"",
985 else if (histindex >= 0)
986 printf_filtered ("$%d = ", histindex);
989 annotate_value_history_value ();
991 get_formatted_print_options (&opts, format);
992 opts.inspect_it = inspect;
995 print_formatted (val, fmt.size, &opts, gdb_stdout);
996 printf_filtered ("\n");
999 annotate_value_history_end ();
1001 annotate_value_end ();
1004 printf_unfiltered ("\") )\030");
1008 do_cleanups (old_chain);
1012 print_command (char *exp, int from_tty)
1014 print_command_1 (exp, 0, 1);
1017 /* Same as print, except in epoch, it gets its own window. */
1019 inspect_command (char *exp, int from_tty)
1021 extern int epoch_interface;
1023 print_command_1 (exp, epoch_interface, 1);
1026 /* Same as print, except it doesn't print void results. */
1028 call_command (char *exp, int from_tty)
1030 print_command_1 (exp, 0, 0);
1034 output_command (char *exp, int from_tty)
1036 struct expression *expr;
1037 struct cleanup *old_chain;
1040 struct format_data fmt;
1041 struct value_print_options opts;
1046 if (exp && *exp == '/')
1049 fmt = decode_format (&exp, 0, 0);
1050 validate_format (fmt, "output");
1051 format = fmt.format;
1054 expr = parse_expression (exp);
1055 old_chain = make_cleanup (free_current_contents, &expr);
1057 val = evaluate_expression (expr);
1059 annotate_value_begin (value_type (val));
1061 get_formatted_print_options (&opts, format);
1063 print_formatted (val, fmt.size, &opts, gdb_stdout);
1065 annotate_value_end ();
1068 gdb_flush (gdb_stdout);
1070 do_cleanups (old_chain);
1074 set_command (char *exp, int from_tty)
1076 struct expression *expr = parse_expression (exp);
1077 struct cleanup *old_chain =
1078 make_cleanup (free_current_contents, &expr);
1079 evaluate_expression (expr);
1080 do_cleanups (old_chain);
1084 sym_info (char *arg, int from_tty)
1086 struct minimal_symbol *msymbol;
1087 struct objfile *objfile;
1088 struct obj_section *osect;
1089 CORE_ADDR addr, sect_addr;
1091 unsigned int offset;
1094 error_no_arg (_("address"));
1096 addr = parse_and_eval_address (arg);
1097 ALL_OBJSECTIONS (objfile, osect)
1099 /* Only process each object file once, even if there's a separate
1101 if (objfile->separate_debug_objfile_backlink)
1104 sect_addr = overlay_mapped_address (addr, osect);
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)))
1110 const char *obj_name, *mapped, *sec_name, *msym_name;
1112 struct cleanup *old_chain;
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);
1120 /* Don't print the offset if it is zero.
1121 We assume there's no need to handle i18n of "sym + offset". */
1123 loc_string = xstrprintf ("%s + %u", msym_name, offset);
1125 loc_string = xstrprintf ("%s", msym_name);
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);
1131 gdb_assert (osect->objfile && osect->objfile->name);
1132 obj_name = osect->objfile->name;
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);
1141 printf_filtered (_("%s in load address range of "
1142 "section %s of %s\n"),
1143 loc_string, sec_name, obj_name);
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);
1149 printf_filtered (_("%s in section %s of %s\n"),
1150 loc_string, sec_name, obj_name);
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 "
1156 loc_string, mapped, sec_name);
1158 printf_filtered (_("%s in load address range of section %s\n"),
1159 loc_string, sec_name);
1161 if (section_is_overlay (osect))
1162 printf_filtered (_("%s in %s overlay section %s\n"),
1163 loc_string, mapped, sec_name);
1165 printf_filtered (_("%s in section %s\n"),
1166 loc_string, sec_name);
1168 do_cleanups (old_chain);
1172 printf_filtered (_("No symbol matches %s.\n"), arg);
1176 address_info (char *exp, int from_tty)
1178 struct block *block;
1179 struct gdbarch *gdbarch;
1182 struct minimal_symbol *msymbol;
1184 struct obj_section *section;
1185 CORE_ADDR load_addr, context_pc = 0;
1186 int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
1187 if exp is a field of `this'. */
1190 error (_("Argument required."));
1192 sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
1193 &is_a_field_of_this);
1196 if (is_a_field_of_this)
1198 printf_filtered ("Symbol \"");
1199 fprintf_symbol_filtered (gdb_stdout, exp,
1200 current_language->la_language, DMGL_ANSI);
1201 printf_filtered ("\" is a field of the local class variable ");
1202 if (current_language->la_language == language_objc)
1203 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1205 printf_filtered ("`this'\n");
1209 msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1211 if (msymbol != NULL)
1213 gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
1214 load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1216 printf_filtered ("Symbol \"");
1217 fprintf_symbol_filtered (gdb_stdout, exp,
1218 current_language->la_language, DMGL_ANSI);
1219 printf_filtered ("\" is at ");
1220 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1221 printf_filtered (" in a file compiled without debugging");
1222 section = SYMBOL_OBJ_SECTION (msymbol);
1223 if (section_is_overlay (section))
1225 load_addr = overlay_unmapped_address (load_addr, section);
1226 printf_filtered (",\n -- loaded at ");
1227 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1228 printf_filtered (" in overlay section %s",
1229 section->the_bfd_section->name);
1231 printf_filtered (".\n");
1234 error (_("No symbol \"%s\" in current context."), exp);
1238 printf_filtered ("Symbol \"");
1239 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
1240 current_language->la_language, DMGL_ANSI);
1241 printf_filtered ("\" is ");
1242 val = SYMBOL_VALUE (sym);
1243 section = SYMBOL_OBJ_SECTION (sym);
1244 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
1246 switch (SYMBOL_CLASS (sym))
1249 case LOC_CONST_BYTES:
1250 printf_filtered ("constant");
1254 printf_filtered ("a label at address ");
1255 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1256 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1257 if (section_is_overlay (section))
1259 load_addr = overlay_unmapped_address (load_addr, section);
1260 printf_filtered (",\n -- loaded at ");
1261 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1262 printf_filtered (" in overlay section %s",
1263 section->the_bfd_section->name);
1268 /* FIXME: cagney/2004-01-26: It should be possible to
1269 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
1270 Unfortunately DWARF 2 stores the frame-base (instead of the
1271 function) location in a function's symbol. Oops! For the
1272 moment enable this when/where applicable. */
1273 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc, gdb_stdout);
1277 /* GDBARCH is the architecture associated with the objfile the symbol
1278 is defined in; the target architecture may be different, and may
1279 provide additional registers. However, we do not know the target
1280 architecture at this point. We assume the objfile architecture
1281 will contain all the standard registers that occur in debug info
1283 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1285 if (SYMBOL_IS_ARGUMENT (sym))
1286 printf_filtered (_("an argument in register %s"),
1287 gdbarch_register_name (gdbarch, regno));
1289 printf_filtered (_("a variable in register %s"),
1290 gdbarch_register_name (gdbarch, regno));
1294 printf_filtered (_("static storage at address "));
1295 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1296 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1297 if (section_is_overlay (section))
1299 load_addr = overlay_unmapped_address (load_addr, section);
1300 printf_filtered (_(",\n -- loaded at "));
1301 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1302 printf_filtered (_(" in overlay section %s"),
1303 section->the_bfd_section->name);
1307 case LOC_REGPARM_ADDR:
1308 /* Note comment at LOC_REGISTER. */
1309 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1310 printf_filtered (_("address of an argument in register %s"),
1311 gdbarch_register_name (gdbarch, regno));
1315 printf_filtered (_("an argument at offset %ld"), val);
1319 printf_filtered (_("a local variable at frame offset %ld"), val);
1323 printf_filtered (_("a reference argument at offset %ld"), val);
1327 printf_filtered (_("a typedef"));
1331 printf_filtered (_("a function at address "));
1332 load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1333 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1334 if (section_is_overlay (section))
1336 load_addr = overlay_unmapped_address (load_addr, section);
1337 printf_filtered (_(",\n -- loaded at "));
1338 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1339 printf_filtered (_(" in overlay section %s"),
1340 section->the_bfd_section->name);
1344 case LOC_UNRESOLVED:
1346 struct minimal_symbol *msym;
1348 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
1350 printf_filtered ("unresolved");
1353 section = SYMBOL_OBJ_SECTION (msym);
1354 load_addr = SYMBOL_VALUE_ADDRESS (msym);
1357 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1358 printf_filtered (_("a thread-local variable at offset %s "
1359 "in the thread-local storage for `%s'"),
1360 paddress (gdbarch, load_addr),
1361 section->objfile->name);
1364 printf_filtered (_("static storage at address "));
1365 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1366 if (section_is_overlay (section))
1368 load_addr = overlay_unmapped_address (load_addr, section);
1369 printf_filtered (_(",\n -- loaded at "));
1370 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1371 printf_filtered (_(" in overlay section %s"),
1372 section->the_bfd_section->name);
1379 case LOC_OPTIMIZED_OUT:
1380 printf_filtered (_("optimized out"));
1384 printf_filtered (_("of unknown (botched) type"));
1387 printf_filtered (".\n");
1392 x_command (char *exp, int from_tty)
1394 struct expression *expr;
1395 struct format_data fmt;
1396 struct cleanup *old_chain;
1399 fmt.format = last_format ? last_format : 'x';
1400 fmt.size = last_size;
1404 if (exp && *exp == '/')
1407 fmt = decode_format (&exp, last_format, last_size);
1410 /* If we have an expression, evaluate it and use it as the address. */
1412 if (exp != 0 && *exp != 0)
1414 expr = parse_expression (exp);
1415 /* Cause expression not to be there any more if this command is
1416 repeated with Newline. But don't clobber a user-defined
1417 command's definition. */
1420 old_chain = make_cleanup (free_current_contents, &expr);
1421 val = evaluate_expression (expr);
1422 if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1423 val = coerce_ref (val);
1424 /* In rvalue contexts, such as this, functions are coerced into
1425 pointers to functions. This makes "x/i main" work. */
1426 if (/* last_format == 'i' && */
1427 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1428 && VALUE_LVAL (val) == lval_memory)
1429 next_address = value_address (val);
1431 next_address = value_as_address (val);
1433 next_gdbarch = expr->gdbarch;
1434 do_cleanups (old_chain);
1438 error_no_arg (_("starting display address"));
1440 do_examine (fmt, next_gdbarch, next_address);
1442 /* If the examine succeeds, we remember its size and format for next
1443 time. Set last_size to 'b' for strings. */
1444 if (fmt.format == 's')
1447 last_size = fmt.size;
1448 last_format = fmt.format;
1450 /* Set a couple of internal variables if appropriate. */
1451 if (last_examine_value)
1453 /* Make last address examined available to the user as $_. Use
1454 the correct pointer type. */
1455 struct type *pointer_type
1456 = lookup_pointer_type (value_type (last_examine_value));
1457 set_internalvar (lookup_internalvar ("_"),
1458 value_from_pointer (pointer_type,
1459 last_examine_address));
1461 /* Make contents of last address examined available to the user
1462 as $__. If the last value has not been fetched from memory
1463 then don't fetch it now; instead mark it by voiding the $__
1465 if (value_lazy (last_examine_value))
1466 clear_internalvar (lookup_internalvar ("__"));
1468 set_internalvar (lookup_internalvar ("__"), last_examine_value);
1473 /* Add an expression to the auto-display chain.
1474 Specify the expression. */
1477 display_command (char *exp, int from_tty)
1479 struct format_data fmt;
1480 struct expression *expr;
1481 struct display *new;
1485 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1487 if (tui_active && exp != NULL && *exp == '$')
1488 display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
1502 fmt = decode_format (&exp, 0, 0);
1503 if (fmt.size && fmt.format == 0)
1505 if (fmt.format == 'i' || fmt.format == 's')
1516 innermost_block = NULL;
1517 expr = parse_expression (exp);
1519 new = (struct display *) xmalloc (sizeof (struct display));
1521 new->exp_string = xstrdup (exp);
1523 new->block = innermost_block;
1524 new->pspace = current_program_space;
1525 new->next = display_chain;
1526 new->number = ++display_number;
1529 display_chain = new;
1531 if (from_tty && target_has_execution)
1532 do_one_display (new);
1539 free_display (struct display *d)
1541 xfree (d->exp_string);
1546 /* Clear out the display_chain. Done when new symtabs are loaded,
1547 since this invalidates the types stored in many expressions. */
1550 clear_displays (void)
1554 while ((d = display_chain) != NULL)
1556 display_chain = d->next;
1561 /* Delete the auto-display number NUM. */
1564 delete_display (int num)
1566 struct display *d1, *d;
1569 error (_("No display number %d."), num);
1571 if (display_chain->number == num)
1574 display_chain = d1->next;
1578 for (d = display_chain;; d = d->next)
1581 error (_("No display number %d."), num);
1582 if (d->next->number == num)
1592 /* Delete some values from the auto-display chain.
1593 Specify the element numbers. */
1596 undisplay_command (char *args, int from_tty)
1604 if (query (_("Delete all auto-display expressions? ")))
1613 while (*p1 >= '0' && *p1 <= '9')
1615 if (*p1 && *p1 != ' ' && *p1 != '\t')
1616 error (_("Arguments must be display numbers."));
1620 delete_display (num);
1623 while (*p == ' ' || *p == '\t')
1629 /* Display a single auto-display.
1630 Do nothing if the display cannot be printed in the current context,
1631 or if the display is disabled. */
1634 do_one_display (struct display *d)
1636 int within_current_scope;
1638 if (d->enabled_p == 0)
1641 /* The expression carries the architecture that was used at parse time.
1642 This is a problem if the expression depends on architecture features
1643 (e.g. register numbers), and the current architecture is now different.
1644 For example, a display statement like "display/i $pc" is expected to
1645 display the PC register of the current architecture, not the arch at
1646 the time the display command was given. Therefore, we re-parse the
1647 expression if the current architecture has changed. */
1648 if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1657 volatile struct gdb_exception ex;
1658 TRY_CATCH (ex, RETURN_MASK_ALL)
1660 innermost_block = NULL;
1661 d->exp = parse_expression (d->exp_string);
1662 d->block = innermost_block;
1666 /* Can't re-parse the expression. Disable this display item. */
1668 warning (_("Unable to display \"%s\": %s"),
1669 d->exp_string, ex.message);
1676 if (d->pspace == current_program_space)
1677 within_current_scope = contained_in (get_selected_block (0), d->block);
1679 within_current_scope = 0;
1682 within_current_scope = 1;
1683 if (!within_current_scope)
1686 current_display_number = d->number;
1688 annotate_display_begin ();
1689 printf_filtered ("%d", d->number);
1690 annotate_display_number_end ();
1691 printf_filtered (": ");
1697 annotate_display_format ();
1699 printf_filtered ("x/");
1700 if (d->format.count != 1)
1701 printf_filtered ("%d", d->format.count);
1702 printf_filtered ("%c", d->format.format);
1703 if (d->format.format != 'i' && d->format.format != 's')
1704 printf_filtered ("%c", d->format.size);
1705 printf_filtered (" ");
1707 annotate_display_expression ();
1709 puts_filtered (d->exp_string);
1710 annotate_display_expression_end ();
1712 if (d->format.count != 1 || d->format.format == 'i')
1713 printf_filtered ("\n");
1715 printf_filtered (" ");
1717 val = evaluate_expression (d->exp);
1718 addr = value_as_address (val);
1719 if (d->format.format == 'i')
1720 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1722 annotate_display_value ();
1724 do_examine (d->format, d->exp->gdbarch, addr);
1728 struct value_print_options opts;
1730 annotate_display_format ();
1732 if (d->format.format)
1733 printf_filtered ("/%c ", d->format.format);
1735 annotate_display_expression ();
1737 puts_filtered (d->exp_string);
1738 annotate_display_expression_end ();
1740 printf_filtered (" = ");
1742 annotate_display_expression ();
1744 get_formatted_print_options (&opts, d->format.format);
1745 opts.raw = d->format.raw;
1746 print_formatted (evaluate_expression (d->exp),
1747 d->format.size, &opts, gdb_stdout);
1748 printf_filtered ("\n");
1751 annotate_display_end ();
1753 gdb_flush (gdb_stdout);
1754 current_display_number = -1;
1757 /* Display all of the values on the auto-display chain which can be
1758 evaluated in the current scope. */
1765 for (d = display_chain; d; d = d->next)
1769 /* Delete the auto-display which we were in the process of displaying.
1770 This is done when there is an error or a signal. */
1773 disable_display (int num)
1777 for (d = display_chain; d; d = d->next)
1778 if (d->number == num)
1783 printf_unfiltered (_("No display number %d.\n"), num);
1787 disable_current_display (void)
1789 if (current_display_number >= 0)
1791 disable_display (current_display_number);
1792 fprintf_unfiltered (gdb_stderr, _("\
1793 Disabling display %d to avoid infinite recursion.\n"),
1794 current_display_number);
1796 current_display_number = -1;
1800 display_info (char *ignore, int from_tty)
1805 printf_unfiltered (_("There are no auto-display expressions now.\n"));
1807 printf_filtered (_("Auto-display expressions now in effect:\n\
1808 Num Enb Expression\n"));
1810 for (d = display_chain; d; d = d->next)
1812 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
1814 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1816 else if (d->format.format)
1817 printf_filtered ("/%c ", d->format.format);
1818 puts_filtered (d->exp_string);
1819 if (d->block && !contained_in (get_selected_block (0), d->block))
1820 printf_filtered (_(" (cannot be evaluated in the current context)"));
1821 printf_filtered ("\n");
1822 gdb_flush (gdb_stdout);
1827 enable_display (char *args, int from_tty)
1836 for (d = display_chain; d; d = d->next)
1843 while (*p1 >= '0' && *p1 <= '9')
1845 if (*p1 && *p1 != ' ' && *p1 != '\t')
1846 error (_("Arguments must be display numbers."));
1850 for (d = display_chain; d; d = d->next)
1851 if (d->number == num)
1856 printf_unfiltered (_("No display number %d.\n"), num);
1859 while (*p == ' ' || *p == '\t')
1865 disable_display_command (char *args, int from_tty)
1873 for (d = display_chain; d; d = d->next)
1880 while (*p1 >= '0' && *p1 <= '9')
1882 if (*p1 && *p1 != ' ' && *p1 != '\t')
1883 error (_("Arguments must be display numbers."));
1885 disable_display (atoi (p));
1888 while (*p == ' ' || *p == '\t')
1893 /* display_chain items point to blocks and expressions. Some expressions in
1894 turn may point to symbols.
1895 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1896 obstack_free'd when a shared library is unloaded.
1897 Clear pointers that are about to become dangling.
1898 Both .exp and .block fields will be restored next time we need to display
1899 an item by re-parsing .exp_string field in the new execution context. */
1902 clear_dangling_display_expressions (struct so_list *solib)
1904 struct objfile *objfile = solib->objfile;
1907 /* With no symbol file we cannot have a block or expression from it. */
1908 if (objfile == NULL)
1910 if (objfile->separate_debug_objfile_backlink)
1911 objfile = objfile->separate_debug_objfile_backlink;
1912 gdb_assert (objfile->pspace == solib->pspace);
1914 for (d = display_chain; d != NULL; d = d->next)
1916 if (d->pspace != solib->pspace)
1919 if (lookup_objfile_from_block (d->block) == objfile
1920 || (d->exp && exp_uses_objfile (d->exp, objfile)))
1930 /* Print the value in stack frame FRAME of a variable specified by a
1931 struct symbol. NAME is the name to print; if NULL then VAR's print
1932 name will be used. STREAM is the ui_file on which to print the
1933 value. INDENT specifies the number of indent levels to print
1934 before printing the variable name. */
1937 print_variable_and_value (const char *name, struct symbol *var,
1938 struct frame_info *frame,
1939 struct ui_file *stream, int indent)
1942 struct value_print_options opts;
1945 name = SYMBOL_PRINT_NAME (var);
1947 fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
1949 val = read_var_value (var, frame);
1950 get_user_print_options (&opts);
1951 common_val_print (val, stream, indent, &opts, current_language);
1952 fprintf_filtered (stream, "\n");
1956 printf_command (char *arg, int from_tty)
1960 char *string = NULL;
1961 struct value **val_args;
1963 char *current_substring;
1965 int allocated_args = 20;
1966 struct cleanup *old_cleanups;
1968 val_args = xmalloc (allocated_args * sizeof (struct value *));
1969 old_cleanups = make_cleanup (free_current_contents, &val_args);
1972 error_no_arg (_("format-control string and values to print"));
1974 /* Skip white space before format string */
1975 while (*s == ' ' || *s == '\t')
1978 /* A format string should follow, enveloped in double quotes. */
1980 error (_("Bad format string, missing '\"'."));
1982 /* Parse the format-control string and copy it into the string STRING,
1983 processing some kinds of escape sequence. */
1985 f = string = (char *) alloca (strlen (s) + 1);
1993 error (_("Bad format string, non-terminated '\"'."));
2026 /* ??? TODO: handle other escape sequences */
2027 error (_("Unrecognized escape character \\%c in format string."),
2037 /* Skip over " and following space and comma. */
2040 while (*s == ' ' || *s == '\t')
2043 if (*s != ',' && *s != 0)
2044 error (_("Invalid argument syntax"));
2048 while (*s == ' ' || *s == '\t')
2051 /* Need extra space for the '\0's. Doubling the size is sufficient. */
2052 substrings = alloca (strlen (string) * 2);
2053 current_substring = substrings;
2056 /* Now scan the string for %-specs and see what kinds of args they want.
2057 argclass[I] classifies the %-specs so we can give printf_filtered
2058 something of the right size. */
2062 int_arg, long_arg, long_long_arg, ptr_arg,
2063 string_arg, wide_string_arg, wide_char_arg,
2064 double_arg, long_double_arg, decfloat_arg
2066 enum argclass *argclass;
2067 enum argclass this_argclass;
2072 argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
2079 int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
2080 int seen_space = 0, seen_plus = 0;
2081 int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
2082 int seen_big_d = 0, seen_double_big_d = 0;
2085 /* Check the validity of the format specifier, and work
2086 out what argument it expects. We only accept C89
2087 format strings, with the exception of long long (which
2088 we autoconf for). */
2090 /* Skip over "%%". */
2097 /* The first part of a format specifier is a set of flag
2099 while (strchr ("0-+ #", *f))
2112 /* The next part of a format specifier is a width. */
2113 while (strchr ("0123456789", *f))
2116 /* The next part of a format specifier is a precision. */
2121 while (strchr ("0123456789", *f))
2125 /* The next part of a format specifier is a length modifier. */
2146 /* Decimal32 modifier. */
2152 /* Decimal64 and Decimal128 modifiers. */
2157 /* Check for a Decimal128. */
2161 seen_double_big_d = 1;
2177 if (seen_space || seen_plus)
2184 this_argclass = int_arg;
2185 else if (lcount == 1)
2186 this_argclass = long_arg;
2188 this_argclass = long_long_arg;
2195 this_argclass = lcount == 0 ? int_arg : wide_char_arg;
2196 if (lcount > 1 || seen_h || seen_big_l)
2198 if (seen_prec || seen_zero || seen_space || seen_plus)
2203 this_argclass = ptr_arg;
2204 if (lcount || seen_h || seen_big_l)
2206 if (seen_prec || seen_zero || seen_space || seen_plus)
2211 this_argclass = lcount == 0 ? string_arg : wide_string_arg;
2212 if (lcount > 1 || seen_h || seen_big_l)
2214 if (seen_zero || seen_space || seen_plus)
2223 if (seen_big_h || seen_big_d || seen_double_big_d)
2224 this_argclass = decfloat_arg;
2225 else if (seen_big_l)
2226 this_argclass = long_double_arg;
2228 this_argclass = double_arg;
2230 if (lcount || seen_h)
2235 error (_("`*' not supported for precision or width in printf"));
2238 error (_("Format specifier `n' not supported in printf"));
2241 error (_("Incomplete format specifier at end of format string"));
2244 error (_("Unrecognized format specifier '%c' in printf"), *f);
2248 error (_("Inappropriate modifiers to format specifier '%c' in printf"),
2253 if (lcount > 1 && USE_PRINTF_I64)
2255 /* Windows' printf does support long long, but not the usual way.
2256 Convert %lld to %I64d. */
2257 int length_before_ll = f - last_arg - 1 - lcount;
2258 strncpy (current_substring, last_arg, length_before_ll);
2259 strcpy (current_substring + length_before_ll, "I64");
2260 current_substring[length_before_ll + 3] =
2261 last_arg[length_before_ll + lcount];
2262 current_substring += length_before_ll + 4;
2264 else if (this_argclass == wide_string_arg
2265 || this_argclass == wide_char_arg)
2267 /* Convert %ls or %lc to %s. */
2268 int length_before_ls = f - last_arg - 2;
2269 strncpy (current_substring, last_arg, length_before_ls);
2270 strcpy (current_substring + length_before_ls, "s");
2271 current_substring += length_before_ls + 2;
2275 strncpy (current_substring, last_arg, f - last_arg);
2276 current_substring += f - last_arg;
2278 *current_substring++ = '\0';
2280 argclass[nargs_wanted++] = this_argclass;
2283 /* Now, parse all arguments and evaluate them.
2284 Store the VALUEs in VAL_ARGS. */
2289 if (nargs == allocated_args)
2290 val_args = (struct value **) xrealloc ((char *) val_args,
2291 (allocated_args *= 2)
2292 * sizeof (struct value *));
2294 val_args[nargs] = parse_to_comma_and_eval (&s1);
2302 if (nargs != nargs_wanted)
2303 error (_("Wrong number of arguments for specified format-string"));
2305 /* Now actually print them. */
2306 current_substring = substrings;
2307 for (i = 0; i < nargs; i++)
2309 switch (argclass[i])
2316 tem = value_as_address (val_args[i]);
2318 /* This is a %s argument. Find the length of the string. */
2323 read_memory (tem + j, &c, 1);
2328 /* Copy the string contents into a string inside GDB. */
2329 str = (gdb_byte *) alloca (j + 1);
2331 read_memory (tem, str, j);
2334 printf_filtered (current_substring, (char *) str);
2337 case wide_string_arg:
2342 struct gdbarch *gdbarch
2343 = get_type_arch (value_type (val_args[i]));
2344 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2345 struct type *wctype = lookup_typename (current_language, gdbarch,
2346 "wchar_t", NULL, 0);
2347 int wcwidth = TYPE_LENGTH (wctype);
2348 gdb_byte *buf = alloca (wcwidth);
2349 struct obstack output;
2350 struct cleanup *inner_cleanup;
2352 tem = value_as_address (val_args[i]);
2354 /* This is a %s argument. Find the length of the string. */
2355 for (j = 0;; j += wcwidth)
2358 read_memory (tem + j, buf, wcwidth);
2359 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2363 /* Copy the string contents into a string inside GDB. */
2364 str = (gdb_byte *) alloca (j + wcwidth);
2366 read_memory (tem, str, j);
2367 memset (&str[j], 0, wcwidth);
2369 obstack_init (&output);
2370 inner_cleanup = make_cleanup_obstack_free (&output);
2372 convert_between_encodings (target_wide_charset (gdbarch),
2375 &output, translit_char);
2376 obstack_grow_str0 (&output, "");
2378 printf_filtered (current_substring, obstack_base (&output));
2379 do_cleanups (inner_cleanup);
2384 struct gdbarch *gdbarch
2385 = get_type_arch (value_type (val_args[i]));
2386 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2387 struct type *wctype = lookup_typename (current_language, gdbarch,
2388 "wchar_t", NULL, 0);
2389 struct type *valtype;
2390 struct obstack output;
2391 struct cleanup *inner_cleanup;
2392 const gdb_byte *bytes;
2394 valtype = value_type (val_args[i]);
2395 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2396 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2397 error (_("expected wchar_t argument for %%lc"));
2399 bytes = value_contents (val_args[i]);
2401 obstack_init (&output);
2402 inner_cleanup = make_cleanup_obstack_free (&output);
2404 convert_between_encodings (target_wide_charset (gdbarch),
2406 bytes, TYPE_LENGTH (valtype),
2407 TYPE_LENGTH (valtype),
2408 &output, translit_char);
2409 obstack_grow_str0 (&output, "");
2411 printf_filtered (current_substring, obstack_base (&output));
2412 do_cleanups (inner_cleanup);
2417 struct type *type = value_type (val_args[i]);
2421 /* If format string wants a float, unchecked-convert the value
2422 to floating point of the same size. */
2423 type = float_type_from_length (type);
2424 val = unpack_double (type, value_contents (val_args[i]), &inv);
2426 error (_("Invalid floating value found in program."));
2428 printf_filtered (current_substring, (double) val);
2431 case long_double_arg:
2432 #ifdef HAVE_LONG_DOUBLE
2434 struct type *type = value_type (val_args[i]);
2438 /* If format string wants a float, unchecked-convert the value
2439 to floating point of the same size. */
2440 type = float_type_from_length (type);
2441 val = unpack_double (type, value_contents (val_args[i]), &inv);
2443 error (_("Invalid floating value found in program."));
2445 printf_filtered (current_substring, (long double) val);
2449 error (_("long double not supported in printf"));
2452 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2454 long long val = value_as_long (val_args[i]);
2455 printf_filtered (current_substring, val);
2459 error (_("long long not supported in printf"));
2463 int val = value_as_long (val_args[i]);
2464 printf_filtered (current_substring, val);
2469 long val = value_as_long (val_args[i]);
2470 printf_filtered (current_substring, val);
2474 /* Handles decimal floating values. */
2477 const gdb_byte *param_ptr = value_contents (val_args[i]);
2478 #if defined (PRINTF_HAS_DECFLOAT)
2479 /* If we have native support for Decimal floating
2480 printing, handle it here. */
2481 printf_filtered (current_substring, param_ptr);
2484 /* As a workaround until vasprintf has native support for DFP
2485 we convert the DFP values to string and print them using
2486 the %s format specifier. */
2489 int nnull_chars = 0;
2491 /* Parameter data. */
2492 struct type *param_type = value_type (val_args[i]);
2493 unsigned int param_len = TYPE_LENGTH (param_type);
2494 struct gdbarch *gdbarch = get_type_arch (param_type);
2495 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2497 /* DFP output data. */
2498 struct value *dfp_value = NULL;
2502 struct type *dfp_type = NULL;
2503 char decstr[MAX_DECIMAL_STRING];
2505 /* Points to the end of the string so that we can go back
2506 and check for DFP length modifiers. */
2507 eos = current_substring + strlen (current_substring);
2509 /* Look for the float/double format specifier. */
2510 while (*eos != 'f' && *eos != 'e' && *eos != 'E'
2511 && *eos != 'g' && *eos != 'G')
2516 /* Search for the '%' char and extract the size and type of
2517 the output decimal value based on its modifiers
2518 (%Hf, %Df, %DDf). */
2519 while (*--sos != '%')
2524 dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2526 else if (*sos == 'D' && *(sos - 1) == 'D')
2529 dfp_type = builtin_type (gdbarch)->builtin_declong;
2535 dfp_type = builtin_type (gdbarch)->builtin_decdouble;
2539 /* Replace %Hf, %Df and %DDf with %s's. */
2542 /* Go through the whole format string and pull the correct
2543 number of chars back to compensate for the change in the
2544 format specifier. */
2545 while (nnull_chars < nargs - i)
2553 /* Conversion between different DFP types. */
2554 if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2555 decimal_convert (param_ptr, param_len, byte_order,
2556 dec, dfp_len, byte_order);
2558 /* If this is a non-trivial conversion, just output 0.
2559 A correct converted value can be displayed by explicitly
2560 casting to a DFP type. */
2561 decimal_from_string (dec, dfp_len, byte_order, "0");
2563 dfp_value = value_from_decfloat (dfp_type, dec);
2565 dfp_ptr = (gdb_byte *) value_contents (dfp_value);
2567 decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
2569 /* Print the DFP value. */
2570 printf_filtered (current_substring, decstr);
2578 /* We avoid the host's %p because pointers are too
2579 likely to be the wrong size. The only interesting
2580 modifier for %p is a width; extract that, and then
2581 handle %p as glibc would: %#x or a literal "(nil)". */
2583 char *p, *fmt, *fmt_p;
2584 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2585 long long val = value_as_long (val_args[i]);
2587 long val = value_as_long (val_args[i]);
2590 fmt = alloca (strlen (current_substring) + 5);
2592 /* Copy up to the leading %. */
2593 p = current_substring;
2597 int is_percent = (*p == '%');
2611 /* Copy any width. */
2612 while (*p >= '0' && *p < '9')
2615 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2618 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2624 printf_filtered (fmt, val);
2630 printf_filtered (fmt, "(nil)");
2636 internal_error (__FILE__, __LINE__,
2637 _("failed internal consistency check"));
2639 /* Skip to the next substring. */
2640 current_substring += strlen (current_substring) + 1;
2642 /* Print the portion of the format string after the last argument.
2643 Note that this will not include any ordinary %-specs, but it
2644 might include "%%". That is why we use printf_filtered and not
2645 puts_filtered here. Also, we pass a dummy argument because
2646 some platforms have modified GCC to include -Wformat-security
2647 by default, which will warn here if there is no argument. */
2648 printf_filtered (last_arg, 0);
2650 do_cleanups (old_cleanups);
2654 _initialize_printcmd (void)
2656 struct cmd_list_element *c;
2658 current_display_number = -1;
2660 observer_attach_solib_unloaded (clear_dangling_display_expressions);
2662 add_info ("address", address_info,
2663 _("Describe where symbol SYM is stored."));
2665 add_info ("symbol", sym_info, _("\
2666 Describe what symbol is at location ADDR.\n\
2667 Only for symbols with fixed locations (global or static scope)."));
2669 add_com ("x", class_vars, x_command, _("\
2670 Examine memory: x/FMT ADDRESS.\n\
2671 ADDRESS is an expression for the memory address to examine.\n\
2672 FMT is a repeat count followed by a format letter and a size letter.\n\
2673 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2674 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2675 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2676 The specified number of objects of the specified size are printed\n\
2677 according to the format.\n\n\
2678 Defaults for format and size letters are those previously used.\n\
2679 Default count is 1. Default address is following last thing printed\n\
2680 with this command or \"print\"."));
2683 add_com ("whereis", class_vars, whereis_command,
2684 _("Print line number and file of definition of variable."));
2687 add_info ("display", display_info, _("\
2688 Expressions to display when program stops, with code numbers."));
2690 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2691 Cancel some expressions to be displayed when program stops.\n\
2692 Arguments are the code numbers of the expressions to stop displaying.\n\
2693 No argument means cancel all automatic-display expressions.\n\
2694 \"delete display\" has the same effect as this command.\n\
2695 Do \"info display\" to see current list of code numbers."),
2698 add_com ("display", class_vars, display_command, _("\
2699 Print value of expression EXP each time the program stops.\n\
2700 /FMT may be used before EXP as in the \"print\" command.\n\
2701 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2702 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2703 and examining is done as in the \"x\" command.\n\n\
2704 With no argument, display all currently requested auto-display expressions.\n\
2705 Use \"undisplay\" to cancel display requests previously made."));
2707 add_cmd ("display", class_vars, enable_display, _("\
2708 Enable some expressions to be displayed when program stops.\n\
2709 Arguments are the code numbers of the expressions to resume displaying.\n\
2710 No argument means enable all automatic-display expressions.\n\
2711 Do \"info display\" to see current list of code numbers."), &enablelist);
2713 add_cmd ("display", class_vars, disable_display_command, _("\
2714 Disable some expressions to be displayed when program stops.\n\
2715 Arguments are the code numbers of the expressions to stop displaying.\n\
2716 No argument means disable all automatic-display expressions.\n\
2717 Do \"info display\" to see current list of code numbers."), &disablelist);
2719 add_cmd ("display", class_vars, undisplay_command, _("\
2720 Cancel some expressions to be displayed when program stops.\n\
2721 Arguments are the code numbers of the expressions to stop displaying.\n\
2722 No argument means cancel all automatic-display expressions.\n\
2723 Do \"info display\" to see current list of code numbers."), &deletelist);
2725 add_com ("printf", class_vars, printf_command, _("\
2726 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2727 This is useful for formatted output in user-defined commands."));
2729 add_com ("output", class_vars, output_command, _("\
2730 Like \"print\" but don't put in value history and don't print newline.\n\
2731 This is useful in user-defined commands."));
2733 add_prefix_cmd ("set", class_vars, set_command, _("\
2734 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2735 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2736 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2737 with $), a register (a few standard names starting with $), or an actual\n\
2738 variable in the program being debugged. EXP is any valid expression.\n\
2739 Use \"set variable\" for variables with names identical to set subcommands.\n\
2741 With a subcommand, this command modifies parts of the gdb environment.\n\
2742 You can see these environment settings with the \"show\" command."),
2743 &setlist, "set ", 1, &cmdlist);
2745 add_com ("assign", class_vars, set_command, _("\
2746 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2747 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2748 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2749 with $), a register (a few standard names starting with $), or an actual\n\
2750 variable in the program being debugged. EXP is any valid expression.\n\
2751 Use \"set variable\" for variables with names identical to set subcommands.\n\
2752 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2753 You can see these environment settings with the \"show\" command."));
2755 /* "call" is the same as "set", but handy for dbx users to call fns. */
2756 c = add_com ("call", class_vars, call_command, _("\
2757 Call a function in the program.\n\
2758 The argument is the function name and arguments, in the notation of the\n\
2759 current working language. The result is printed and saved in the value\n\
2760 history, if it is not void."));
2761 set_cmd_completer (c, expression_completer);
2763 add_cmd ("variable", class_vars, set_command, _("\
2764 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2765 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2766 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2767 with $), a register (a few standard names starting with $), or an actual\n\
2768 variable in the program being debugged. EXP is any valid expression.\n\
2769 This may usually be abbreviated to simply \"set\"."),
2772 c = add_com ("print", class_vars, print_command, _("\
2773 Print value of expression EXP.\n\
2774 Variables accessible are those of the lexical environment of the selected\n\
2775 stack frame, plus all those whose scope is global or an entire file.\n\
2777 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2778 $$NUM refers to NUM'th value back from the last one.\n\
2779 Names starting with $ refer to registers (with the values they would have\n\
2780 if the program were to return to the stack frame now selected, restoring\n\
2781 all registers saved by frames farther in) or else to debugger\n\
2782 \"convenience\" variables (any such name not a known register).\n\
2783 Use assignment expressions to give values to convenience variables.\n\
2785 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2786 @ is a binary operator for treating consecutive data objects\n\
2787 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2788 element is FOO, whose second element is stored in the space following\n\
2789 where FOO is stored, etc. FOO must be an expression whose value\n\
2790 resides in memory.\n\
2792 EXP may be preceded with /FMT, where FMT is a format letter\n\
2793 but no count or size letter (see \"x\" command)."));
2794 set_cmd_completer (c, expression_completer);
2795 add_com_alias ("p", "print", class_vars, 1);
2797 c = add_com ("inspect", class_vars, inspect_command, _("\
2798 Same as \"print\" command, except that if you are running in the epoch\n\
2799 environment, the value is printed in its own window."));
2800 set_cmd_completer (c, expression_completer);
2802 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2803 &max_symbolic_offset, _("\
2804 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2805 Show the largest offset that will be printed in <symbol+1234> form."), NULL,
2807 show_max_symbolic_offset,
2808 &setprintlist, &showprintlist);
2809 add_setshow_boolean_cmd ("symbol-filename", no_class,
2810 &print_symbol_filename, _("\
2811 Set printing of source filename and line number with <symbol>."), _("\
2812 Show printing of source filename and line number with <symbol>."), NULL,
2814 show_print_symbol_filename,
2815 &setprintlist, &showprintlist);