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 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"
50 #include "parser-defs.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;
138 /* The expression as the user typed it. */
140 /* Expression to be evaluated and displayed. */
141 struct expression *exp;
142 /* Item number of this auto-display item. */
144 /* Display format specified. */
145 struct format_data format;
146 /* Innermost block required by this expression when evaluated */
148 /* Status of this display (enabled or disabled) */
152 /* Chain of expressions whose values should be displayed
153 automatically each time the program stops. */
155 static struct display *display_chain;
157 static int display_number;
159 /* Prototypes for exported functions. */
161 void output_command (char *, int);
163 void _initialize_printcmd (void);
165 /* Prototypes for local functions. */
167 static void do_one_display (struct display *);
170 /* Decode a format specification. *STRING_PTR should point to it.
171 OFORMAT and OSIZE are used as defaults for the format and size
172 if none are given in the format specification.
173 If OSIZE is zero, then the size field of the returned value
174 should be set only if a size is explicitly specified by the
176 The structure returned describes all the data
177 found in the specification. In addition, *STRING_PTR is advanced
178 past the specification and past all whitespace following it. */
180 static struct format_data
181 decode_format (char **string_ptr, int oformat, int osize)
183 struct format_data val;
184 char *p = *string_ptr;
191 if (*p >= '0' && *p <= '9')
192 val.count = atoi (p);
193 while (*p >= '0' && *p <= '9')
196 /* Now process size or format letters that follow. */
200 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
207 else if (*p >= 'a' && *p <= 'z')
213 while (*p == ' ' || *p == '\t')
217 /* Set defaults for format and size if not specified. */
218 if (val.format == '?')
222 /* Neither has been specified. */
223 val.format = oformat;
227 /* If a size is specified, any format makes a reasonable
228 default except 'i'. */
229 val.format = oformat == 'i' ? 'x' : oformat;
231 else if (val.size == '?')
235 /* Pick the appropriate size for an address. This is deferred
236 until do_examine when we know the actual architecture to use.
237 A special size value of 'a' is used to indicate this case. */
238 val.size = osize ? 'a' : osize;
241 /* Floating point has to be word or giantword. */
242 if (osize == 'w' || osize == 'g')
245 /* Default it to giantword if the last used size is not
247 val.size = osize ? 'g' : osize;
250 /* Characters default to one byte. */
251 val.size = osize ? 'b' : osize;
254 /* The default is the size most recently specified. */
261 /* Print value VAL on stream according to OPTIONS.
262 Do not end with a newline.
263 SIZE is the letter for the size of datum being printed.
264 This is used to pad hex numbers so they line up. SIZE is 0
265 for print / output and set for examine. */
268 print_formatted (struct value *val, int size,
269 const struct value_print_options *options,
270 struct ui_file *stream)
272 struct type *type = check_typedef (value_type (val));
273 int len = TYPE_LENGTH (type);
275 if (VALUE_LVAL (val) == lval_memory)
276 next_address = value_address (val) + len;
280 switch (options->format)
284 struct type *elttype = value_type (val);
285 next_address = (value_address (val)
286 + val_print_string (elttype,
287 value_address (val), -1,
293 /* We often wrap here if there are long symbolic names. */
295 next_address = (value_address (val)
296 + gdb_print_insn (get_type_arch (type),
297 value_address (val), stream,
298 &branch_delay_insns));
303 if (options->format == 0 || options->format == 's'
304 || TYPE_CODE (type) == TYPE_CODE_REF
305 || TYPE_CODE (type) == TYPE_CODE_ARRAY
306 || TYPE_CODE (type) == TYPE_CODE_STRING
307 || TYPE_CODE (type) == TYPE_CODE_STRUCT
308 || TYPE_CODE (type) == TYPE_CODE_UNION
309 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
310 value_print (val, stream, options);
312 /* User specified format, so don't look to the the type to
313 tell us what to do. */
314 print_scalar_formatted (value_contents (val), type,
315 options, size, stream);
318 /* Return builtin floating point type of same length as TYPE.
319 If no such type is found, return TYPE itself. */
321 float_type_from_length (struct type *type)
323 struct gdbarch *gdbarch = get_type_arch (type);
324 const struct builtin_type *builtin = builtin_type (gdbarch);
325 unsigned int len = TYPE_LENGTH (type);
327 if (len == TYPE_LENGTH (builtin->builtin_float))
328 type = builtin->builtin_float;
329 else if (len == TYPE_LENGTH (builtin->builtin_double))
330 type = builtin->builtin_double;
331 else if (len == TYPE_LENGTH (builtin->builtin_long_double))
332 type = builtin->builtin_long_double;
337 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
338 according to OPTIONS and SIZE on STREAM.
339 Formats s and i are not supported at this level.
341 This is how the elements of an array or structure are printed
345 print_scalar_formatted (const void *valaddr, struct type *type,
346 const struct value_print_options *options,
347 int size, struct ui_file *stream)
349 struct gdbarch *gdbarch = get_type_arch (type);
350 LONGEST val_long = 0;
351 unsigned int len = TYPE_LENGTH (type);
352 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
354 /* If we get here with a string format, try again without it. Go
355 all the way back to the language printers, which may call us
357 if (options->format == 's')
359 struct value_print_options opts = *options;
362 val_print (type, valaddr, 0, 0, stream, 0, &opts,
367 if (len > sizeof(LONGEST) &&
368 (TYPE_CODE (type) == TYPE_CODE_INT
369 || TYPE_CODE (type) == TYPE_CODE_ENUM))
371 switch (options->format)
374 print_octal_chars (stream, valaddr, len, byte_order);
378 print_decimal_chars (stream, valaddr, len, byte_order);
381 print_binary_chars (stream, valaddr, len, byte_order);
384 print_hex_chars (stream, valaddr, len, byte_order);
387 print_char_chars (stream, type, valaddr, len, byte_order);
394 if (options->format != 'f')
395 val_long = unpack_long (type, valaddr);
397 /* If the value is a pointer, and pointers and addresses are not the
398 same, then at this point, the value's length (in target bytes) is
399 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
400 if (TYPE_CODE (type) == TYPE_CODE_PTR)
401 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
403 /* If we are printing it as unsigned, truncate it in case it is actually
404 a negative signed value (e.g. "print/u (short)-1" should print 65535
405 (if shorts are 16 bits) instead of 4294967295). */
406 if (options->format != 'd' || TYPE_UNSIGNED (type))
408 if (len < sizeof (LONGEST))
409 val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
412 switch (options->format)
417 /* No size specified, like in print. Print varying # of digits. */
418 print_longest (stream, 'x', 1, val_long);
427 print_longest (stream, size, 1, val_long);
430 error (_("Undefined output size \"%c\"."), size);
435 print_longest (stream, 'd', 1, val_long);
439 print_longest (stream, 'u', 0, val_long);
444 print_longest (stream, 'o', 1, val_long);
446 fprintf_filtered (stream, "0");
451 CORE_ADDR addr = unpack_pointer (type, valaddr);
452 print_address (addr, stream);
458 struct value_print_options opts = *options;
461 if (TYPE_UNSIGNED (type))
462 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
464 type = builtin_type (gdbarch)->builtin_true_char;
466 value_print (value_from_longest (type, val_long), stream, &opts);
471 type = float_type_from_length (type);
472 print_floating (valaddr, type, stream);
476 internal_error (__FILE__, __LINE__,
477 _("failed internal consistency check"));
480 /* Binary; 't' stands for "two". */
482 char bits[8 * (sizeof val_long) + 1];
483 char buf[8 * (sizeof val_long) + 32];
488 width = 8 * (sizeof val_long);
505 error (_("Undefined output size \"%c\"."), size);
511 bits[width] = (val_long & 1) ? '1' : '0';
516 while (*cp && *cp == '0')
522 fputs_filtered (buf, stream);
527 error (_("Undefined output format \"%c\"."), options->format);
531 /* Specify default address for `x' command.
532 The `info lines' command uses this. */
535 set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
537 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
539 next_gdbarch = gdbarch;
542 /* Make address available to the user as $_. */
543 set_internalvar (lookup_internalvar ("_"),
544 value_from_pointer (ptr_type, addr));
547 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
548 after LEADIN. Print nothing if no symbolic name is found nearby.
549 Optionally also print source file and line number, if available.
550 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
551 or to interpret it as a possible C++ name and convert it back to source
552 form. However note that DO_DEMANGLE can be overridden by the specific
553 settings of the demangle and asm_demangle variables. */
556 print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
557 int do_demangle, char *leadin)
560 char *filename = NULL;
565 /* Throw away both name and filename. */
566 struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
567 make_cleanup (free_current_contents, &filename);
569 if (build_address_symbolic (addr, do_demangle, &name, &offset,
570 &filename, &line, &unmapped))
572 do_cleanups (cleanup_chain);
576 fputs_filtered (leadin, stream);
578 fputs_filtered ("<*", stream);
580 fputs_filtered ("<", stream);
581 fputs_filtered (name, stream);
583 fprintf_filtered (stream, "+%u", (unsigned int) offset);
585 /* Append source filename and line number if desired. Give specific
586 line # of this addr, if we have it; else line # of the nearest symbol. */
587 if (print_symbol_filename && filename != NULL)
590 fprintf_filtered (stream, " at %s:%d", filename, line);
592 fprintf_filtered (stream, " in %s", filename);
595 fputs_filtered ("*>", stream);
597 fputs_filtered (">", stream);
599 do_cleanups (cleanup_chain);
602 /* Given an address ADDR return all the elements needed to print the
603 address in a symbolic form. NAME can be mangled or not depending
604 on DO_DEMANGLE (and also on the asm_demangle global variable,
605 manipulated via ''set print asm-demangle''). Return 0 in case of
606 success, when all the info in the OUT paramters is valid. Return 1
609 build_address_symbolic (CORE_ADDR addr, /* IN */
610 int do_demangle, /* IN */
611 char **name, /* OUT */
612 int *offset, /* OUT */
613 char **filename, /* OUT */
615 int *unmapped) /* OUT */
617 struct minimal_symbol *msymbol;
618 struct symbol *symbol;
619 CORE_ADDR name_location = 0;
620 struct obj_section *section = NULL;
621 char *name_temp = "";
623 /* Let's say it is mapped (not unmapped). */
626 /* Determine if the address is in an overlay, and whether it is
628 if (overlay_debugging)
630 section = find_pc_overlay (addr);
631 if (pc_in_unmapped_range (addr, section))
634 addr = overlay_mapped_address (addr, section);
638 /* First try to find the address in the symbol table, then
639 in the minsyms. Take the closest one. */
641 /* This is defective in the sense that it only finds text symbols. So
642 really this is kind of pointless--we should make sure that the
643 minimal symbols have everything we need (by changing that we could
644 save some memory, but for many debug format--ELF/DWARF or
645 anything/stabs--it would be inconvenient to eliminate those minimal
647 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
648 symbol = find_pc_sect_function (addr, section);
652 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
653 if (do_demangle || asm_demangle)
654 name_temp = SYMBOL_PRINT_NAME (symbol);
656 name_temp = SYMBOL_LINKAGE_NAME (symbol);
661 if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
663 /* The msymbol is closer to the address than the symbol;
664 use the msymbol instead. */
666 name_location = SYMBOL_VALUE_ADDRESS (msymbol);
667 if (do_demangle || asm_demangle)
668 name_temp = SYMBOL_PRINT_NAME (msymbol);
670 name_temp = SYMBOL_LINKAGE_NAME (msymbol);
673 if (symbol == NULL && msymbol == NULL)
676 /* If the nearest symbol is too far away, don't print anything symbolic. */
678 /* For when CORE_ADDR is larger than unsigned int, we do math in
679 CORE_ADDR. But when we detect unsigned wraparound in the
680 CORE_ADDR math, we ignore this test and print the offset,
681 because addr+max_symbolic_offset has wrapped through the end
682 of the address space back to the beginning, giving bogus comparison. */
683 if (addr > name_location + max_symbolic_offset
684 && name_location + max_symbolic_offset > name_location)
687 *offset = addr - name_location;
689 *name = xstrdup (name_temp);
691 if (print_symbol_filename)
693 struct symtab_and_line sal;
695 sal = find_pc_sect_line (addr, section, 0);
699 *filename = xstrdup (sal.symtab->filename);
707 /* Print address ADDR symbolically on STREAM.
708 First print it as a number. Then perhaps print
709 <SYMBOL + OFFSET> after the number. */
712 print_address (CORE_ADDR addr, struct ui_file *stream)
714 fputs_filtered (paddress (addr), stream);
715 print_address_symbolic (addr, stream, asm_demangle, " ");
718 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
719 controls whether to print the symbolic name "raw" or demangled.
720 Global setting "addressprint" controls whether to print hex address
724 print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
727 struct value_print_options opts;
728 get_user_print_options (&opts);
731 fprintf_filtered (stream, "0");
733 else if (opts.addressprint)
735 fputs_filtered (paddress (addr), stream);
736 print_address_symbolic (addr, stream, do_demangle, " ");
740 print_address_symbolic (addr, stream, do_demangle, "");
745 /* Examine data at address ADDR in format FMT.
746 Fetch it from memory and print on gdb_stdout. */
749 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
754 struct type *val_type = NULL;
757 struct value_print_options opts;
762 next_gdbarch = gdbarch;
765 /* String or instruction format implies fetch single bytes
766 regardless of the specified size. */
767 if (format == 's' || format == 'i')
772 /* Pick the appropriate size for an address. */
773 if (gdbarch_ptr_bit (next_gdbarch) == 64)
775 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
777 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
780 /* Bad value for gdbarch_ptr_bit. */
781 internal_error (__FILE__, __LINE__,
782 _("failed internal consistency check"));
786 val_type = builtin_type (next_gdbarch)->builtin_int8;
787 else if (size == 'h')
788 val_type = builtin_type (next_gdbarch)->builtin_int16;
789 else if (size == 'w')
790 val_type = builtin_type (next_gdbarch)->builtin_int32;
791 else if (size == 'g')
792 val_type = builtin_type (next_gdbarch)->builtin_int64;
799 if (format == 's' || format == 'i')
802 get_formatted_print_options (&opts, format);
804 /* Print as many objects as specified in COUNT, at most maxelts per line,
805 with the address of the next one at the start of each line. */
810 print_address (next_address, gdb_stdout);
811 printf_filtered (":");
816 printf_filtered ("\t");
817 /* Note that print_formatted sets next_address for the next
819 last_examine_address = next_address;
821 if (last_examine_value)
822 value_free (last_examine_value);
824 /* The value to be displayed is not fetched greedily.
825 Instead, to avoid the possibility of a fetched value not
826 being used, its retrieval is delayed until the print code
827 uses it. When examining an instruction stream, the
828 disassembler will perform its own memory fetch using just
829 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
830 the disassembler be modified so that LAST_EXAMINE_VALUE
831 is left with the byte sequence from the last complete
832 instruction fetched from memory? */
833 last_examine_value = value_at_lazy (val_type, next_address);
835 if (last_examine_value)
836 release_value (last_examine_value);
838 print_formatted (last_examine_value, size, &opts, gdb_stdout);
840 /* Display any branch delay slots following the final insn. */
841 if (format == 'i' && count == 1)
842 count += branch_delay_insns;
844 printf_filtered ("\n");
845 gdb_flush (gdb_stdout);
850 validate_format (struct format_data fmt, char *cmdname)
853 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
855 error (_("Item count other than 1 is meaningless in \"%s\" command."),
857 if (fmt.format == 'i')
858 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
859 fmt.format, cmdname);
862 /* Evaluate string EXP as an expression in the current language and
863 print the resulting value. EXP may contain a format specifier as the
864 first argument ("/x myvar" for example, to print myvar in hex). */
867 print_command_1 (char *exp, int inspect, int voidprint)
869 struct expression *expr;
870 struct cleanup *old_chain = 0;
873 struct format_data fmt;
876 if (exp && *exp == '/')
879 fmt = decode_format (&exp, last_format, 0);
880 validate_format (fmt, "print");
881 last_format = format = fmt.format;
894 expr = parse_expression (exp);
895 old_chain = make_cleanup (free_current_contents, &expr);
897 val = evaluate_expression (expr);
900 val = access_value_history (0);
902 if (voidprint || (val && value_type (val) &&
903 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
905 struct value_print_options opts;
906 int histindex = record_latest_value (val);
909 annotate_value_history_begin (histindex, value_type (val));
911 annotate_value_begin (value_type (val));
914 printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"",
916 else if (histindex >= 0)
917 printf_filtered ("$%d = ", histindex);
920 annotate_value_history_value ();
922 get_formatted_print_options (&opts, format);
923 opts.inspect_it = inspect;
926 print_formatted (val, fmt.size, &opts, gdb_stdout);
927 printf_filtered ("\n");
930 annotate_value_history_end ();
932 annotate_value_end ();
935 printf_unfiltered ("\") )\030");
939 do_cleanups (old_chain);
943 print_command (char *exp, int from_tty)
945 print_command_1 (exp, 0, 1);
948 /* Same as print, except in epoch, it gets its own window. */
950 inspect_command (char *exp, int from_tty)
952 extern int epoch_interface;
954 print_command_1 (exp, epoch_interface, 1);
957 /* Same as print, except it doesn't print void results. */
959 call_command (char *exp, int from_tty)
961 print_command_1 (exp, 0, 0);
965 output_command (char *exp, int from_tty)
967 struct expression *expr;
968 struct cleanup *old_chain;
971 struct format_data fmt;
972 struct value_print_options opts;
977 if (exp && *exp == '/')
980 fmt = decode_format (&exp, 0, 0);
981 validate_format (fmt, "output");
985 expr = parse_expression (exp);
986 old_chain = make_cleanup (free_current_contents, &expr);
988 val = evaluate_expression (expr);
990 annotate_value_begin (value_type (val));
992 get_formatted_print_options (&opts, format);
994 print_formatted (val, fmt.size, &opts, gdb_stdout);
996 annotate_value_end ();
999 gdb_flush (gdb_stdout);
1001 do_cleanups (old_chain);
1005 set_command (char *exp, int from_tty)
1007 struct expression *expr = parse_expression (exp);
1008 struct cleanup *old_chain =
1009 make_cleanup (free_current_contents, &expr);
1010 evaluate_expression (expr);
1011 do_cleanups (old_chain);
1015 sym_info (char *arg, int from_tty)
1017 struct minimal_symbol *msymbol;
1018 struct objfile *objfile;
1019 struct obj_section *osect;
1020 CORE_ADDR addr, sect_addr;
1022 unsigned int offset;
1025 error_no_arg (_("address"));
1027 addr = parse_and_eval_address (arg);
1028 ALL_OBJSECTIONS (objfile, osect)
1030 /* Only process each object file once, even if there's a separate
1032 if (objfile->separate_debug_objfile_backlink)
1035 sect_addr = overlay_mapped_address (addr, osect);
1037 if (obj_section_addr (osect) <= sect_addr
1038 && sect_addr < obj_section_endaddr (osect)
1039 && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
1041 const char *obj_name, *mapped, *sec_name, *msym_name;
1043 struct cleanup *old_chain;
1046 offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
1047 mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
1048 sec_name = osect->the_bfd_section->name;
1049 msym_name = SYMBOL_PRINT_NAME (msymbol);
1051 /* Don't print the offset if it is zero.
1052 We assume there's no need to handle i18n of "sym + offset". */
1054 loc_string = xstrprintf ("%s + %u", msym_name, offset);
1056 loc_string = xstrprintf ("%s", msym_name);
1058 /* Use a cleanup to free loc_string in case the user quits
1059 a pagination request inside printf_filtered. */
1060 old_chain = make_cleanup (xfree, loc_string);
1062 gdb_assert (osect->objfile && osect->objfile->name);
1063 obj_name = osect->objfile->name;
1065 if (MULTI_OBJFILE_P ())
1066 if (pc_in_unmapped_range (addr, osect))
1067 if (section_is_overlay (osect))
1068 printf_filtered (_("%s in load address range of "
1069 "%s overlay section %s of %s\n"),
1070 loc_string, mapped, sec_name, obj_name);
1072 printf_filtered (_("%s in load address range of "
1073 "section %s of %s\n"),
1074 loc_string, sec_name, obj_name);
1076 if (section_is_overlay (osect))
1077 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1078 loc_string, mapped, sec_name, obj_name);
1080 printf_filtered (_("%s in section %s of %s\n"),
1081 loc_string, sec_name, obj_name);
1083 if (pc_in_unmapped_range (addr, osect))
1084 if (section_is_overlay (osect))
1085 printf_filtered (_("%s in load address range of %s overlay "
1087 loc_string, mapped, sec_name);
1089 printf_filtered (_("%s in load address range of section %s\n"),
1090 loc_string, sec_name);
1092 if (section_is_overlay (osect))
1093 printf_filtered (_("%s in %s overlay section %s\n"),
1094 loc_string, mapped, sec_name);
1096 printf_filtered (_("%s in section %s\n"),
1097 loc_string, sec_name);
1099 do_cleanups (old_chain);
1103 printf_filtered (_("No symbol matches %s.\n"), arg);
1107 address_info (char *exp, int from_tty)
1109 struct gdbarch *gdbarch;
1112 struct minimal_symbol *msymbol;
1114 struct obj_section *section;
1115 CORE_ADDR load_addr;
1116 int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
1117 if exp is a field of `this'. */
1120 error (_("Argument required."));
1122 sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
1123 &is_a_field_of_this);
1126 if (is_a_field_of_this)
1128 printf_filtered ("Symbol \"");
1129 fprintf_symbol_filtered (gdb_stdout, exp,
1130 current_language->la_language, DMGL_ANSI);
1131 printf_filtered ("\" is a field of the local class variable ");
1132 if (current_language->la_language == language_objc)
1133 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1135 printf_filtered ("`this'\n");
1139 msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1141 if (msymbol != NULL)
1143 load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1145 printf_filtered ("Symbol \"");
1146 fprintf_symbol_filtered (gdb_stdout, exp,
1147 current_language->la_language, DMGL_ANSI);
1148 printf_filtered ("\" is at ");
1149 fputs_filtered (paddress (load_addr), gdb_stdout);
1150 printf_filtered (" in a file compiled without debugging");
1151 section = SYMBOL_OBJ_SECTION (msymbol);
1152 if (section_is_overlay (section))
1154 load_addr = overlay_unmapped_address (load_addr, section);
1155 printf_filtered (",\n -- loaded at ");
1156 fputs_filtered (paddress (load_addr), gdb_stdout);
1157 printf_filtered (" in overlay section %s",
1158 section->the_bfd_section->name);
1160 printf_filtered (".\n");
1163 error (_("No symbol \"%s\" in current context."), exp);
1167 printf_filtered ("Symbol \"");
1168 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
1169 current_language->la_language, DMGL_ANSI);
1170 printf_filtered ("\" is ");
1171 val = SYMBOL_VALUE (sym);
1172 section = SYMBOL_OBJ_SECTION (sym);
1173 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
1175 switch (SYMBOL_CLASS (sym))
1178 case LOC_CONST_BYTES:
1179 printf_filtered ("constant");
1183 printf_filtered ("a label at address ");
1184 fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
1186 if (section_is_overlay (section))
1188 load_addr = overlay_unmapped_address (load_addr, section);
1189 printf_filtered (",\n -- loaded at ");
1190 fputs_filtered (paddress (load_addr), gdb_stdout);
1191 printf_filtered (" in overlay section %s",
1192 section->the_bfd_section->name);
1197 /* FIXME: cagney/2004-01-26: It should be possible to
1198 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
1199 Unfortunately DWARF 2 stores the frame-base (instead of the
1200 function) location in a function's symbol. Oops! For the
1201 moment enable this when/where applicable. */
1202 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
1206 /* GDBARCH is the architecture associated with the objfile the symbol
1207 is defined in; the target architecture may be different, and may
1208 provide additional registers. However, we do not know the target
1209 architecture at this point. We assume the objfile architecture
1210 will contain all the standard registers that occur in debug info
1212 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1214 if (SYMBOL_IS_ARGUMENT (sym))
1215 printf_filtered (_("an argument in register %s"),
1216 gdbarch_register_name (gdbarch, regno));
1218 printf_filtered (_("a variable in register %s"),
1219 gdbarch_register_name (gdbarch, regno));
1223 printf_filtered (_("static storage at address "));
1224 fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
1226 if (section_is_overlay (section))
1228 load_addr = overlay_unmapped_address (load_addr, section);
1229 printf_filtered (_(",\n -- loaded at "));
1230 fputs_filtered (paddress (load_addr), gdb_stdout);
1231 printf_filtered (_(" in overlay section %s"),
1232 section->the_bfd_section->name);
1236 case LOC_REGPARM_ADDR:
1237 /* Note comment at LOC_REGISTER. */
1238 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1239 printf_filtered (_("address of an argument in register %s"),
1240 gdbarch_register_name (gdbarch, regno));
1244 printf_filtered (_("an argument at offset %ld"), val);
1248 printf_filtered (_("a local variable at frame offset %ld"), val);
1252 printf_filtered (_("a reference argument at offset %ld"), val);
1256 printf_filtered (_("a typedef"));
1260 printf_filtered (_("a function at address "));
1261 load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1262 fputs_filtered (paddress (load_addr), gdb_stdout);
1263 if (section_is_overlay (section))
1265 load_addr = overlay_unmapped_address (load_addr, section);
1266 printf_filtered (_(",\n -- loaded at "));
1267 fputs_filtered (paddress (load_addr), gdb_stdout);
1268 printf_filtered (_(" in overlay section %s"),
1269 section->the_bfd_section->name);
1273 case LOC_UNRESOLVED:
1275 struct minimal_symbol *msym;
1277 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
1279 printf_filtered ("unresolved");
1282 section = SYMBOL_OBJ_SECTION (msym);
1283 load_addr = SYMBOL_VALUE_ADDRESS (msym);
1286 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1287 printf_filtered (_("a thread-local variable at offset %s "
1288 "in the thread-local storage for `%s'"),
1289 paddr_nz (load_addr), section->objfile->name);
1292 printf_filtered (_("static storage at address "));
1293 fputs_filtered (paddress (load_addr), gdb_stdout);
1294 if (section_is_overlay (section))
1296 load_addr = overlay_unmapped_address (load_addr, section);
1297 printf_filtered (_(",\n -- loaded at "));
1298 fputs_filtered (paddress (load_addr), gdb_stdout);
1299 printf_filtered (_(" in overlay section %s"),
1300 section->the_bfd_section->name);
1307 case LOC_OPTIMIZED_OUT:
1308 printf_filtered (_("optimized out"));
1312 printf_filtered (_("of unknown (botched) type"));
1315 printf_filtered (".\n");
1320 x_command (char *exp, int from_tty)
1322 struct expression *expr;
1323 struct format_data fmt;
1324 struct cleanup *old_chain;
1327 fmt.format = last_format ? last_format : 'x';
1328 fmt.size = last_size;
1332 if (exp && *exp == '/')
1335 fmt = decode_format (&exp, last_format, last_size);
1338 /* If we have an expression, evaluate it and use it as the address. */
1340 if (exp != 0 && *exp != 0)
1342 expr = parse_expression (exp);
1343 /* Cause expression not to be there any more if this command is
1344 repeated with Newline. But don't clobber a user-defined
1345 command's definition. */
1348 old_chain = make_cleanup (free_current_contents, &expr);
1349 val = evaluate_expression (expr);
1350 if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1351 val = value_ind (val);
1352 /* In rvalue contexts, such as this, functions are coerced into
1353 pointers to functions. This makes "x/i main" work. */
1354 if (/* last_format == 'i' && */
1355 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1356 && VALUE_LVAL (val) == lval_memory)
1357 next_address = value_address (val);
1359 next_address = value_as_address (val);
1361 next_gdbarch = expr->gdbarch;
1362 do_cleanups (old_chain);
1366 error_no_arg (_("starting display address"));
1368 do_examine (fmt, next_gdbarch, next_address);
1370 /* If the examine succeeds, we remember its size and format for next
1372 last_size = fmt.size;
1373 last_format = fmt.format;
1375 /* Set a couple of internal variables if appropriate. */
1376 if (last_examine_value)
1378 /* Make last address examined available to the user as $_. Use
1379 the correct pointer type. */
1380 struct type *pointer_type
1381 = lookup_pointer_type (value_type (last_examine_value));
1382 set_internalvar (lookup_internalvar ("_"),
1383 value_from_pointer (pointer_type,
1384 last_examine_address));
1386 /* Make contents of last address examined available to the user
1387 as $__. If the last value has not been fetched from memory
1388 then don't fetch it now; instead mark it by voiding the $__
1390 if (value_lazy (last_examine_value))
1391 clear_internalvar (lookup_internalvar ("__"));
1393 set_internalvar (lookup_internalvar ("__"), last_examine_value);
1398 /* Add an expression to the auto-display chain.
1399 Specify the expression. */
1402 display_command (char *exp, int from_tty)
1404 struct format_data fmt;
1405 struct expression *expr;
1406 struct display *new;
1410 /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1412 if (tui_active && exp != NULL && *exp == '$')
1413 display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
1427 fmt = decode_format (&exp, 0, 0);
1428 if (fmt.size && fmt.format == 0)
1430 if (fmt.format == 'i' || fmt.format == 's')
1441 innermost_block = NULL;
1442 expr = parse_expression (exp);
1444 new = (struct display *) xmalloc (sizeof (struct display));
1446 new->exp_string = xstrdup (exp);
1448 new->block = innermost_block;
1449 new->next = display_chain;
1450 new->number = ++display_number;
1453 display_chain = new;
1455 if (from_tty && target_has_execution)
1456 do_one_display (new);
1463 free_display (struct display *d)
1465 xfree (d->exp_string);
1470 /* Clear out the display_chain. Done when new symtabs are loaded,
1471 since this invalidates the types stored in many expressions. */
1474 clear_displays (void)
1478 while ((d = display_chain) != NULL)
1480 display_chain = d->next;
1485 /* Delete the auto-display number NUM. */
1488 delete_display (int num)
1490 struct display *d1, *d;
1493 error (_("No display number %d."), num);
1495 if (display_chain->number == num)
1498 display_chain = d1->next;
1502 for (d = display_chain;; d = d->next)
1505 error (_("No display number %d."), num);
1506 if (d->next->number == num)
1516 /* Delete some values from the auto-display chain.
1517 Specify the element numbers. */
1520 undisplay_command (char *args, int from_tty)
1528 if (query (_("Delete all auto-display expressions? ")))
1537 while (*p1 >= '0' && *p1 <= '9')
1539 if (*p1 && *p1 != ' ' && *p1 != '\t')
1540 error (_("Arguments must be display numbers."));
1544 delete_display (num);
1547 while (*p == ' ' || *p == '\t')
1553 /* Display a single auto-display.
1554 Do nothing if the display cannot be printed in the current context,
1555 or if the display is disabled. */
1558 do_one_display (struct display *d)
1560 int within_current_scope;
1562 if (d->enabled_p == 0)
1567 volatile struct gdb_exception ex;
1568 TRY_CATCH (ex, RETURN_MASK_ALL)
1570 innermost_block = NULL;
1571 d->exp = parse_expression (d->exp_string);
1572 d->block = innermost_block;
1576 /* Can't re-parse the expression. Disable this display item. */
1578 warning (_("Unable to display \"%s\": %s"),
1579 d->exp_string, ex.message);
1585 within_current_scope = contained_in (get_selected_block (0), d->block);
1587 within_current_scope = 1;
1588 if (!within_current_scope)
1591 current_display_number = d->number;
1593 annotate_display_begin ();
1594 printf_filtered ("%d", d->number);
1595 annotate_display_number_end ();
1596 printf_filtered (": ");
1602 annotate_display_format ();
1604 printf_filtered ("x/");
1605 if (d->format.count != 1)
1606 printf_filtered ("%d", d->format.count);
1607 printf_filtered ("%c", d->format.format);
1608 if (d->format.format != 'i' && d->format.format != 's')
1609 printf_filtered ("%c", d->format.size);
1610 printf_filtered (" ");
1612 annotate_display_expression ();
1614 puts_filtered (d->exp_string);
1615 annotate_display_expression_end ();
1617 if (d->format.count != 1 || d->format.format == 'i')
1618 printf_filtered ("\n");
1620 printf_filtered (" ");
1622 val = evaluate_expression (d->exp);
1623 addr = value_as_address (val);
1624 if (d->format.format == 'i')
1625 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1627 annotate_display_value ();
1629 do_examine (d->format, d->exp->gdbarch, addr);
1633 struct value_print_options opts;
1635 annotate_display_format ();
1637 if (d->format.format)
1638 printf_filtered ("/%c ", d->format.format);
1640 annotate_display_expression ();
1642 puts_filtered (d->exp_string);
1643 annotate_display_expression_end ();
1645 printf_filtered (" = ");
1647 annotate_display_expression ();
1649 get_formatted_print_options (&opts, d->format.format);
1650 opts.raw = d->format.raw;
1651 print_formatted (evaluate_expression (d->exp),
1652 d->format.size, &opts, gdb_stdout);
1653 printf_filtered ("\n");
1656 annotate_display_end ();
1658 gdb_flush (gdb_stdout);
1659 current_display_number = -1;
1662 /* Display all of the values on the auto-display chain which can be
1663 evaluated in the current scope. */
1670 for (d = display_chain; d; d = d->next)
1674 /* Delete the auto-display which we were in the process of displaying.
1675 This is done when there is an error or a signal. */
1678 disable_display (int num)
1682 for (d = display_chain; d; d = d->next)
1683 if (d->number == num)
1688 printf_unfiltered (_("No display number %d.\n"), num);
1692 disable_current_display (void)
1694 if (current_display_number >= 0)
1696 disable_display (current_display_number);
1697 fprintf_unfiltered (gdb_stderr, _("\
1698 Disabling display %d to avoid infinite recursion.\n"),
1699 current_display_number);
1701 current_display_number = -1;
1705 display_info (char *ignore, int from_tty)
1710 printf_unfiltered (_("There are no auto-display expressions now.\n"));
1712 printf_filtered (_("Auto-display expressions now in effect:\n\
1713 Num Enb Expression\n"));
1715 for (d = display_chain; d; d = d->next)
1717 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
1719 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1721 else if (d->format.format)
1722 printf_filtered ("/%c ", d->format.format);
1723 puts_filtered (d->exp_string);
1724 if (d->block && !contained_in (get_selected_block (0), d->block))
1725 printf_filtered (_(" (cannot be evaluated in the current context)"));
1726 printf_filtered ("\n");
1727 gdb_flush (gdb_stdout);
1732 enable_display (char *args, int from_tty)
1741 for (d = display_chain; d; d = d->next)
1748 while (*p1 >= '0' && *p1 <= '9')
1750 if (*p1 && *p1 != ' ' && *p1 != '\t')
1751 error (_("Arguments must be display numbers."));
1755 for (d = display_chain; d; d = d->next)
1756 if (d->number == num)
1761 printf_unfiltered (_("No display number %d.\n"), num);
1764 while (*p == ' ' || *p == '\t')
1770 disable_display_command (char *args, int from_tty)
1778 for (d = display_chain; d; d = d->next)
1785 while (*p1 >= '0' && *p1 <= '9')
1787 if (*p1 && *p1 != ' ' && *p1 != '\t')
1788 error (_("Arguments must be display numbers."));
1790 disable_display (atoi (p));
1793 while (*p == ' ' || *p == '\t')
1798 /* Return 1 if D uses SOLIB (and will become dangling when SOLIB
1799 is unloaded), otherwise return 0. */
1802 display_uses_solib_p (const struct display *d,
1803 const struct so_list *solib)
1806 struct expression *const exp = d->exp;
1807 const union exp_element *const elts = exp->elts;
1809 if (d->block != NULL
1810 && solib_contains_address_p (solib, d->block->startaddr))
1813 for (endpos = exp->nelts; endpos > 0; )
1815 int i, args, oplen = 0;
1817 exp->language_defn->la_exp_desc->operator_length (exp, endpos,
1819 gdb_assert (oplen > 0);
1822 if (elts[i].opcode == OP_VAR_VALUE)
1824 const struct block *const block = elts[i + 1].block;
1825 const struct symbol *const symbol = elts[i + 2].symbol;
1826 const struct obj_section *const section =
1827 SYMBOL_OBJ_SECTION (symbol);
1830 && solib_contains_address_p (solib, block->startaddr))
1833 if (section && section->objfile == solib->objfile)
1842 /* display_chain items point to blocks and expressions. Some expressions in
1843 turn may point to symbols.
1844 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1845 obstack_free'd when a shared library is unloaded.
1846 Clear pointers that are about to become dangling.
1847 Both .exp and .block fields will be restored next time we need to display
1848 an item by re-parsing .exp_string field in the new execution context. */
1851 clear_dangling_display_expressions (struct so_list *solib)
1854 struct objfile *objfile = NULL;
1856 for (d = display_chain; d; d = d->next)
1858 if (d->exp && display_uses_solib_p (d, solib))
1868 /* Print the value in stack frame FRAME of a variable specified by a
1869 struct symbol. NAME is the name to print; if NULL then VAR's print
1870 name will be used. STREAM is the ui_file on which to print the
1871 value. INDENT specifies the number of indent levels to print
1872 before printing the variable name. */
1875 print_variable_and_value (const char *name, struct symbol *var,
1876 struct frame_info *frame,
1877 struct ui_file *stream, int indent)
1880 struct value_print_options opts;
1883 name = SYMBOL_PRINT_NAME (var);
1885 fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
1887 val = read_var_value (var, frame);
1888 get_user_print_options (&opts);
1889 common_val_print (val, stream, indent, &opts, current_language);
1890 fprintf_filtered (stream, "\n");
1894 printf_command (char *arg, int from_tty)
1898 char *string = NULL;
1899 struct value **val_args;
1901 char *current_substring;
1903 int allocated_args = 20;
1904 struct cleanup *old_cleanups;
1906 val_args = xmalloc (allocated_args * sizeof (struct value *));
1907 old_cleanups = make_cleanup (free_current_contents, &val_args);
1910 error_no_arg (_("format-control string and values to print"));
1912 /* Skip white space before format string */
1913 while (*s == ' ' || *s == '\t')
1916 /* A format string should follow, enveloped in double quotes. */
1918 error (_("Bad format string, missing '\"'."));
1920 /* Parse the format-control string and copy it into the string STRING,
1921 processing some kinds of escape sequence. */
1923 f = string = (char *) alloca (strlen (s) + 1);
1931 error (_("Bad format string, non-terminated '\"'."));
1964 /* ??? TODO: handle other escape sequences */
1965 error (_("Unrecognized escape character \\%c in format string."),
1975 /* Skip over " and following space and comma. */
1978 while (*s == ' ' || *s == '\t')
1981 if (*s != ',' && *s != 0)
1982 error (_("Invalid argument syntax"));
1986 while (*s == ' ' || *s == '\t')
1989 /* Need extra space for the '\0's. Doubling the size is sufficient. */
1990 substrings = alloca (strlen (string) * 2);
1991 current_substring = substrings;
1994 /* Now scan the string for %-specs and see what kinds of args they want.
1995 argclass[I] classifies the %-specs so we can give printf_filtered
1996 something of the right size. */
2000 int_arg, long_arg, long_long_arg, ptr_arg,
2001 string_arg, wide_string_arg, wide_char_arg,
2002 double_arg, long_double_arg, decfloat_arg
2004 enum argclass *argclass;
2005 enum argclass this_argclass;
2010 argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
2017 int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
2018 int seen_space = 0, seen_plus = 0;
2019 int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
2020 int seen_big_d = 0, seen_double_big_d = 0;
2023 /* Check the validity of the format specifier, and work
2024 out what argument it expects. We only accept C89
2025 format strings, with the exception of long long (which
2026 we autoconf for). */
2028 /* Skip over "%%". */
2035 /* The first part of a format specifier is a set of flag
2037 while (strchr ("0-+ #", *f))
2050 /* The next part of a format specifier is a width. */
2051 while (strchr ("0123456789", *f))
2054 /* The next part of a format specifier is a precision. */
2059 while (strchr ("0123456789", *f))
2063 /* The next part of a format specifier is a length modifier. */
2084 /* Decimal32 modifier. */
2090 /* Decimal64 and Decimal128 modifiers. */
2095 /* Check for a Decimal128. */
2099 seen_double_big_d = 1;
2115 if (seen_space || seen_plus)
2122 this_argclass = int_arg;
2123 else if (lcount == 1)
2124 this_argclass = long_arg;
2126 this_argclass = long_long_arg;
2133 this_argclass = lcount == 0 ? int_arg : wide_char_arg;
2134 if (lcount > 1 || seen_h || seen_big_l)
2136 if (seen_prec || seen_zero || seen_space || seen_plus)
2141 this_argclass = ptr_arg;
2142 if (lcount || seen_h || seen_big_l)
2144 if (seen_prec || seen_zero || seen_space || seen_plus)
2149 this_argclass = lcount == 0 ? string_arg : wide_string_arg;
2150 if (lcount > 1 || seen_h || seen_big_l)
2152 if (seen_zero || seen_space || seen_plus)
2161 if (seen_big_h || seen_big_d || seen_double_big_d)
2162 this_argclass = decfloat_arg;
2163 else if (seen_big_l)
2164 this_argclass = long_double_arg;
2166 this_argclass = double_arg;
2168 if (lcount || seen_h)
2173 error (_("`*' not supported for precision or width in printf"));
2176 error (_("Format specifier `n' not supported in printf"));
2179 error (_("Incomplete format specifier at end of format string"));
2182 error (_("Unrecognized format specifier '%c' in printf"), *f);
2186 error (_("Inappropriate modifiers to format specifier '%c' in printf"),
2191 if (lcount > 1 && USE_PRINTF_I64)
2193 /* Windows' printf does support long long, but not the usual way.
2194 Convert %lld to %I64d. */
2195 int length_before_ll = f - last_arg - 1 - lcount;
2196 strncpy (current_substring, last_arg, length_before_ll);
2197 strcpy (current_substring + length_before_ll, "I64");
2198 current_substring[length_before_ll + 3] =
2199 last_arg[length_before_ll + lcount];
2200 current_substring += length_before_ll + 4;
2202 else if (this_argclass == wide_string_arg
2203 || this_argclass == wide_char_arg)
2205 /* Convert %ls or %lc to %s. */
2206 int length_before_ls = f - last_arg - 2;
2207 strncpy (current_substring, last_arg, length_before_ls);
2208 strcpy (current_substring + length_before_ls, "s");
2209 current_substring += length_before_ls + 2;
2213 strncpy (current_substring, last_arg, f - last_arg);
2214 current_substring += f - last_arg;
2216 *current_substring++ = '\0';
2218 argclass[nargs_wanted++] = this_argclass;
2221 /* Now, parse all arguments and evaluate them.
2222 Store the VALUEs in VAL_ARGS. */
2227 if (nargs == allocated_args)
2228 val_args = (struct value **) xrealloc ((char *) val_args,
2229 (allocated_args *= 2)
2230 * sizeof (struct value *));
2232 val_args[nargs] = parse_to_comma_and_eval (&s1);
2240 if (nargs != nargs_wanted)
2241 error (_("Wrong number of arguments for specified format-string"));
2243 /* Now actually print them. */
2244 current_substring = substrings;
2245 for (i = 0; i < nargs; i++)
2247 switch (argclass[i])
2254 tem = value_as_address (val_args[i]);
2256 /* This is a %s argument. Find the length of the string. */
2261 read_memory (tem + j, &c, 1);
2266 /* Copy the string contents into a string inside GDB. */
2267 str = (gdb_byte *) alloca (j + 1);
2269 read_memory (tem, str, j);
2272 printf_filtered (current_substring, (char *) str);
2275 case wide_string_arg:
2280 struct gdbarch *gdbarch
2281 = get_type_arch (value_type (val_args[i]));
2282 struct type *wctype = lookup_typename (current_language, gdbarch,
2283 "wchar_t", NULL, 0);
2284 int wcwidth = TYPE_LENGTH (wctype);
2285 gdb_byte *buf = alloca (wcwidth);
2286 struct obstack output;
2287 struct cleanup *inner_cleanup;
2289 tem = value_as_address (val_args[i]);
2291 /* This is a %s argument. Find the length of the string. */
2292 for (j = 0;; j += wcwidth)
2295 read_memory (tem + j, buf, wcwidth);
2296 if (extract_unsigned_integer (buf, wcwidth) == 0)
2300 /* Copy the string contents into a string inside GDB. */
2301 str = (gdb_byte *) alloca (j + wcwidth);
2303 read_memory (tem, str, j);
2304 memset (&str[j], 0, wcwidth);
2306 obstack_init (&output);
2307 inner_cleanup = make_cleanup_obstack_free (&output);
2309 convert_between_encodings (target_wide_charset (),
2312 &output, translit_char);
2313 obstack_grow_str0 (&output, "");
2315 printf_filtered (current_substring, obstack_base (&output));
2316 do_cleanups (inner_cleanup);
2321 struct gdbarch *gdbarch
2322 = get_type_arch (value_type (val_args[i]));
2323 struct type *wctype = lookup_typename (current_language, gdbarch,
2324 "wchar_t", NULL, 0);
2325 struct type *valtype;
2326 struct obstack output;
2327 struct cleanup *inner_cleanup;
2328 const gdb_byte *bytes;
2330 valtype = value_type (val_args[i]);
2331 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2332 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2333 error (_("expected wchar_t argument for %%lc"));
2335 bytes = value_contents (val_args[i]);
2337 obstack_init (&output);
2338 inner_cleanup = make_cleanup_obstack_free (&output);
2340 convert_between_encodings (target_wide_charset (),
2342 bytes, TYPE_LENGTH (valtype),
2343 TYPE_LENGTH (valtype),
2344 &output, translit_char);
2345 obstack_grow_str0 (&output, "");
2347 printf_filtered (current_substring, obstack_base (&output));
2348 do_cleanups (inner_cleanup);
2353 struct type *type = value_type (val_args[i]);
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);
2362 error (_("Invalid floating value found in program."));
2364 printf_filtered (current_substring, (double) val);
2367 case long_double_arg:
2368 #ifdef HAVE_LONG_DOUBLE
2370 struct type *type = value_type (val_args[i]);
2374 /* If format string wants a float, unchecked-convert the value
2375 to floating point of the same size. */
2376 type = float_type_from_length (type);
2377 val = unpack_double (type, value_contents (val_args[i]), &inv);
2379 error (_("Invalid floating value found in program."));
2381 printf_filtered (current_substring, (long double) val);
2385 error (_("long double not supported in printf"));
2388 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2390 long long val = value_as_long (val_args[i]);
2391 printf_filtered (current_substring, val);
2395 error (_("long long not supported in printf"));
2399 int val = value_as_long (val_args[i]);
2400 printf_filtered (current_substring, val);
2405 long val = value_as_long (val_args[i]);
2406 printf_filtered (current_substring, val);
2410 /* Handles decimal floating values. */
2413 const gdb_byte *param_ptr = value_contents (val_args[i]);
2414 #if defined (PRINTF_HAS_DECFLOAT)
2415 /* If we have native support for Decimal floating
2416 printing, handle it here. */
2417 printf_filtered (current_substring, param_ptr);
2420 /* As a workaround until vasprintf has native support for DFP
2421 we convert the DFP values to string and print them using
2422 the %s format specifier. */
2425 int nnull_chars = 0;
2427 /* Parameter data. */
2428 struct type *param_type = value_type (val_args[i]);
2429 unsigned int param_len = TYPE_LENGTH (param_type);
2430 struct gdbarch *gdbarch = get_type_arch (param_type);
2432 /* DFP output data. */
2433 struct value *dfp_value = NULL;
2437 struct type *dfp_type = NULL;
2438 char decstr[MAX_DECIMAL_STRING];
2440 /* Points to the end of the string so that we can go back
2441 and check for DFP length modifiers. */
2442 eos = current_substring + strlen (current_substring);
2444 /* Look for the float/double format specifier. */
2445 while (*eos != 'f' && *eos != 'e' && *eos != 'E'
2446 && *eos != 'g' && *eos != 'G')
2451 /* Search for the '%' char and extract the size and type of
2452 the output decimal value based on its modifiers
2453 (%Hf, %Df, %DDf). */
2454 while (*--sos != '%')
2459 dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2461 else if (*sos == 'D' && *(sos - 1) == 'D')
2464 dfp_type = builtin_type (gdbarch)->builtin_declong;
2470 dfp_type = builtin_type (gdbarch)->builtin_decdouble;
2474 /* Replace %Hf, %Df and %DDf with %s's. */
2477 /* Go through the whole format string and pull the correct
2478 number of chars back to compensate for the change in the
2479 format specifier. */
2480 while (nnull_chars < nargs - i)
2488 /* Conversion between different DFP types. */
2489 if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2490 decimal_convert (param_ptr, param_len, dec, dfp_len);
2492 /* If this is a non-trivial conversion, just output 0.
2493 A correct converted value can be displayed by explicitly
2494 casting to a DFP type. */
2495 decimal_from_string (dec, dfp_len, "0");
2497 dfp_value = value_from_decfloat (dfp_type, dec);
2499 dfp_ptr = (gdb_byte *) value_contents (dfp_value);
2501 decimal_to_string (dfp_ptr, dfp_len, decstr);
2503 /* Print the DFP value. */
2504 printf_filtered (current_substring, decstr);
2512 /* We avoid the host's %p because pointers are too
2513 likely to be the wrong size. The only interesting
2514 modifier for %p is a width; extract that, and then
2515 handle %p as glibc would: %#x or a literal "(nil)". */
2517 char *p, *fmt, *fmt_p;
2518 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2519 long long val = value_as_long (val_args[i]);
2521 long val = value_as_long (val_args[i]);
2524 fmt = alloca (strlen (current_substring) + 5);
2526 /* Copy up to the leading %. */
2527 p = current_substring;
2531 int is_percent = (*p == '%');
2545 /* Copy any width. */
2546 while (*p >= '0' && *p < '9')
2549 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2552 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2558 printf_filtered (fmt, val);
2564 printf_filtered (fmt, "(nil)");
2570 internal_error (__FILE__, __LINE__,
2571 _("failed internal consistency check"));
2573 /* Skip to the next substring. */
2574 current_substring += strlen (current_substring) + 1;
2576 /* Print the portion of the format string after the last argument. */
2577 puts_filtered (last_arg);
2579 do_cleanups (old_cleanups);
2583 _initialize_printcmd (void)
2585 struct cmd_list_element *c;
2587 current_display_number = -1;
2589 observer_attach_solib_unloaded (clear_dangling_display_expressions);
2591 add_info ("address", address_info,
2592 _("Describe where symbol SYM is stored."));
2594 add_info ("symbol", sym_info, _("\
2595 Describe what symbol is at location ADDR.\n\
2596 Only for symbols with fixed locations (global or static scope)."));
2598 add_com ("x", class_vars, x_command, _("\
2599 Examine memory: x/FMT ADDRESS.\n\
2600 ADDRESS is an expression for the memory address to examine.\n\
2601 FMT is a repeat count followed by a format letter and a size letter.\n\
2602 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2603 t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2604 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2605 The specified number of objects of the specified size are printed\n\
2606 according to the format.\n\n\
2607 Defaults for format and size letters are those previously used.\n\
2608 Default count is 1. Default address is following last thing printed\n\
2609 with this command or \"print\"."));
2612 add_com ("whereis", class_vars, whereis_command,
2613 _("Print line number and file of definition of variable."));
2616 add_info ("display", display_info, _("\
2617 Expressions to display when program stops, with code numbers."));
2619 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2620 Cancel some expressions to be displayed when program stops.\n\
2621 Arguments are the code numbers of the expressions to stop displaying.\n\
2622 No argument means cancel all automatic-display expressions.\n\
2623 \"delete display\" has the same effect as this command.\n\
2624 Do \"info display\" to see current list of code numbers."),
2627 add_com ("display", class_vars, display_command, _("\
2628 Print value of expression EXP each time the program stops.\n\
2629 /FMT may be used before EXP as in the \"print\" command.\n\
2630 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2631 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2632 and examining is done as in the \"x\" command.\n\n\
2633 With no argument, display all currently requested auto-display expressions.\n\
2634 Use \"undisplay\" to cancel display requests previously made."));
2636 add_cmd ("display", class_vars, enable_display, _("\
2637 Enable some expressions to be displayed when program stops.\n\
2638 Arguments are the code numbers of the expressions to resume displaying.\n\
2639 No argument means enable all automatic-display expressions.\n\
2640 Do \"info display\" to see current list of code numbers."), &enablelist);
2642 add_cmd ("display", class_vars, disable_display_command, _("\
2643 Disable some expressions to be displayed when program stops.\n\
2644 Arguments are the code numbers of the expressions to stop displaying.\n\
2645 No argument means disable all automatic-display expressions.\n\
2646 Do \"info display\" to see current list of code numbers."), &disablelist);
2648 add_cmd ("display", class_vars, undisplay_command, _("\
2649 Cancel some expressions to be displayed when program stops.\n\
2650 Arguments are the code numbers of the expressions to stop displaying.\n\
2651 No argument means cancel all automatic-display expressions.\n\
2652 Do \"info display\" to see current list of code numbers."), &deletelist);
2654 add_com ("printf", class_vars, printf_command, _("\
2655 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2656 This is useful for formatted output in user-defined commands."));
2658 add_com ("output", class_vars, output_command, _("\
2659 Like \"print\" but don't put in value history and don't print newline.\n\
2660 This is useful in user-defined commands."));
2662 add_prefix_cmd ("set", class_vars, set_command, _("\
2663 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2664 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2665 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2666 with $), a register (a few standard names starting with $), or an actual\n\
2667 variable in the program being debugged. EXP is any valid expression.\n\
2668 Use \"set variable\" for variables with names identical to set subcommands.\n\
2670 With a subcommand, this command modifies parts of the gdb environment.\n\
2671 You can see these environment settings with the \"show\" command."),
2672 &setlist, "set ", 1, &cmdlist);
2674 add_com ("assign", class_vars, set_command, _("\
2675 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2676 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2677 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2678 with $), a register (a few standard names starting with $), or an actual\n\
2679 variable in the program being debugged. EXP is any valid expression.\n\
2680 Use \"set variable\" for variables with names identical to set subcommands.\n\
2681 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2682 You can see these environment settings with the \"show\" command."));
2684 /* "call" is the same as "set", but handy for dbx users to call fns. */
2685 c = add_com ("call", class_vars, call_command, _("\
2686 Call a function in the program.\n\
2687 The argument is the function name and arguments, in the notation of the\n\
2688 current working language. The result is printed and saved in the value\n\
2689 history, if it is not void."));
2690 set_cmd_completer (c, expression_completer);
2692 add_cmd ("variable", class_vars, set_command, _("\
2693 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2694 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2695 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2696 with $), a register (a few standard names starting with $), or an actual\n\
2697 variable in the program being debugged. EXP is any valid expression.\n\
2698 This may usually be abbreviated to simply \"set\"."),
2701 c = add_com ("print", class_vars, print_command, _("\
2702 Print value of expression EXP.\n\
2703 Variables accessible are those of the lexical environment of the selected\n\
2704 stack frame, plus all those whose scope is global or an entire file.\n\
2706 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2707 $$NUM refers to NUM'th value back from the last one.\n\
2708 Names starting with $ refer to registers (with the values they would have\n\
2709 if the program were to return to the stack frame now selected, restoring\n\
2710 all registers saved by frames farther in) or else to debugger\n\
2711 \"convenience\" variables (any such name not a known register).\n\
2712 Use assignment expressions to give values to convenience variables.\n\
2714 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2715 @ is a binary operator for treating consecutive data objects\n\
2716 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2717 element is FOO, whose second element is stored in the space following\n\
2718 where FOO is stored, etc. FOO must be an expression whose value\n\
2719 resides in memory.\n\
2721 EXP may be preceded with /FMT, where FMT is a format letter\n\
2722 but no count or size letter (see \"x\" command)."));
2723 set_cmd_completer (c, expression_completer);
2724 add_com_alias ("p", "print", class_vars, 1);
2726 c = add_com ("inspect", class_vars, inspect_command, _("\
2727 Same as \"print\" command, except that if you are running in the epoch\n\
2728 environment, the value is printed in its own window."));
2729 set_cmd_completer (c, expression_completer);
2731 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2732 &max_symbolic_offset, _("\
2733 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2734 Show the largest offset that will be printed in <symbol+1234> form."), NULL,
2736 show_max_symbolic_offset,
2737 &setprintlist, &showprintlist);
2738 add_setshow_boolean_cmd ("symbol-filename", no_class,
2739 &print_symbol_filename, _("\
2740 Set printing of source filename and line number with <symbol>."), _("\
2741 Show printing of source filename and line number with <symbol>."), NULL,
2743 show_print_symbol_filename,
2744 &setprintlist, &showprintlist);