1 /* Print values for GNU debugger GDB.
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
30 #include "breakpoint.h"
32 #include "gdb-demangle.h"
35 #include "symfile.h" /* for overlay functions */
36 #include "objfiles.h" /* ditto */
37 #include "completer.h" /* for completion functions */
41 #include "target-float.h"
42 #include "observable.h"
44 #include "parser-defs.h"
46 #include "arch-utils.h"
47 #include "cli/cli-utils.h"
48 #include "cli/cli-script.h"
49 #include "cli/cli-style.h"
52 #include "common/byte-vector.h"
54 /* Last specified output format. */
56 static char last_format = 0;
58 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
60 static char last_size = 'w';
62 /* Last specified count for the 'x' command. */
64 static int last_count;
66 /* Default address to examine next, and associated architecture. */
68 static struct gdbarch *next_gdbarch;
69 static CORE_ADDR next_address;
71 /* Number of delay instructions following current disassembled insn. */
73 static int branch_delay_insns;
75 /* Last address examined. */
77 static CORE_ADDR last_examine_address;
79 /* Contents of last address examined.
80 This is not valid past the end of the `x' command! */
82 static value_ref_ptr last_examine_value;
84 /* Largest offset between a symbolic value and an address, that will be
85 printed as `0x1234 <symbol+offset>'. */
87 static unsigned int max_symbolic_offset = UINT_MAX;
89 show_max_symbolic_offset (struct ui_file *file, int from_tty,
90 struct cmd_list_element *c, const char *value)
92 fprintf_filtered (file,
93 _("The largest offset that will be "
94 "printed in <symbol+1234> form is %s.\n"),
98 /* Append the source filename and linenumber of the symbol when
99 printing a symbolic value as `<symbol at filename:linenum>' if set. */
100 static int print_symbol_filename = 0;
102 show_print_symbol_filename (struct ui_file *file, int from_tty,
103 struct cmd_list_element *c, const char *value)
105 fprintf_filtered (file, _("Printing of source filename and "
106 "line number with <symbol> is %s.\n"),
110 /* Number of auto-display expression currently being displayed.
111 So that we can disable it if we get a signal within it.
112 -1 when not doing one. */
114 static int current_display_number;
118 /* Chain link to next auto-display item. */
119 struct display *next;
121 /* The expression as the user typed it. */
124 /* Expression to be evaluated and displayed. */
127 /* Item number of this auto-display item. */
130 /* Display format specified. */
131 struct format_data format;
133 /* Program space associated with `block'. */
134 struct program_space *pspace;
136 /* Innermost block required by this expression when evaluated. */
137 const struct block *block;
139 /* Status of this display (enabled or disabled). */
143 /* Chain of expressions whose values should be displayed
144 automatically each time the program stops. */
146 static struct display *display_chain;
148 static int display_number;
150 /* Walk the following statement or block through all displays.
151 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
154 #define ALL_DISPLAYS(B) \
155 for (B = display_chain; B; B = B->next)
157 #define ALL_DISPLAYS_SAFE(B,TMP) \
158 for (B = display_chain; \
159 B ? (TMP = B->next, 1): 0; \
162 /* Prototypes for local functions. */
164 static void do_one_display (struct display *);
167 /* Decode a format specification. *STRING_PTR should point to it.
168 OFORMAT and OSIZE are used as defaults for the format and size
169 if none are given in the format specification.
170 If OSIZE is zero, then the size field of the returned value
171 should be set only if a size is explicitly specified by the
173 The structure returned describes all the data
174 found in the specification. In addition, *STRING_PTR is advanced
175 past the specification and past all whitespace following it. */
177 static struct format_data
178 decode_format (const char **string_ptr, int oformat, int osize)
180 struct format_data val;
181 const char *p = *string_ptr;
193 if (*p >= '0' && *p <= '9')
194 val.count *= atoi (p);
195 while (*p >= '0' && *p <= '9')
198 /* Now process size or format letters that follow. */
202 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
209 else if (*p >= 'a' && *p <= 'z')
215 *string_ptr = skip_spaces (p);
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 /* Display strings with byte size chars unless explicitly
260 /* The default is the size most recently specified. */
267 /* Print value VAL on stream according to OPTIONS.
268 Do not end with a newline.
269 SIZE is the letter for the size of datum being printed.
270 This is used to pad hex numbers so they line up. SIZE is 0
271 for print / output and set for examine. */
274 print_formatted (struct value *val, int size,
275 const struct value_print_options *options,
276 struct ui_file *stream)
278 struct type *type = check_typedef (value_type (val));
279 int len = TYPE_LENGTH (type);
281 if (VALUE_LVAL (val) == lval_memory)
282 next_address = value_address (val) + len;
286 switch (options->format)
290 struct type *elttype = value_type (val);
292 next_address = (value_address (val)
293 + val_print_string (elttype, NULL,
294 value_address (val), -1,
295 stream, options) * len);
300 /* We often wrap here if there are long symbolic names. */
302 next_address = (value_address (val)
303 + gdb_print_insn (get_type_arch (type),
304 value_address (val), stream,
305 &branch_delay_insns));
310 if (options->format == 0 || options->format == 's'
311 || TYPE_CODE (type) == TYPE_CODE_REF
312 || TYPE_CODE (type) == TYPE_CODE_ARRAY
313 || TYPE_CODE (type) == TYPE_CODE_STRING
314 || TYPE_CODE (type) == TYPE_CODE_STRUCT
315 || TYPE_CODE (type) == TYPE_CODE_UNION
316 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
317 value_print (val, stream, options);
319 /* User specified format, so don't look to the type to tell us
321 val_print_scalar_formatted (type,
322 value_embedded_offset (val),
324 options, size, stream);
327 /* Return builtin floating point type of same length as TYPE.
328 If no such type is found, return TYPE itself. */
330 float_type_from_length (struct type *type)
332 struct gdbarch *gdbarch = get_type_arch (type);
333 const struct builtin_type *builtin = builtin_type (gdbarch);
335 if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
336 type = builtin->builtin_float;
337 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
338 type = builtin->builtin_double;
339 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
340 type = builtin->builtin_long_double;
345 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
346 according to OPTIONS and SIZE on STREAM. Formats s and i are not
347 supported at this level. */
350 print_scalar_formatted (const gdb_byte *valaddr, struct type *type,
351 const struct value_print_options *options,
352 int size, struct ui_file *stream)
354 struct gdbarch *gdbarch = get_type_arch (type);
355 unsigned int len = TYPE_LENGTH (type);
356 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
358 /* String printing should go through val_print_scalar_formatted. */
359 gdb_assert (options->format != 's');
361 /* If the value is a pointer, and pointers and addresses are not the
362 same, then at this point, the value's length (in target bytes) is
363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
364 if (TYPE_CODE (type) == TYPE_CODE_PTR)
365 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
367 /* If we are printing it as unsigned, truncate it in case it is actually
368 a negative signed value (e.g. "print/u (short)-1" should print 65535
369 (if shorts are 16 bits) instead of 4294967295). */
370 if (options->format != 'c'
371 && (options->format != 'd' || TYPE_UNSIGNED (type)))
373 if (len < TYPE_LENGTH (type) && byte_order == BFD_ENDIAN_BIG)
374 valaddr += TYPE_LENGTH (type) - len;
377 if (size != 0 && (options->format == 'x' || options->format == 't'))
379 /* Truncate to fit. */
396 error (_("Undefined output size \"%c\"."), size);
398 if (newlen < len && byte_order == BFD_ENDIAN_BIG)
399 valaddr += len - newlen;
403 /* Historically gdb has printed floats by first casting them to a
404 long, and then printing the long. PR cli/16242 suggests changing
405 this to using C-style hex float format. */
406 gdb::byte_vector converted_float_bytes;
407 if (TYPE_CODE (type) == TYPE_CODE_FLT
408 && (options->format == 'o'
409 || options->format == 'x'
410 || options->format == 't'
411 || options->format == 'z'
412 || options->format == 'd'
413 || options->format == 'u'))
415 LONGEST val_long = unpack_long (type, valaddr);
416 converted_float_bytes.resize (TYPE_LENGTH (type));
417 store_signed_integer (converted_float_bytes.data (), TYPE_LENGTH (type),
418 byte_order, val_long);
419 valaddr = converted_float_bytes.data ();
422 /* Printing a non-float type as 'f' will interpret the data as if it were
423 of a floating-point type of the same length, if that exists. Otherwise,
424 the data is printed as integer. */
425 char format = options->format;
426 if (format == 'f' && TYPE_CODE (type) != TYPE_CODE_FLT)
428 type = float_type_from_length (type);
429 if (TYPE_CODE (type) != TYPE_CODE_FLT)
436 print_octal_chars (stream, valaddr, len, byte_order);
439 print_decimal_chars (stream, valaddr, len, true, byte_order);
442 print_decimal_chars (stream, valaddr, len, false, byte_order);
445 if (TYPE_CODE (type) != TYPE_CODE_FLT)
447 print_decimal_chars (stream, valaddr, len, !TYPE_UNSIGNED (type),
453 print_floating (valaddr, type, stream);
457 print_binary_chars (stream, valaddr, len, byte_order, size > 0);
460 print_hex_chars (stream, valaddr, len, byte_order, size > 0);
463 print_hex_chars (stream, valaddr, len, byte_order, true);
467 struct value_print_options opts = *options;
469 LONGEST val_long = unpack_long (type, valaddr);
472 if (TYPE_UNSIGNED (type))
473 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
475 type = builtin_type (gdbarch)->builtin_true_char;
477 value_print (value_from_longest (type, val_long), stream, &opts);
483 CORE_ADDR addr = unpack_pointer (type, valaddr);
485 print_address (gdbarch, addr, stream);
490 error (_("Undefined output format \"%c\"."), format);
494 /* Specify default address for `x' command.
495 The `info lines' command uses this. */
498 set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
500 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
502 next_gdbarch = gdbarch;
505 /* Make address available to the user as $_. */
506 set_internalvar (lookup_internalvar ("_"),
507 value_from_pointer (ptr_type, addr));
510 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
511 after LEADIN. Print nothing if no symbolic name is found nearby.
512 Optionally also print source file and line number, if available.
513 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
514 or to interpret it as a possible C++ name and convert it back to source
515 form. However note that DO_DEMANGLE can be overridden by the specific
516 settings of the demangle and asm_demangle variables. Returns
517 non-zero if anything was printed; zero otherwise. */
520 print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
521 struct ui_file *stream,
522 int do_demangle, const char *leadin)
524 std::string name, filename;
529 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
530 &filename, &line, &unmapped))
533 fputs_filtered (leadin, stream);
535 fputs_filtered ("<*", stream);
537 fputs_filtered ("<", stream);
538 fputs_filtered (name.c_str (), stream);
540 fprintf_filtered (stream, "+%u", (unsigned int) offset);
542 /* Append source filename and line number if desired. Give specific
543 line # of this addr, if we have it; else line # of the nearest symbol. */
544 if (print_symbol_filename && !filename.empty ())
547 fprintf_filtered (stream, " at %s:%d", filename.c_str (), line);
549 fprintf_filtered (stream, " in %s", filename.c_str ());
552 fputs_filtered ("*>", stream);
554 fputs_filtered (">", stream);
559 /* See valprint.h. */
562 build_address_symbolic (struct gdbarch *gdbarch,
563 CORE_ADDR addr, /* IN */
564 int do_demangle, /* IN */
565 std::string *name, /* OUT */
566 int *offset, /* OUT */
567 std::string *filename, /* OUT */
569 int *unmapped) /* OUT */
571 struct bound_minimal_symbol msymbol;
572 struct symbol *symbol;
573 CORE_ADDR name_location = 0;
574 struct obj_section *section = NULL;
575 const char *name_temp = "";
577 /* Let's say it is mapped (not unmapped). */
580 /* Determine if the address is in an overlay, and whether it is
582 if (overlay_debugging)
584 section = find_pc_overlay (addr);
585 if (pc_in_unmapped_range (addr, section))
588 addr = overlay_mapped_address (addr, section);
592 /* First try to find the address in the symbol table, then
593 in the minsyms. Take the closest one. */
595 /* This is defective in the sense that it only finds text symbols. So
596 really this is kind of pointless--we should make sure that the
597 minimal symbols have everything we need (by changing that we could
598 save some memory, but for many debug format--ELF/DWARF or
599 anything/stabs--it would be inconvenient to eliminate those minimal
601 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
602 symbol = find_pc_sect_function (addr, section);
606 /* If this is a function (i.e. a code address), strip out any
607 non-address bits. For instance, display a pointer to the
608 first instruction of a Thumb function as <function>; the
609 second instruction will be <function+2>, even though the
610 pointer is <function+3>. This matches the ISA behavior. */
611 addr = gdbarch_addr_bits_remove (gdbarch, addr);
613 name_location = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol));
614 if (do_demangle || asm_demangle)
615 name_temp = SYMBOL_PRINT_NAME (symbol);
617 name_temp = SYMBOL_LINKAGE_NAME (symbol);
620 if (msymbol.minsym != NULL
621 && MSYMBOL_HAS_SIZE (msymbol.minsym)
622 && MSYMBOL_SIZE (msymbol.minsym) == 0
623 && MSYMBOL_TYPE (msymbol.minsym) != mst_text
624 && MSYMBOL_TYPE (msymbol.minsym) != mst_text_gnu_ifunc
625 && MSYMBOL_TYPE (msymbol.minsym) != mst_file_text)
626 msymbol.minsym = NULL;
628 if (msymbol.minsym != NULL)
630 if (BMSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
632 /* If this is a function (i.e. a code address), strip out any
633 non-address bits. For instance, display a pointer to the
634 first instruction of a Thumb function as <function>; the
635 second instruction will be <function+2>, even though the
636 pointer is <function+3>. This matches the ISA behavior. */
637 if (MSYMBOL_TYPE (msymbol.minsym) == mst_text
638 || MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc
639 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_text
640 || MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
641 addr = gdbarch_addr_bits_remove (gdbarch, addr);
643 /* The msymbol is closer to the address than the symbol;
644 use the msymbol instead. */
646 name_location = BMSYMBOL_VALUE_ADDRESS (msymbol);
647 if (do_demangle || asm_demangle)
648 name_temp = MSYMBOL_PRINT_NAME (msymbol.minsym);
650 name_temp = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
653 if (symbol == NULL && msymbol.minsym == NULL)
656 /* If the nearest symbol is too far away, don't print anything symbolic. */
658 /* For when CORE_ADDR is larger than unsigned int, we do math in
659 CORE_ADDR. But when we detect unsigned wraparound in the
660 CORE_ADDR math, we ignore this test and print the offset,
661 because addr+max_symbolic_offset has wrapped through the end
662 of the address space back to the beginning, giving bogus comparison. */
663 if (addr > name_location + max_symbolic_offset
664 && name_location + max_symbolic_offset > name_location)
667 *offset = addr - name_location;
671 if (print_symbol_filename)
673 struct symtab_and_line sal;
675 sal = find_pc_sect_line (addr, section, 0);
679 *filename = symtab_to_filename_for_display (sal.symtab);
687 /* Print address ADDR symbolically on STREAM.
688 First print it as a number. Then perhaps print
689 <SYMBOL + OFFSET> after the number. */
692 print_address (struct gdbarch *gdbarch,
693 CORE_ADDR addr, struct ui_file *stream)
695 fputs_filtered (paddress (gdbarch, addr), stream);
696 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
699 /* Return a prefix for instruction address:
700 "=> " for current instruction, else " ". */
703 pc_prefix (CORE_ADDR addr)
705 if (has_stack_frames ())
707 struct frame_info *frame;
710 frame = get_selected_frame (NULL);
711 if (get_frame_pc_if_available (frame, &pc) && pc == addr)
717 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
718 controls whether to print the symbolic name "raw" or demangled.
719 Return non-zero if anything was printed; zero otherwise. */
722 print_address_demangle (const struct value_print_options *opts,
723 struct gdbarch *gdbarch, CORE_ADDR addr,
724 struct ui_file *stream, int do_demangle)
726 if (opts->addressprint)
728 fputs_filtered (paddress (gdbarch, addr), stream);
729 print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
733 return print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
739 /* Find the address of the instruction that is INST_COUNT instructions before
740 the instruction at ADDR.
741 Since some architectures have variable-length instructions, we can't just
742 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
743 number information to locate the nearest known instruction boundary,
744 and disassemble forward from there. If we go out of the symbol range
745 during disassembling, we return the lowest address we've got so far and
746 set the number of instructions read to INST_READ. */
749 find_instruction_backward (struct gdbarch *gdbarch, CORE_ADDR addr,
750 int inst_count, int *inst_read)
752 /* The vector PCS is used to store instruction addresses within
754 CORE_ADDR loop_start, loop_end, p;
755 std::vector<CORE_ADDR> pcs;
756 struct symtab_and_line sal;
759 loop_start = loop_end = addr;
761 /* In each iteration of the outer loop, we get a pc range that ends before
762 LOOP_START, then we count and store every instruction address of the range
763 iterated in the loop.
764 If the number of instructions counted reaches INST_COUNT, return the
765 stored address that is located INST_COUNT instructions back from ADDR.
766 If INST_COUNT is not reached, we subtract the number of counted
767 instructions from INST_COUNT, and go to the next iteration. */
771 sal = find_pc_sect_line (loop_start, NULL, 1);
774 /* We reach here when line info is not available. In this case,
775 we print a message and just exit the loop. The return value
776 is calculated after the loop. */
777 printf_filtered (_("No line number information available "
780 print_address (gdbarch, loop_start - 1, gdb_stdout);
781 printf_filtered ("\n");
785 loop_end = loop_start;
788 /* This loop pushes instruction addresses in the range from
789 LOOP_START to LOOP_END. */
790 for (p = loop_start; p < loop_end;)
793 p += gdb_insn_length (gdbarch, p);
796 inst_count -= pcs.size ();
797 *inst_read += pcs.size ();
799 while (inst_count > 0);
801 /* After the loop, the vector PCS has instruction addresses of the last
802 source line we processed, and INST_COUNT has a negative value.
803 We return the address at the index of -INST_COUNT in the vector for
805 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
815 find_instruction_backward is called with INST_COUNT = 4 and expected to
816 return 0x4001. When we reach here, INST_COUNT is set to -1 because
817 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
818 4001 is located at the index 1 of the last iterated line (= Line X),
819 which is simply calculated by -INST_COUNT.
820 The case when the length of PCS is 0 means that we reached an area for
821 which line info is not available. In such case, we return LOOP_START,
822 which was the lowest instruction address that had line info. */
823 p = pcs.size () > 0 ? pcs[-inst_count] : loop_start;
825 /* INST_READ includes all instruction addresses in a pc range. Need to
826 exclude the beginning part up to the address we're returning. That
827 is, exclude {0x4000} in the example above. */
829 *inst_read += inst_count;
834 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
835 placing the results in GDB's memory from MYADDR + LEN. Returns
836 a count of the bytes actually read. */
839 read_memory_backward (struct gdbarch *gdbarch,
840 CORE_ADDR memaddr, gdb_byte *myaddr, int len)
843 int nread; /* Number of bytes actually read. */
845 /* First try a complete read. */
846 errcode = target_read_memory (memaddr, myaddr, len);
854 /* Loop, reading one byte at a time until we get as much as we can. */
857 for (nread = 0; nread < len; ++nread)
859 errcode = target_read_memory (--memaddr, --myaddr, 1);
862 /* The read was unsuccessful, so exit the loop. */
863 printf_filtered (_("Cannot access memory at address %s\n"),
864 paddress (gdbarch, memaddr));
872 /* Returns true if X (which is LEN bytes wide) is the number zero. */
875 integer_is_zero (const gdb_byte *x, int len)
879 while (i < len && x[i] == 0)
884 /* Find the start address of a string in which ADDR is included.
885 Basically we search for '\0' and return the next address,
886 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
887 we stop searching and return the address to print characters as many as
888 PRINT_MAX from the string. */
891 find_string_backward (struct gdbarch *gdbarch,
892 CORE_ADDR addr, int count, int char_size,
893 const struct value_print_options *options,
894 int *strings_counted)
896 const int chunk_size = 0x20;
899 int chars_to_read = chunk_size;
900 int chars_counted = 0;
901 int count_original = count;
902 CORE_ADDR string_start_addr = addr;
904 gdb_assert (char_size == 1 || char_size == 2 || char_size == 4);
905 gdb::byte_vector buffer (chars_to_read * char_size);
906 while (count > 0 && read_error == 0)
910 addr -= chars_to_read * char_size;
911 chars_read = read_memory_backward (gdbarch, addr, buffer.data (),
912 chars_to_read * char_size);
913 chars_read /= char_size;
914 read_error = (chars_read == chars_to_read) ? 0 : 1;
915 /* Searching for '\0' from the end of buffer in backward direction. */
916 for (i = 0; i < chars_read && count > 0 ; ++i, ++chars_counted)
918 int offset = (chars_to_read - i - 1) * char_size;
920 if (integer_is_zero (&buffer[offset], char_size)
921 || chars_counted == options->print_max)
923 /* Found '\0' or reached print_max. As OFFSET is the offset to
924 '\0', we add CHAR_SIZE to return the start address of
927 string_start_addr = addr + offset + char_size;
933 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
934 *strings_counted = count_original - count;
938 /* In error case, STRING_START_ADDR is pointing to the string that
939 was last successfully loaded. Rewind the partially loaded string. */
940 string_start_addr -= chars_counted * char_size;
943 return string_start_addr;
946 /* Examine data at address ADDR in format FMT.
947 Fetch it from memory and print on gdb_stdout. */
950 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
955 struct type *val_type = NULL;
958 struct value_print_options opts;
959 int need_to_update_next_address = 0;
960 CORE_ADDR addr_rewound = 0;
965 next_gdbarch = gdbarch;
968 /* Instruction format implies fetch single bytes
969 regardless of the specified size.
970 The case of strings is handled in decode_format, only explicit
971 size operator are not changed to 'b'. */
977 /* Pick the appropriate size for an address. */
978 if (gdbarch_ptr_bit (next_gdbarch) == 64)
980 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
982 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
985 /* Bad value for gdbarch_ptr_bit. */
986 internal_error (__FILE__, __LINE__,
987 _("failed internal consistency check"));
991 val_type = builtin_type (next_gdbarch)->builtin_int8;
992 else if (size == 'h')
993 val_type = builtin_type (next_gdbarch)->builtin_int16;
994 else if (size == 'w')
995 val_type = builtin_type (next_gdbarch)->builtin_int32;
996 else if (size == 'g')
997 val_type = builtin_type (next_gdbarch)->builtin_int64;
1001 struct type *char_type = NULL;
1003 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1004 if type is not found. */
1006 char_type = builtin_type (next_gdbarch)->builtin_char16;
1007 else if (size == 'w')
1008 char_type = builtin_type (next_gdbarch)->builtin_char32;
1010 val_type = char_type;
1013 if (size != '\0' && size != 'b')
1014 warning (_("Unable to display strings with "
1015 "size '%c', using 'b' instead."), size);
1017 val_type = builtin_type (next_gdbarch)->builtin_int8;
1026 if (format == 's' || format == 'i')
1029 get_formatted_print_options (&opts, format);
1033 /* This is the negative repeat count case.
1034 We rewind the address based on the given repeat count and format,
1035 then examine memory from there in forward direction. */
1040 next_address = find_instruction_backward (gdbarch, addr, count,
1043 else if (format == 's')
1045 next_address = find_string_backward (gdbarch, addr, count,
1046 TYPE_LENGTH (val_type),
1051 next_address = addr - count * TYPE_LENGTH (val_type);
1054 /* The following call to print_formatted updates next_address in every
1055 iteration. In backward case, we store the start address here
1056 and update next_address with it before exiting the function. */
1057 addr_rewound = (format == 's'
1058 ? next_address - TYPE_LENGTH (val_type)
1060 need_to_update_next_address = 1;
1063 /* Print as many objects as specified in COUNT, at most maxelts per line,
1064 with the address of the next one at the start of each line. */
1070 fputs_filtered (pc_prefix (next_address), gdb_stdout);
1071 print_address (next_gdbarch, next_address, gdb_stdout);
1072 printf_filtered (":");
1077 printf_filtered ("\t");
1078 /* Note that print_formatted sets next_address for the next
1080 last_examine_address = next_address;
1082 /* The value to be displayed is not fetched greedily.
1083 Instead, to avoid the possibility of a fetched value not
1084 being used, its retrieval is delayed until the print code
1085 uses it. When examining an instruction stream, the
1086 disassembler will perform its own memory fetch using just
1087 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1088 the disassembler be modified so that LAST_EXAMINE_VALUE
1089 is left with the byte sequence from the last complete
1090 instruction fetched from memory? */
1092 = release_value (value_at_lazy (val_type, next_address));
1094 print_formatted (last_examine_value.get (), size, &opts, gdb_stdout);
1096 /* Display any branch delay slots following the final insn. */
1097 if (format == 'i' && count == 1)
1098 count += branch_delay_insns;
1100 printf_filtered ("\n");
1101 gdb_flush (gdb_stdout);
1104 if (need_to_update_next_address)
1105 next_address = addr_rewound;
1109 validate_format (struct format_data fmt, const char *cmdname)
1112 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
1114 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1116 if (fmt.format == 'i')
1117 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1118 fmt.format, cmdname);
1121 /* Parse print command format string into *FMTP and update *EXPP.
1122 CMDNAME should name the current command. */
1125 print_command_parse_format (const char **expp, const char *cmdname,
1126 struct format_data *fmtp)
1128 const char *exp = *expp;
1130 if (exp && *exp == '/')
1133 *fmtp = decode_format (&exp, last_format, 0);
1134 validate_format (*fmtp, cmdname);
1135 last_format = fmtp->format;
1148 /* Print VAL to console according to *FMTP, including recording it to
1152 print_value (struct value *val, const struct format_data *fmtp)
1154 struct value_print_options opts;
1155 int histindex = record_latest_value (val);
1157 annotate_value_history_begin (histindex, value_type (val));
1159 printf_filtered ("$%d = ", histindex);
1161 annotate_value_history_value ();
1163 get_formatted_print_options (&opts, fmtp->format);
1164 opts.raw = fmtp->raw;
1166 print_formatted (val, fmtp->size, &opts, gdb_stdout);
1167 printf_filtered ("\n");
1169 annotate_value_history_end ();
1172 /* Evaluate string EXP as an expression in the current language and
1173 print the resulting value. EXP may contain a format specifier as the
1174 first argument ("/x myvar" for example, to print myvar in hex). */
1177 print_command_1 (const char *exp, int voidprint)
1180 struct format_data fmt;
1182 print_command_parse_format (&exp, "print", &fmt);
1186 expression_up expr = parse_expression (exp);
1187 val = evaluate_expression (expr.get ());
1190 val = access_value_history (0);
1192 if (voidprint || (val && value_type (val) &&
1193 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
1194 print_value (val, &fmt);
1198 print_command (const char *exp, int from_tty)
1200 print_command_1 (exp, 1);
1203 /* Same as print, except it doesn't print void results. */
1205 call_command (const char *exp, int from_tty)
1207 print_command_1 (exp, 0);
1210 /* Implementation of the "output" command. */
1213 output_command (const char *exp, int from_tty)
1217 struct format_data fmt;
1218 struct value_print_options opts;
1223 if (exp && *exp == '/')
1226 fmt = decode_format (&exp, 0, 0);
1227 validate_format (fmt, "output");
1228 format = fmt.format;
1231 expression_up expr = parse_expression (exp);
1233 val = evaluate_expression (expr.get ());
1235 annotate_value_begin (value_type (val));
1237 get_formatted_print_options (&opts, format);
1239 print_formatted (val, fmt.size, &opts, gdb_stdout);
1241 annotate_value_end ();
1244 gdb_flush (gdb_stdout);
1248 set_command (const char *exp, int from_tty)
1250 expression_up expr = parse_expression (exp);
1252 if (expr->nelts >= 1)
1253 switch (expr->elts[0].opcode)
1255 case UNOP_PREINCREMENT:
1256 case UNOP_POSTINCREMENT:
1257 case UNOP_PREDECREMENT:
1258 case UNOP_POSTDECREMENT:
1260 case BINOP_ASSIGN_MODIFY:
1265 (_("Expression is not an assignment (and might have no effect)"));
1268 evaluate_expression (expr.get ());
1272 info_symbol_command (const char *arg, int from_tty)
1274 struct minimal_symbol *msymbol;
1275 struct objfile *objfile;
1276 struct obj_section *osect;
1277 CORE_ADDR addr, sect_addr;
1279 unsigned int offset;
1282 error_no_arg (_("address"));
1284 addr = parse_and_eval_address (arg);
1285 ALL_OBJSECTIONS (objfile, osect)
1287 /* Only process each object file once, even if there's a separate
1289 if (objfile->separate_debug_objfile_backlink)
1292 sect_addr = overlay_mapped_address (addr, osect);
1294 if (obj_section_addr (osect) <= sect_addr
1295 && sect_addr < obj_section_endaddr (osect)
1297 = lookup_minimal_symbol_by_pc_section (sect_addr, osect).minsym))
1299 const char *obj_name, *mapped, *sec_name, *msym_name;
1300 const char *loc_string;
1303 offset = sect_addr - MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
1304 mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
1305 sec_name = osect->the_bfd_section->name;
1306 msym_name = MSYMBOL_PRINT_NAME (msymbol);
1308 /* Don't print the offset if it is zero.
1309 We assume there's no need to handle i18n of "sym + offset". */
1310 std::string string_holder;
1313 string_holder = string_printf ("%s + %u", msym_name, offset);
1314 loc_string = string_holder.c_str ();
1317 loc_string = msym_name;
1319 gdb_assert (osect->objfile && objfile_name (osect->objfile));
1320 obj_name = objfile_name (osect->objfile);
1322 if (MULTI_OBJFILE_P ())
1323 if (pc_in_unmapped_range (addr, osect))
1324 if (section_is_overlay (osect))
1325 printf_filtered (_("%s in load address range of "
1326 "%s overlay section %s of %s\n"),
1327 loc_string, mapped, sec_name, obj_name);
1329 printf_filtered (_("%s in load address range of "
1330 "section %s of %s\n"),
1331 loc_string, sec_name, obj_name);
1333 if (section_is_overlay (osect))
1334 printf_filtered (_("%s in %s overlay section %s of %s\n"),
1335 loc_string, mapped, sec_name, obj_name);
1337 printf_filtered (_("%s in section %s of %s\n"),
1338 loc_string, sec_name, obj_name);
1340 if (pc_in_unmapped_range (addr, osect))
1341 if (section_is_overlay (osect))
1342 printf_filtered (_("%s in load address range of %s overlay "
1344 loc_string, mapped, sec_name);
1346 printf_filtered (_("%s in load address range of section %s\n"),
1347 loc_string, sec_name);
1349 if (section_is_overlay (osect))
1350 printf_filtered (_("%s in %s overlay section %s\n"),
1351 loc_string, mapped, sec_name);
1353 printf_filtered (_("%s in section %s\n"),
1354 loc_string, sec_name);
1358 printf_filtered (_("No symbol matches %s.\n"), arg);
1362 info_address_command (const char *exp, int from_tty)
1364 struct gdbarch *gdbarch;
1367 struct bound_minimal_symbol msymbol;
1369 struct obj_section *section;
1370 CORE_ADDR load_addr, context_pc = 0;
1371 struct field_of_this_result is_a_field_of_this;
1374 error (_("Argument required."));
1376 sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
1377 &is_a_field_of_this).symbol;
1380 if (is_a_field_of_this.type != NULL)
1382 printf_filtered ("Symbol \"");
1383 fprintf_symbol_filtered (gdb_stdout, exp,
1384 current_language->la_language, DMGL_ANSI);
1385 printf_filtered ("\" is a field of the local class variable ");
1386 if (current_language->la_language == language_objc)
1387 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1389 printf_filtered ("`this'\n");
1393 msymbol = lookup_bound_minimal_symbol (exp);
1395 if (msymbol.minsym != NULL)
1397 struct objfile *objfile = msymbol.objfile;
1399 gdbarch = get_objfile_arch (objfile);
1400 load_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
1402 printf_filtered ("Symbol \"");
1403 fprintf_symbol_filtered (gdb_stdout, exp,
1404 current_language->la_language, DMGL_ANSI);
1405 printf_filtered ("\" is at ");
1406 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1407 printf_filtered (" in a file compiled without debugging");
1408 section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
1409 if (section_is_overlay (section))
1411 load_addr = overlay_unmapped_address (load_addr, section);
1412 printf_filtered (",\n -- loaded at ");
1413 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1414 printf_filtered (" in overlay section %s",
1415 section->the_bfd_section->name);
1417 printf_filtered (".\n");
1420 error (_("No symbol \"%s\" in current context."), exp);
1424 printf_filtered ("Symbol \"");
1425 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
1426 current_language->la_language, DMGL_ANSI);
1427 printf_filtered ("\" is ");
1428 val = SYMBOL_VALUE (sym);
1429 if (SYMBOL_OBJFILE_OWNED (sym))
1430 section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
1433 gdbarch = symbol_arch (sym);
1435 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
1437 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
1439 printf_filtered (".\n");
1443 switch (SYMBOL_CLASS (sym))
1446 case LOC_CONST_BYTES:
1447 printf_filtered ("constant");
1451 printf_filtered ("a label at address ");
1452 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1453 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1454 if (section_is_overlay (section))
1456 load_addr = overlay_unmapped_address (load_addr, section);
1457 printf_filtered (",\n -- loaded at ");
1458 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1459 printf_filtered (" in overlay section %s",
1460 section->the_bfd_section->name);
1465 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1468 /* GDBARCH is the architecture associated with the objfile the symbol
1469 is defined in; the target architecture may be different, and may
1470 provide additional registers. However, we do not know the target
1471 architecture at this point. We assume the objfile architecture
1472 will contain all the standard registers that occur in debug info
1474 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1476 if (SYMBOL_IS_ARGUMENT (sym))
1477 printf_filtered (_("an argument in register %s"),
1478 gdbarch_register_name (gdbarch, regno));
1480 printf_filtered (_("a variable in register %s"),
1481 gdbarch_register_name (gdbarch, regno));
1485 printf_filtered (_("static storage at address "));
1486 load_addr = SYMBOL_VALUE_ADDRESS (sym);
1487 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1488 if (section_is_overlay (section))
1490 load_addr = overlay_unmapped_address (load_addr, section);
1491 printf_filtered (_(",\n -- loaded at "));
1492 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1493 printf_filtered (_(" in overlay section %s"),
1494 section->the_bfd_section->name);
1498 case LOC_REGPARM_ADDR:
1499 /* Note comment at LOC_REGISTER. */
1500 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1501 printf_filtered (_("address of an argument in register %s"),
1502 gdbarch_register_name (gdbarch, regno));
1506 printf_filtered (_("an argument at offset %ld"), val);
1510 printf_filtered (_("a local variable at frame offset %ld"), val);
1514 printf_filtered (_("a reference argument at offset %ld"), val);
1518 printf_filtered (_("a typedef"));
1522 printf_filtered (_("a function at address "));
1523 load_addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
1524 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1525 if (section_is_overlay (section))
1527 load_addr = overlay_unmapped_address (load_addr, section);
1528 printf_filtered (_(",\n -- loaded at "));
1529 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1530 printf_filtered (_(" in overlay section %s"),
1531 section->the_bfd_section->name);
1535 case LOC_UNRESOLVED:
1537 struct bound_minimal_symbol msym;
1539 msym = lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym));
1540 if (msym.minsym == NULL)
1541 printf_filtered ("unresolved");
1544 section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
1547 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1549 load_addr = MSYMBOL_VALUE_RAW_ADDRESS (msym.minsym);
1550 printf_filtered (_("a thread-local variable at offset %s "
1551 "in the thread-local storage for `%s'"),
1552 paddress (gdbarch, load_addr),
1553 objfile_name (section->objfile));
1557 load_addr = BMSYMBOL_VALUE_ADDRESS (msym);
1558 printf_filtered (_("static storage at address "));
1559 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1560 if (section_is_overlay (section))
1562 load_addr = overlay_unmapped_address (load_addr, section);
1563 printf_filtered (_(",\n -- loaded at "));
1564 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1565 printf_filtered (_(" in overlay section %s"),
1566 section->the_bfd_section->name);
1573 case LOC_OPTIMIZED_OUT:
1574 printf_filtered (_("optimized out"));
1578 printf_filtered (_("of unknown (botched) type"));
1581 printf_filtered (".\n");
1586 x_command (const char *exp, int from_tty)
1588 struct format_data fmt;
1591 fmt.format = last_format ? last_format : 'x';
1592 fmt.size = last_size;
1596 /* If there is no expression and no format, use the most recent
1598 if (exp == nullptr && last_count > 0)
1599 fmt.count = last_count;
1601 if (exp && *exp == '/')
1603 const char *tmp = exp + 1;
1605 fmt = decode_format (&tmp, last_format, last_size);
1609 last_count = fmt.count;
1611 /* If we have an expression, evaluate it and use it as the address. */
1613 if (exp != 0 && *exp != 0)
1615 expression_up expr = parse_expression (exp);
1616 /* Cause expression not to be there any more if this command is
1617 repeated with Newline. But don't clobber a user-defined
1618 command's definition. */
1620 set_repeat_arguments ("");
1621 val = evaluate_expression (expr.get ());
1622 if (TYPE_IS_REFERENCE (value_type (val)))
1623 val = coerce_ref (val);
1624 /* In rvalue contexts, such as this, functions are coerced into
1625 pointers to functions. This makes "x/i main" work. */
1626 if (/* last_format == 'i' && */
1627 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1628 && VALUE_LVAL (val) == lval_memory)
1629 next_address = value_address (val);
1631 next_address = value_as_address (val);
1633 next_gdbarch = expr->gdbarch;
1637 error_no_arg (_("starting display address"));
1639 do_examine (fmt, next_gdbarch, next_address);
1641 /* If the examine succeeds, we remember its size and format for next
1642 time. Set last_size to 'b' for strings. */
1643 if (fmt.format == 's')
1646 last_size = fmt.size;
1647 last_format = fmt.format;
1649 /* Set a couple of internal variables if appropriate. */
1650 if (last_examine_value != nullptr)
1652 /* Make last address examined available to the user as $_. Use
1653 the correct pointer type. */
1654 struct type *pointer_type
1655 = lookup_pointer_type (value_type (last_examine_value.get ()));
1656 set_internalvar (lookup_internalvar ("_"),
1657 value_from_pointer (pointer_type,
1658 last_examine_address));
1660 /* Make contents of last address examined available to the user
1661 as $__. If the last value has not been fetched from memory
1662 then don't fetch it now; instead mark it by voiding the $__
1664 if (value_lazy (last_examine_value.get ()))
1665 clear_internalvar (lookup_internalvar ("__"));
1667 set_internalvar (lookup_internalvar ("__"), last_examine_value.get ());
1672 /* Add an expression to the auto-display chain.
1673 Specify the expression. */
1676 display_command (const char *arg, int from_tty)
1678 struct format_data fmt;
1679 struct display *newobj;
1680 const char *exp = arg;
1691 fmt = decode_format (&exp, 0, 0);
1692 if (fmt.size && fmt.format == 0)
1694 if (fmt.format == 'i' || fmt.format == 's')
1705 innermost_block.reset ();
1706 expression_up expr = parse_expression (exp);
1708 newobj = new display ();
1710 newobj->exp_string = xstrdup (exp);
1711 newobj->exp = std::move (expr);
1712 newobj->block = innermost_block.block ();
1713 newobj->pspace = current_program_space;
1714 newobj->number = ++display_number;
1715 newobj->format = fmt;
1716 newobj->enabled_p = 1;
1717 newobj->next = NULL;
1719 if (display_chain == NULL)
1720 display_chain = newobj;
1723 struct display *last;
1725 for (last = display_chain; last->next != NULL; last = last->next)
1727 last->next = newobj;
1731 do_one_display (newobj);
1737 free_display (struct display *d)
1739 xfree (d->exp_string);
1743 /* Clear out the display_chain. Done when new symtabs are loaded,
1744 since this invalidates the types stored in many expressions. */
1747 clear_displays (void)
1751 while ((d = display_chain) != NULL)
1753 display_chain = d->next;
1758 /* Delete the auto-display DISPLAY. */
1761 delete_display (struct display *display)
1765 gdb_assert (display != NULL);
1767 if (display_chain == display)
1768 display_chain = display->next;
1771 if (d->next == display)
1773 d->next = display->next;
1777 free_display (display);
1780 /* Call FUNCTION on each of the displays whose numbers are given in
1781 ARGS. DATA is passed unmodified to FUNCTION. */
1784 map_display_numbers (const char *args,
1785 void (*function) (struct display *,
1792 error_no_arg (_("one or more display numbers"));
1794 number_or_range_parser parser (args);
1796 while (!parser.finished ())
1798 const char *p = parser.cur_tok ();
1800 num = parser.get_number ();
1802 warning (_("bad display number at or near '%s'"), p);
1805 struct display *d, *tmp;
1807 ALL_DISPLAYS_SAFE (d, tmp)
1808 if (d->number == num)
1811 printf_unfiltered (_("No display number %d.\n"), num);
1818 /* Callback for map_display_numbers, that deletes a display. */
1821 do_delete_display (struct display *d, void *data)
1826 /* "undisplay" command. */
1829 undisplay_command (const char *args, int from_tty)
1833 if (query (_("Delete all auto-display expressions? ")))
1839 map_display_numbers (args, do_delete_display, NULL);
1843 /* Display a single auto-display.
1844 Do nothing if the display cannot be printed in the current context,
1845 or if the display is disabled. */
1848 do_one_display (struct display *d)
1850 int within_current_scope;
1852 if (d->enabled_p == 0)
1855 /* The expression carries the architecture that was used at parse time.
1856 This is a problem if the expression depends on architecture features
1857 (e.g. register numbers), and the current architecture is now different.
1858 For example, a display statement like "display/i $pc" is expected to
1859 display the PC register of the current architecture, not the arch at
1860 the time the display command was given. Therefore, we re-parse the
1861 expression if the current architecture has changed. */
1862 if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1873 innermost_block.reset ();
1874 d->exp = parse_expression (d->exp_string);
1875 d->block = innermost_block.block ();
1877 CATCH (ex, RETURN_MASK_ALL)
1879 /* Can't re-parse the expression. Disable this display item. */
1881 warning (_("Unable to display \"%s\": %s"),
1882 d->exp_string, ex.message);
1890 if (d->pspace == current_program_space)
1891 within_current_scope = contained_in (get_selected_block (0), d->block);
1893 within_current_scope = 0;
1896 within_current_scope = 1;
1897 if (!within_current_scope)
1900 scoped_restore save_display_number
1901 = make_scoped_restore (¤t_display_number, d->number);
1903 annotate_display_begin ();
1904 printf_filtered ("%d", d->number);
1905 annotate_display_number_end ();
1906 printf_filtered (": ");
1910 annotate_display_format ();
1912 printf_filtered ("x/");
1913 if (d->format.count != 1)
1914 printf_filtered ("%d", d->format.count);
1915 printf_filtered ("%c", d->format.format);
1916 if (d->format.format != 'i' && d->format.format != 's')
1917 printf_filtered ("%c", d->format.size);
1918 printf_filtered (" ");
1920 annotate_display_expression ();
1922 puts_filtered (d->exp_string);
1923 annotate_display_expression_end ();
1925 if (d->format.count != 1 || d->format.format == 'i')
1926 printf_filtered ("\n");
1928 printf_filtered (" ");
1930 annotate_display_value ();
1937 val = evaluate_expression (d->exp.get ());
1938 addr = value_as_address (val);
1939 if (d->format.format == 'i')
1940 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1941 do_examine (d->format, d->exp->gdbarch, addr);
1943 CATCH (ex, RETURN_MASK_ERROR)
1945 fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
1951 struct value_print_options opts;
1953 annotate_display_format ();
1955 if (d->format.format)
1956 printf_filtered ("/%c ", d->format.format);
1958 annotate_display_expression ();
1960 puts_filtered (d->exp_string);
1961 annotate_display_expression_end ();
1963 printf_filtered (" = ");
1965 annotate_display_expression ();
1967 get_formatted_print_options (&opts, d->format.format);
1968 opts.raw = d->format.raw;
1974 val = evaluate_expression (d->exp.get ());
1975 print_formatted (val, d->format.size, &opts, gdb_stdout);
1977 CATCH (ex, RETURN_MASK_ERROR)
1979 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1983 printf_filtered ("\n");
1986 annotate_display_end ();
1988 gdb_flush (gdb_stdout);
1991 /* Display all of the values on the auto-display chain which can be
1992 evaluated in the current scope. */
1999 for (d = display_chain; d; d = d->next)
2003 /* Delete the auto-display which we were in the process of displaying.
2004 This is done when there is an error or a signal. */
2007 disable_display (int num)
2011 for (d = display_chain; d; d = d->next)
2012 if (d->number == num)
2017 printf_unfiltered (_("No display number %d.\n"), num);
2021 disable_current_display (void)
2023 if (current_display_number >= 0)
2025 disable_display (current_display_number);
2026 fprintf_unfiltered (gdb_stderr,
2027 _("Disabling display %d to "
2028 "avoid infinite recursion.\n"),
2029 current_display_number);
2031 current_display_number = -1;
2035 info_display_command (const char *ignore, int from_tty)
2040 printf_unfiltered (_("There are no auto-display expressions now.\n"));
2042 printf_filtered (_("Auto-display expressions now in effect:\n\
2043 Num Enb Expression\n"));
2045 for (d = display_chain; d; d = d->next)
2047 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
2049 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
2051 else if (d->format.format)
2052 printf_filtered ("/%c ", d->format.format);
2053 puts_filtered (d->exp_string);
2054 if (d->block && !contained_in (get_selected_block (0), d->block))
2055 printf_filtered (_(" (cannot be evaluated in the current context)"));
2056 printf_filtered ("\n");
2057 gdb_flush (gdb_stdout);
2061 /* Callback fo map_display_numbers, that enables or disables the
2062 passed in display D. */
2065 do_enable_disable_display (struct display *d, void *data)
2067 d->enabled_p = *(int *) data;
2070 /* Implamentation of both the "disable display" and "enable display"
2071 commands. ENABLE decides what to do. */
2074 enable_disable_display_command (const char *args, int from_tty, int enable)
2081 d->enabled_p = enable;
2085 map_display_numbers (args, do_enable_disable_display, &enable);
2088 /* The "enable display" command. */
2091 enable_display_command (const char *args, int from_tty)
2093 enable_disable_display_command (args, from_tty, 1);
2096 /* The "disable display" command. */
2099 disable_display_command (const char *args, int from_tty)
2101 enable_disable_display_command (args, from_tty, 0);
2104 /* display_chain items point to blocks and expressions. Some expressions in
2105 turn may point to symbols.
2106 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2107 obstack_free'd when a shared library is unloaded.
2108 Clear pointers that are about to become dangling.
2109 Both .exp and .block fields will be restored next time we need to display
2110 an item by re-parsing .exp_string field in the new execution context. */
2113 clear_dangling_display_expressions (struct objfile *objfile)
2116 struct program_space *pspace;
2118 /* With no symbol file we cannot have a block or expression from it. */
2119 if (objfile == NULL)
2121 pspace = objfile->pspace;
2122 if (objfile->separate_debug_objfile_backlink)
2124 objfile = objfile->separate_debug_objfile_backlink;
2125 gdb_assert (objfile->pspace == pspace);
2128 for (d = display_chain; d != NULL; d = d->next)
2130 if (d->pspace != pspace)
2133 if (lookup_objfile_from_block (d->block) == objfile
2134 || (d->exp != NULL && exp_uses_objfile (d->exp.get (), objfile)))
2143 /* Print the value in stack frame FRAME of a variable specified by a
2144 struct symbol. NAME is the name to print; if NULL then VAR's print
2145 name will be used. STREAM is the ui_file on which to print the
2146 value. INDENT specifies the number of indent levels to print
2147 before printing the variable name.
2149 This function invalidates FRAME. */
2152 print_variable_and_value (const char *name, struct symbol *var,
2153 struct frame_info *frame,
2154 struct ui_file *stream, int indent)
2158 name = SYMBOL_PRINT_NAME (var);
2160 fputs_filtered (n_spaces (2 * indent), stream);
2161 fputs_styled (name, variable_name_style.style (), stream);
2162 fputs_filtered (" = ", stream);
2167 struct value_print_options opts;
2169 /* READ_VAR_VALUE needs a block in order to deal with non-local
2170 references (i.e. to handle nested functions). In this context, we
2171 print variables that are local to this frame, so we can avoid passing
2173 val = read_var_value (var, NULL, frame);
2174 get_user_print_options (&opts);
2176 common_val_print (val, stream, indent, &opts, current_language);
2178 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2182 CATCH (except, RETURN_MASK_ERROR)
2184 fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
2189 fprintf_filtered (stream, "\n");
2192 /* Subroutine of ui_printf to simplify it.
2193 Print VALUE to STREAM using FORMAT.
2194 VALUE is a C-style string on the target. */
2197 printf_c_string (struct ui_file *stream, const char *format,
2198 struct value *value)
2204 tem = value_as_address (value);
2208 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2209 fprintf_filtered (stream, format, "(null)");
2214 /* This is a %s argument. Find the length of the string. */
2220 read_memory (tem + j, &c, 1);
2225 /* Copy the string contents into a string inside GDB. */
2226 str = (gdb_byte *) alloca (j + 1);
2228 read_memory (tem, str, j);
2232 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2233 fprintf_filtered (stream, format, (char *) str);
2237 /* Subroutine of ui_printf to simplify it.
2238 Print VALUE to STREAM using FORMAT.
2239 VALUE is a wide C-style string on the target. */
2242 printf_wide_c_string (struct ui_file *stream, const char *format,
2243 struct value *value)
2248 struct gdbarch *gdbarch = get_type_arch (value_type (value));
2249 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2250 struct type *wctype = lookup_typename (current_language, gdbarch,
2251 "wchar_t", NULL, 0);
2252 int wcwidth = TYPE_LENGTH (wctype);
2253 gdb_byte *buf = (gdb_byte *) alloca (wcwidth);
2255 tem = value_as_address (value);
2259 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2260 fprintf_filtered (stream, format, "(null)");
2265 /* This is a %s argument. Find the length of the string. */
2266 for (j = 0;; j += wcwidth)
2269 read_memory (tem + j, buf, wcwidth);
2270 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2274 /* Copy the string contents into a string inside GDB. */
2275 str = (gdb_byte *) alloca (j + wcwidth);
2277 read_memory (tem, str, j);
2278 memset (&str[j], 0, wcwidth);
2280 auto_obstack output;
2282 convert_between_encodings (target_wide_charset (gdbarch),
2285 &output, translit_char);
2286 obstack_grow_str0 (&output, "");
2289 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2290 fprintf_filtered (stream, format, obstack_base (&output));
2294 /* Subroutine of ui_printf to simplify it.
2295 Print VALUE, a floating point value, to STREAM using FORMAT. */
2298 printf_floating (struct ui_file *stream, const char *format,
2299 struct value *value, enum argclass argclass)
2301 /* Parameter data. */
2302 struct type *param_type = value_type (value);
2303 struct gdbarch *gdbarch = get_type_arch (param_type);
2305 /* Determine target type corresponding to the format string. */
2306 struct type *fmt_type;
2310 fmt_type = builtin_type (gdbarch)->builtin_double;
2312 case long_double_arg:
2313 fmt_type = builtin_type (gdbarch)->builtin_long_double;
2315 case dec32float_arg:
2316 fmt_type = builtin_type (gdbarch)->builtin_decfloat;
2318 case dec64float_arg:
2319 fmt_type = builtin_type (gdbarch)->builtin_decdouble;
2321 case dec128float_arg:
2322 fmt_type = builtin_type (gdbarch)->builtin_declong;
2325 gdb_assert_not_reached ("unexpected argument class");
2328 /* To match the traditional GDB behavior, the conversion is
2329 done differently depending on the type of the parameter:
2331 - if the parameter has floating-point type, it's value
2332 is converted to the target type;
2334 - otherwise, if the parameter has a type that is of the
2335 same size as a built-in floating-point type, the value
2336 bytes are interpreted as if they were of that type, and
2337 then converted to the target type (this is not done for
2338 decimal floating-point argument classes);
2340 - otherwise, if the source value has an integer value,
2341 it's value is converted to the target type;
2343 - otherwise, an error is raised.
2345 In either case, the result of the conversion is a byte buffer
2346 formatted in the target format for the target type. */
2348 if (TYPE_CODE (fmt_type) == TYPE_CODE_FLT)
2350 param_type = float_type_from_length (param_type);
2351 if (param_type != value_type (value))
2352 value = value_from_contents (param_type, value_contents (value));
2355 value = value_cast (fmt_type, value);
2357 /* Convert the value to a string and print it. */
2359 = target_float_to_string (value_contents (value), fmt_type, format);
2360 fputs_filtered (str.c_str (), stream);
2363 /* Subroutine of ui_printf to simplify it.
2364 Print VALUE, a target pointer, to STREAM using FORMAT. */
2367 printf_pointer (struct ui_file *stream, const char *format,
2368 struct value *value)
2370 /* We avoid the host's %p because pointers are too
2371 likely to be the wrong size. The only interesting
2372 modifier for %p is a width; extract that, and then
2373 handle %p as glibc would: %#x or a literal "(nil)". */
2377 #ifdef PRINTF_HAS_LONG_LONG
2378 long long val = value_as_long (value);
2380 long val = value_as_long (value);
2383 fmt = (char *) alloca (strlen (format) + 5);
2385 /* Copy up to the leading %. */
2390 int is_percent = (*p == '%');
2405 /* Copy any width or flags. Only the "-" flag is valid for pointers
2406 -- see the format_pieces constructor. */
2407 while (*p == '-' || (*p >= '0' && *p < '9'))
2410 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2413 #ifdef PRINTF_HAS_LONG_LONG
2420 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2421 fprintf_filtered (stream, fmt, val);
2429 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2430 fprintf_filtered (stream, fmt, "(nil)");
2435 /* printf "printf format string" ARG to STREAM. */
2438 ui_printf (const char *arg, struct ui_file *stream)
2440 const char *s = arg;
2441 std::vector<struct value *> val_args;
2444 error_no_arg (_("format-control string and values to print"));
2446 s = skip_spaces (s);
2448 /* A format string should follow, enveloped in double quotes. */
2450 error (_("Bad format string, missing '\"'."));
2452 format_pieces fpieces (&s);
2455 error (_("Bad format string, non-terminated '\"'."));
2457 s = skip_spaces (s);
2459 if (*s != ',' && *s != 0)
2460 error (_("Invalid argument syntax"));
2464 s = skip_spaces (s);
2469 const char *current_substring;
2472 for (auto &&piece : fpieces)
2473 if (piece.argclass != literal_piece)
2476 /* Now, parse all arguments and evaluate them.
2477 Store the VALUEs in VAL_ARGS. */
2484 val_args.push_back (parse_to_comma_and_eval (&s1));
2491 if (val_args.size () != nargs_wanted)
2492 error (_("Wrong number of arguments for specified format-string"));
2494 /* Now actually print them. */
2496 for (auto &&piece : fpieces)
2498 current_substring = piece.string;
2499 switch (piece.argclass)
2502 printf_c_string (stream, current_substring, val_args[i]);
2504 case wide_string_arg:
2505 printf_wide_c_string (stream, current_substring, val_args[i]);
2509 struct gdbarch *gdbarch
2510 = get_type_arch (value_type (val_args[i]));
2511 struct type *wctype = lookup_typename (current_language, gdbarch,
2512 "wchar_t", NULL, 0);
2513 struct type *valtype;
2514 const gdb_byte *bytes;
2516 valtype = value_type (val_args[i]);
2517 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2518 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2519 error (_("expected wchar_t argument for %%lc"));
2521 bytes = value_contents (val_args[i]);
2523 auto_obstack output;
2525 convert_between_encodings (target_wide_charset (gdbarch),
2527 bytes, TYPE_LENGTH (valtype),
2528 TYPE_LENGTH (valtype),
2529 &output, translit_char);
2530 obstack_grow_str0 (&output, "");
2533 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2534 fprintf_filtered (stream, current_substring,
2535 obstack_base (&output));
2540 #ifdef PRINTF_HAS_LONG_LONG
2542 long long val = value_as_long (val_args[i]);
2545 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2546 fprintf_filtered (stream, current_substring, val);
2551 error (_("long long not supported in printf"));
2555 int val = value_as_long (val_args[i]);
2558 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2559 fprintf_filtered (stream, current_substring, val);
2565 long val = value_as_long (val_args[i]);
2568 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2569 fprintf_filtered (stream, current_substring, val);
2573 /* Handles floating-point values. */
2575 case long_double_arg:
2576 case dec32float_arg:
2577 case dec64float_arg:
2578 case dec128float_arg:
2579 printf_floating (stream, current_substring, val_args[i],
2583 printf_pointer (stream, current_substring, val_args[i]);
2586 /* Print a portion of the format string that has no
2587 directives. Note that this will not include any
2588 ordinary %-specs, but it might include "%%". That is
2589 why we use printf_filtered and not puts_filtered here.
2590 Also, we pass a dummy argument because some platforms
2591 have modified GCC to include -Wformat-security by
2592 default, which will warn here if there is no
2595 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
2596 fprintf_filtered (stream, current_substring, 0);
2600 internal_error (__FILE__, __LINE__,
2601 _("failed internal consistency check"));
2603 /* Maybe advance to the next argument. */
2604 if (piece.argclass != literal_piece)
2610 /* Implement the "printf" command. */
2613 printf_command (const char *arg, int from_tty)
2615 ui_printf (arg, gdb_stdout);
2616 reset_terminal_style (gdb_stdout);
2618 gdb_flush (gdb_stdout);
2621 /* Implement the "eval" command. */
2624 eval_command (const char *arg, int from_tty)
2628 ui_printf (arg, &stb);
2630 std::string expanded = insert_user_defined_cmd_args (stb.c_str ());
2632 execute_command (expanded.c_str (), from_tty);
2636 _initialize_printcmd (void)
2638 struct cmd_list_element *c;
2640 current_display_number = -1;
2642 gdb::observers::free_objfile.attach (clear_dangling_display_expressions);
2644 add_info ("address", info_address_command,
2645 _("Describe where symbol SYM is stored."));
2647 add_info ("symbol", info_symbol_command, _("\
2648 Describe what symbol is at location ADDR.\n\
2649 Only for symbols with fixed locations (global or static scope)."));
2651 add_com ("x", class_vars, x_command, _("\
2652 Examine memory: x/FMT ADDRESS.\n\
2653 ADDRESS is an expression for the memory address to examine.\n\
2654 FMT is a repeat count followed by a format letter and a size letter.\n\
2655 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2656 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2657 and z(hex, zero padded on the left).\n\
2658 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2659 The specified number of objects of the specified size are printed\n\
2660 according to the format. If a negative number is specified, memory is\n\
2661 examined backward from the address.\n\n\
2662 Defaults for format and size letters are those previously used.\n\
2663 Default count is 1. Default address is following last thing printed\n\
2664 with this command or \"print\"."));
2667 add_com ("whereis", class_vars, whereis_command,
2668 _("Print line number and file of definition of variable."));
2671 add_info ("display", info_display_command, _("\
2672 Expressions to display when program stops, with code numbers."));
2674 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2675 Cancel some expressions to be displayed when program stops.\n\
2676 Arguments are the code numbers of the expressions to stop displaying.\n\
2677 No argument means cancel all automatic-display expressions.\n\
2678 \"delete display\" has the same effect as this command.\n\
2679 Do \"info display\" to see current list of code numbers."),
2682 add_com ("display", class_vars, display_command, _("\
2683 Print value of expression EXP each time the program stops.\n\
2684 /FMT may be used before EXP as in the \"print\" command.\n\
2685 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2686 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2687 and examining is done as in the \"x\" command.\n\n\
2688 With no argument, display all currently requested auto-display expressions.\n\
2689 Use \"undisplay\" to cancel display requests previously made."));
2691 add_cmd ("display", class_vars, enable_display_command, _("\
2692 Enable some expressions to be displayed when program stops.\n\
2693 Arguments are the code numbers of the expressions to resume displaying.\n\
2694 No argument means enable all automatic-display expressions.\n\
2695 Do \"info display\" to see current list of code numbers."), &enablelist);
2697 add_cmd ("display", class_vars, disable_display_command, _("\
2698 Disable some expressions to be displayed when program stops.\n\
2699 Arguments are the code numbers of the expressions to stop displaying.\n\
2700 No argument means disable all automatic-display expressions.\n\
2701 Do \"info display\" to see current list of code numbers."), &disablelist);
2703 add_cmd ("display", class_vars, undisplay_command, _("\
2704 Cancel some expressions to be displayed when program stops.\n\
2705 Arguments are the code numbers of the expressions to stop displaying.\n\
2706 No argument means cancel all automatic-display expressions.\n\
2707 Do \"info display\" to see current list of code numbers."), &deletelist);
2709 add_com ("printf", class_vars, printf_command, _("\
2710 Formatted printing, like the C \"printf\" function.\n\
2711 Usage: printf \"format string\", arg1, arg2, arg3, ..., argn\n\
2712 This supports most C printf format specifications, like %s, %d, etc."));
2714 add_com ("output", class_vars, output_command, _("\
2715 Like \"print\" but don't put in value history and don't print newline.\n\
2716 This is useful in user-defined commands."));
2718 add_prefix_cmd ("set", class_vars, set_command, _("\
2719 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2720 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2721 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2722 with $), a register (a few standard names starting with $), or an actual\n\
2723 variable in the program being debugged. EXP is any valid expression.\n\
2724 Use \"set variable\" for variables with names identical to set subcommands.\n\
2726 With a subcommand, this command modifies parts of the gdb environment.\n\
2727 You can see these environment settings with the \"show\" command."),
2728 &setlist, "set ", 1, &cmdlist);
2730 add_com ("assign", class_vars, set_command, _("\
2731 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2732 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2733 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2734 with $), a register (a few standard names starting with $), or an actual\n\
2735 variable in the program being debugged. EXP is any valid expression.\n\
2736 Use \"set variable\" for variables with names identical to set subcommands.\n\
2737 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2738 You can see these environment settings with the \"show\" command."));
2740 /* "call" is the same as "set", but handy for dbx users to call fns. */
2741 c = add_com ("call", class_vars, call_command, _("\
2742 Call a function in the program.\n\
2743 The argument is the function name and arguments, in the notation of the\n\
2744 current working language. The result is printed and saved in the value\n\
2745 history, if it is not void."));
2746 set_cmd_completer (c, expression_completer);
2748 add_cmd ("variable", class_vars, set_command, _("\
2749 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2750 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2751 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2752 with $), a register (a few standard names starting with $), or an actual\n\
2753 variable in the program being debugged. EXP is any valid expression.\n\
2754 This may usually be abbreviated to simply \"set\"."),
2756 add_alias_cmd ("var", "variable", class_vars, 0, &setlist);
2758 c = add_com ("print", class_vars, print_command, _("\
2759 Print value of expression EXP.\n\
2760 Variables accessible are those of the lexical environment of the selected\n\
2761 stack frame, plus all those whose scope is global or an entire file.\n\
2763 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2764 $$NUM refers to NUM'th value back from the last one.\n\
2765 Names starting with $ refer to registers (with the values they would have\n\
2766 if the program were to return to the stack frame now selected, restoring\n\
2767 all registers saved by frames farther in) or else to debugger\n\
2768 \"convenience\" variables (any such name not a known register).\n\
2769 Use assignment expressions to give values to convenience variables.\n\
2771 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2772 @ is a binary operator for treating consecutive data objects\n\
2773 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2774 element is FOO, whose second element is stored in the space following\n\
2775 where FOO is stored, etc. FOO must be an expression whose value\n\
2776 resides in memory.\n\
2778 EXP may be preceded with /FMT, where FMT is a format letter\n\
2779 but no count or size letter (see \"x\" command)."));
2780 set_cmd_completer (c, expression_completer);
2781 add_com_alias ("p", "print", class_vars, 1);
2782 add_com_alias ("inspect", "print", class_vars, 1);
2784 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2785 &max_symbolic_offset, _("\
2786 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2787 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2788 Tell GDB to only display the symbolic form of an address if the\n\
2789 offset between the closest earlier symbol and the address is less than\n\
2790 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2791 to always print the symbolic form of an address if any symbol precedes\n\
2792 it. Zero is equivalent to \"unlimited\"."),
2794 show_max_symbolic_offset,
2795 &setprintlist, &showprintlist);
2796 add_setshow_boolean_cmd ("symbol-filename", no_class,
2797 &print_symbol_filename, _("\
2798 Set printing of source filename and line number with <symbol>."), _("\
2799 Show printing of source filename and line number with <symbol>."), NULL,
2801 show_print_symbol_filename,
2802 &setprintlist, &showprintlist);
2804 add_com ("eval", no_class, eval_command, _("\
2805 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2806 a command line, and call it."));