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"
51 #include "common/byte-vector.h"
53 /* Last specified output format. */
55 static char last_format = 0;
57 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
59 static char last_size = 'w';
61 /* Last specified count for the 'x' command. */
63 static int last_count;
65 /* Default address to examine next, and associated architecture. */
67 static struct gdbarch *next_gdbarch;
68 static CORE_ADDR next_address;
70 /* Number of delay instructions following current disassembled insn. */
72 static int branch_delay_insns;
74 /* Last address examined. */
76 static CORE_ADDR last_examine_address;
78 /* Contents of last address examined.
79 This is not valid past the end of the `x' command! */
81 static value_ref_ptr last_examine_value;
83 /* Largest offset between a symbolic value and an address, that will be
84 printed as `0x1234 <symbol+offset>'. */
86 static unsigned int max_symbolic_offset = UINT_MAX;
88 show_max_symbolic_offset (struct ui_file *file, int from_tty,
89 struct cmd_list_element *c, const char *value)
91 fprintf_filtered (file,
92 _("The largest offset that will be "
93 "printed in <symbol+1234> form is %s.\n"),
97 /* Append the source filename and linenumber of the symbol when
98 printing a symbolic value as `<symbol at filename:linenum>' if set. */
99 static int print_symbol_filename = 0;
101 show_print_symbol_filename (struct ui_file *file, int from_tty,
102 struct cmd_list_element *c, const char *value)
104 fprintf_filtered (file, _("Printing of source filename and "
105 "line number with <symbol> is %s.\n"),
109 /* Number of auto-display expression currently being displayed.
110 So that we can disable it if we get a signal within it.
111 -1 when not doing one. */
113 static int current_display_number;
117 /* Chain link to next auto-display item. */
118 struct display *next;
120 /* The expression as the user typed it. */
123 /* Expression to be evaluated and displayed. */
126 /* Item number of this auto-display item. */
129 /* Display format specified. */
130 struct format_data format;
132 /* Program space associated with `block'. */
133 struct program_space *pspace;
135 /* Innermost block required by this expression when evaluated. */
136 const struct block *block;
138 /* Status of this display (enabled or disabled). */
142 /* Chain of expressions whose values should be displayed
143 automatically each time the program stops. */
145 static struct display *display_chain;
147 static int display_number;
149 /* Walk the following statement or block through all displays.
150 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
153 #define ALL_DISPLAYS(B) \
154 for (B = display_chain; B; B = B->next)
156 #define ALL_DISPLAYS_SAFE(B,TMP) \
157 for (B = display_chain; \
158 B ? (TMP = B->next, 1): 0; \
161 /* Prototypes for local functions. */
163 static void do_one_display (struct display *);
166 /* Decode a format specification. *STRING_PTR should point to it.
167 OFORMAT and OSIZE are used as defaults for the format and size
168 if none are given in the format specification.
169 If OSIZE is zero, then the size field of the returned value
170 should be set only if a size is explicitly specified by the
172 The structure returned describes all the data
173 found in the specification. In addition, *STRING_PTR is advanced
174 past the specification and past all whitespace following it. */
176 static struct format_data
177 decode_format (const char **string_ptr, int oformat, int osize)
179 struct format_data val;
180 const char *p = *string_ptr;
192 if (*p >= '0' && *p <= '9')
193 val.count *= atoi (p);
194 while (*p >= '0' && *p <= '9')
197 /* Now process size or format letters that follow. */
201 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
208 else if (*p >= 'a' && *p <= 'z')
214 *string_ptr = skip_spaces (p);
216 /* Set defaults for format and size if not specified. */
217 if (val.format == '?')
221 /* Neither has been specified. */
222 val.format = oformat;
226 /* If a size is specified, any format makes a reasonable
227 default except 'i'. */
228 val.format = oformat == 'i' ? 'x' : oformat;
230 else if (val.size == '?')
234 /* Pick the appropriate size for an address. This is deferred
235 until do_examine when we know the actual architecture to use.
236 A special size value of 'a' is used to indicate this case. */
237 val.size = osize ? 'a' : osize;
240 /* Floating point has to be word or giantword. */
241 if (osize == 'w' || osize == 'g')
244 /* Default it to giantword if the last used size is not
246 val.size = osize ? 'g' : osize;
249 /* Characters default to one byte. */
250 val.size = osize ? 'b' : osize;
253 /* Display strings with byte size chars unless explicitly
259 /* The default is the size most recently specified. */
266 /* Print value VAL on stream according to OPTIONS.
267 Do not end with a newline.
268 SIZE is the letter for the size of datum being printed.
269 This is used to pad hex numbers so they line up. SIZE is 0
270 for print / output and set for examine. */
273 print_formatted (struct value *val, int size,
274 const struct value_print_options *options,
275 struct ui_file *stream)
277 struct type *type = check_typedef (value_type (val));
278 int len = TYPE_LENGTH (type);
280 if (VALUE_LVAL (val) == lval_memory)
281 next_address = value_address (val) + len;
285 switch (options->format)
289 struct type *elttype = value_type (val);
291 next_address = (value_address (val)
292 + val_print_string (elttype, NULL,
293 value_address (val), -1,
294 stream, options) * len);
299 /* We often wrap here if there are long symbolic names. */
301 next_address = (value_address (val)
302 + gdb_print_insn (get_type_arch (type),
303 value_address (val), stream,
304 &branch_delay_insns));
309 if (options->format == 0 || options->format == 's'
310 || TYPE_CODE (type) == TYPE_CODE_REF
311 || TYPE_CODE (type) == TYPE_CODE_ARRAY
312 || TYPE_CODE (type) == TYPE_CODE_STRING
313 || TYPE_CODE (type) == TYPE_CODE_STRUCT
314 || TYPE_CODE (type) == TYPE_CODE_UNION
315 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
316 value_print (val, stream, options);
318 /* User specified format, so don't look to the type to tell us
320 val_print_scalar_formatted (type,
321 value_embedded_offset (val),
323 options, size, stream);
326 /* Return builtin floating point type of same length as TYPE.
327 If no such type is found, return TYPE itself. */
329 float_type_from_length (struct type *type)
331 struct gdbarch *gdbarch = get_type_arch (type);
332 const struct builtin_type *builtin = builtin_type (gdbarch);
334 if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
335 type = builtin->builtin_float;
336 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
337 type = builtin->builtin_double;
338 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
339 type = builtin->builtin_long_double;
344 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
345 according to OPTIONS and SIZE on STREAM. Formats s and i are not
346 supported at this level. */
349 print_scalar_formatted (const gdb_byte *valaddr, struct type *type,
350 const struct value_print_options *options,
351 int size, struct ui_file *stream)
353 struct gdbarch *gdbarch = get_type_arch (type);
354 unsigned int len = TYPE_LENGTH (type);
355 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
357 /* String printing should go through val_print_scalar_formatted. */
358 gdb_assert (options->format != 's');
360 /* If the value is a pointer, and pointers and addresses are not the
361 same, then at this point, the value's length (in target bytes) is
362 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
363 if (TYPE_CODE (type) == TYPE_CODE_PTR)
364 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
366 /* If we are printing it as unsigned, truncate it in case it is actually
367 a negative signed value (e.g. "print/u (short)-1" should print 65535
368 (if shorts are 16 bits) instead of 4294967295). */
369 if (options->format != 'c'
370 && (options->format != 'd' || TYPE_UNSIGNED (type)))
372 if (len < TYPE_LENGTH (type) && byte_order == BFD_ENDIAN_BIG)
373 valaddr += TYPE_LENGTH (type) - len;
376 if (size != 0 && (options->format == 'x' || options->format == 't'))
378 /* Truncate to fit. */
395 error (_("Undefined output size \"%c\"."), size);
397 if (newlen < len && byte_order == BFD_ENDIAN_BIG)
398 valaddr += len - newlen;
402 /* Historically gdb has printed floats by first casting them to a
403 long, and then printing the long. PR cli/16242 suggests changing
404 this to using C-style hex float format. */
405 gdb::byte_vector converted_float_bytes;
406 if (TYPE_CODE (type) == TYPE_CODE_FLT
407 && (options->format == 'o'
408 || options->format == 'x'
409 || options->format == 't'
410 || options->format == 'z'
411 || options->format == 'd'
412 || options->format == 'u'))
414 LONGEST val_long = unpack_long (type, valaddr);
415 converted_float_bytes.resize (TYPE_LENGTH (type));
416 store_signed_integer (converted_float_bytes.data (), TYPE_LENGTH (type),
417 byte_order, val_long);
418 valaddr = converted_float_bytes.data ();
421 /* Printing a non-float type as 'f' will interpret the data as if it were
422 of a floating-point type of the same length, if that exists. Otherwise,
423 the data is printed as integer. */
424 char format = options->format;
425 if (format == 'f' && TYPE_CODE (type) != TYPE_CODE_FLT)
427 type = float_type_from_length (type);
428 if (TYPE_CODE (type) != TYPE_CODE_FLT)
435 print_octal_chars (stream, valaddr, len, byte_order);
438 print_decimal_chars (stream, valaddr, len, true, byte_order);
441 print_decimal_chars (stream, valaddr, len, false, byte_order);
444 if (TYPE_CODE (type) != TYPE_CODE_FLT)
446 print_decimal_chars (stream, valaddr, len, !TYPE_UNSIGNED (type),
452 print_floating (valaddr, type, stream);
456 print_binary_chars (stream, valaddr, len, byte_order, size > 0);
459 print_hex_chars (stream, valaddr, len, byte_order, size > 0);
462 print_hex_chars (stream, valaddr, len, byte_order, true);
466 struct value_print_options opts = *options;
468 LONGEST val_long = unpack_long (type, valaddr);
471 if (TYPE_UNSIGNED (type))
472 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
474 type = builtin_type (gdbarch)->builtin_true_char;
476 value_print (value_from_longest (type, val_long), stream, &opts);
482 CORE_ADDR addr = unpack_pointer (type, valaddr);
484 print_address (gdbarch, addr, stream);
489 error (_("Undefined output format \"%c\"."), format);
493 /* Specify default address for `x' command.
494 The `info lines' command uses this. */
497 set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
499 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
501 next_gdbarch = gdbarch;
504 /* Make address available to the user as $_. */
505 set_internalvar (lookup_internalvar ("_"),
506 value_from_pointer (ptr_type, addr));
509 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
510 after LEADIN. Print nothing if no symbolic name is found nearby.
511 Optionally also print source file and line number, if available.
512 DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
513 or to interpret it as a possible C++ name and convert it back to source
514 form. However note that DO_DEMANGLE can be overridden by the specific
515 settings of the demangle and asm_demangle variables. Returns
516 non-zero if anything was printed; zero otherwise. */
519 print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
520 struct ui_file *stream,
521 int do_demangle, const char *leadin)
523 std::string name, filename;
528 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
529 &filename, &line, &unmapped))
532 fputs_filtered (leadin, stream);
534 fputs_filtered ("<*", stream);
536 fputs_filtered ("<", stream);
537 fputs_filtered (name.c_str (), stream);
539 fprintf_filtered (stream, "+%u", (unsigned int) offset);
541 /* Append source filename and line number if desired. Give specific
542 line # of this addr, if we have it; else line # of the nearest symbol. */
543 if (print_symbol_filename && !filename.empty ())
546 fprintf_filtered (stream, " at %s:%d", filename.c_str (), line);
548 fprintf_filtered (stream, " in %s", filename.c_str ());
551 fputs_filtered ("*>", stream);
553 fputs_filtered (">", stream);
558 /* See valprint.h. */
561 build_address_symbolic (struct gdbarch *gdbarch,
562 CORE_ADDR addr, /* IN */
563 int do_demangle, /* IN */
564 std::string *name, /* OUT */
565 int *offset, /* OUT */
566 std::string *filename, /* OUT */
568 int *unmapped) /* OUT */
570 struct bound_minimal_symbol msymbol;
571 struct symbol *symbol;
572 CORE_ADDR name_location = 0;
573 struct obj_section *section = NULL;
574 const char *name_temp = "";
576 /* Let's say it is mapped (not unmapped). */
579 /* Determine if the address is in an overlay, and whether it is
581 if (overlay_debugging)
583 section = find_pc_overlay (addr);
584 if (pc_in_unmapped_range (addr, section))
587 addr = overlay_mapped_address (addr, section);
591 /* First try to find the address in the symbol table, then
592 in the minsyms. Take the closest one. */
594 /* This is defective in the sense that it only finds text symbols. So
595 really this is kind of pointless--we should make sure that the
596 minimal symbols have everything we need (by changing that we could
597 save some memory, but for many debug format--ELF/DWARF or
598 anything/stabs--it would be inconvenient to eliminate those minimal
600 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
601 symbol = find_pc_sect_function (addr, section);
605 /* If this is a function (i.e. a code address), strip out any
606 non-address bits. For instance, display a pointer to the
607 first instruction of a Thumb function as <function>; the
608 second instruction will be <function+2>, even though the
609 pointer is <function+3>. This matches the ISA behavior. */
610 addr = gdbarch_addr_bits_remove (gdbarch, addr);
612 name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
613 if (do_demangle || asm_demangle)
614 name_temp = SYMBOL_PRINT_NAME (symbol);
616 name_temp = SYMBOL_LINKAGE_NAME (symbol);
619 if (msymbol.minsym != NULL
620 && MSYMBOL_HAS_SIZE (msymbol.minsym)
621 && MSYMBOL_SIZE (msymbol.minsym) == 0
622 && MSYMBOL_TYPE (msymbol.minsym) != mst_text
623 && MSYMBOL_TYPE (msymbol.minsym) != mst_text_gnu_ifunc
624 && MSYMBOL_TYPE (msymbol.minsym) != mst_file_text)
625 msymbol.minsym = NULL;
627 if (msymbol.minsym != NULL)
629 if (BMSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
631 /* If this is a function (i.e. a code address), strip out any
632 non-address bits. For instance, display a pointer to the
633 first instruction of a Thumb function as <function>; the
634 second instruction will be <function+2>, even though the
635 pointer is <function+3>. This matches the ISA behavior. */
636 if (MSYMBOL_TYPE (msymbol.minsym) == mst_text
637 || MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc
638 || MSYMBOL_TYPE (msymbol.minsym) == mst_file_text
639 || MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
640 addr = gdbarch_addr_bits_remove (gdbarch, addr);
642 /* The msymbol is closer to the address than the symbol;
643 use the msymbol instead. */
645 name_location = BMSYMBOL_VALUE_ADDRESS (msymbol);
646 if (do_demangle || asm_demangle)
647 name_temp = MSYMBOL_PRINT_NAME (msymbol.minsym);
649 name_temp = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
652 if (symbol == NULL && msymbol.minsym == NULL)
655 /* If the nearest symbol is too far away, don't print anything symbolic. */
657 /* For when CORE_ADDR is larger than unsigned int, we do math in
658 CORE_ADDR. But when we detect unsigned wraparound in the
659 CORE_ADDR math, we ignore this test and print the offset,
660 because addr+max_symbolic_offset has wrapped through the end
661 of the address space back to the beginning, giving bogus comparison. */
662 if (addr > name_location + max_symbolic_offset
663 && name_location + max_symbolic_offset > name_location)
666 *offset = addr - name_location;
670 if (print_symbol_filename)
672 struct symtab_and_line sal;
674 sal = find_pc_sect_line (addr, section, 0);
678 *filename = symtab_to_filename_for_display (sal.symtab);
686 /* Print address ADDR symbolically on STREAM.
687 First print it as a number. Then perhaps print
688 <SYMBOL + OFFSET> after the number. */
691 print_address (struct gdbarch *gdbarch,
692 CORE_ADDR addr, struct ui_file *stream)
694 fputs_filtered (paddress (gdbarch, addr), stream);
695 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
698 /* Return a prefix for instruction address:
699 "=> " for current instruction, else " ". */
702 pc_prefix (CORE_ADDR addr)
704 if (has_stack_frames ())
706 struct frame_info *frame;
709 frame = get_selected_frame (NULL);
710 if (get_frame_pc_if_available (frame, &pc) && pc == addr)
716 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
717 controls whether to print the symbolic name "raw" or demangled.
718 Return non-zero if anything was printed; zero otherwise. */
721 print_address_demangle (const struct value_print_options *opts,
722 struct gdbarch *gdbarch, CORE_ADDR addr,
723 struct ui_file *stream, int do_demangle)
725 if (opts->addressprint)
727 fputs_filtered (paddress (gdbarch, addr), stream);
728 print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
732 return print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
738 /* Find the address of the instruction that is INST_COUNT instructions before
739 the instruction at ADDR.
740 Since some architectures have variable-length instructions, we can't just
741 simply subtract INST_COUNT * INSN_LEN from ADDR. Instead, we use line
742 number information to locate the nearest known instruction boundary,
743 and disassemble forward from there. If we go out of the symbol range
744 during disassembling, we return the lowest address we've got so far and
745 set the number of instructions read to INST_READ. */
748 find_instruction_backward (struct gdbarch *gdbarch, CORE_ADDR addr,
749 int inst_count, int *inst_read)
751 /* The vector PCS is used to store instruction addresses within
753 CORE_ADDR loop_start, loop_end, p;
754 std::vector<CORE_ADDR> pcs;
755 struct symtab_and_line sal;
758 loop_start = loop_end = addr;
760 /* In each iteration of the outer loop, we get a pc range that ends before
761 LOOP_START, then we count and store every instruction address of the range
762 iterated in the loop.
763 If the number of instructions counted reaches INST_COUNT, return the
764 stored address that is located INST_COUNT instructions back from ADDR.
765 If INST_COUNT is not reached, we subtract the number of counted
766 instructions from INST_COUNT, and go to the next iteration. */
770 sal = find_pc_sect_line (loop_start, NULL, 1);
773 /* We reach here when line info is not available. In this case,
774 we print a message and just exit the loop. The return value
775 is calculated after the loop. */
776 printf_filtered (_("No line number information available "
779 print_address (gdbarch, loop_start - 1, gdb_stdout);
780 printf_filtered ("\n");
784 loop_end = loop_start;
787 /* This loop pushes instruction addresses in the range from
788 LOOP_START to LOOP_END. */
789 for (p = loop_start; p < loop_end;)
792 p += gdb_insn_length (gdbarch, p);
795 inst_count -= pcs.size ();
796 *inst_read += pcs.size ();
798 while (inst_count > 0);
800 /* After the loop, the vector PCS has instruction addresses of the last
801 source line we processed, and INST_COUNT has a negative value.
802 We return the address at the index of -INST_COUNT in the vector for
804 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
814 find_instruction_backward is called with INST_COUNT = 4 and expected to
815 return 0x4001. When we reach here, INST_COUNT is set to -1 because
816 it was subtracted by 2 (from Line Y) and 3 (from Line X). The value
817 4001 is located at the index 1 of the last iterated line (= Line X),
818 which is simply calculated by -INST_COUNT.
819 The case when the length of PCS is 0 means that we reached an area for
820 which line info is not available. In such case, we return LOOP_START,
821 which was the lowest instruction address that had line info. */
822 p = pcs.size () > 0 ? pcs[-inst_count] : loop_start;
824 /* INST_READ includes all instruction addresses in a pc range. Need to
825 exclude the beginning part up to the address we're returning. That
826 is, exclude {0x4000} in the example above. */
828 *inst_read += inst_count;
833 /* Backward read LEN bytes of target memory from address MEMADDR + LEN,
834 placing the results in GDB's memory from MYADDR + LEN. Returns
835 a count of the bytes actually read. */
838 read_memory_backward (struct gdbarch *gdbarch,
839 CORE_ADDR memaddr, gdb_byte *myaddr, int len)
842 int nread; /* Number of bytes actually read. */
844 /* First try a complete read. */
845 errcode = target_read_memory (memaddr, myaddr, len);
853 /* Loop, reading one byte at a time until we get as much as we can. */
856 for (nread = 0; nread < len; ++nread)
858 errcode = target_read_memory (--memaddr, --myaddr, 1);
861 /* The read was unsuccessful, so exit the loop. */
862 printf_filtered (_("Cannot access memory at address %s\n"),
863 paddress (gdbarch, memaddr));
871 /* Returns true if X (which is LEN bytes wide) is the number zero. */
874 integer_is_zero (const gdb_byte *x, int len)
878 while (i < len && x[i] == 0)
883 /* Find the start address of a string in which ADDR is included.
884 Basically we search for '\0' and return the next address,
885 but if OPTIONS->PRINT_MAX is smaller than the length of a string,
886 we stop searching and return the address to print characters as many as
887 PRINT_MAX from the string. */
890 find_string_backward (struct gdbarch *gdbarch,
891 CORE_ADDR addr, int count, int char_size,
892 const struct value_print_options *options,
893 int *strings_counted)
895 const int chunk_size = 0x20;
898 int chars_to_read = chunk_size;
899 int chars_counted = 0;
900 int count_original = count;
901 CORE_ADDR string_start_addr = addr;
903 gdb_assert (char_size == 1 || char_size == 2 || char_size == 4);
904 gdb::byte_vector buffer (chars_to_read * char_size);
905 while (count > 0 && read_error == 0)
909 addr -= chars_to_read * char_size;
910 chars_read = read_memory_backward (gdbarch, addr, buffer.data (),
911 chars_to_read * char_size);
912 chars_read /= char_size;
913 read_error = (chars_read == chars_to_read) ? 0 : 1;
914 /* Searching for '\0' from the end of buffer in backward direction. */
915 for (i = 0; i < chars_read && count > 0 ; ++i, ++chars_counted)
917 int offset = (chars_to_read - i - 1) * char_size;
919 if (integer_is_zero (&buffer[offset], char_size)
920 || chars_counted == options->print_max)
922 /* Found '\0' or reached print_max. As OFFSET is the offset to
923 '\0', we add CHAR_SIZE to return the start address of
926 string_start_addr = addr + offset + char_size;
932 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
933 *strings_counted = count_original - count;
937 /* In error case, STRING_START_ADDR is pointing to the string that
938 was last successfully loaded. Rewind the partially loaded string. */
939 string_start_addr -= chars_counted * char_size;
942 return string_start_addr;
945 /* Examine data at address ADDR in format FMT.
946 Fetch it from memory and print on gdb_stdout. */
949 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
954 struct type *val_type = NULL;
957 struct value_print_options opts;
958 int need_to_update_next_address = 0;
959 CORE_ADDR addr_rewound = 0;
964 next_gdbarch = gdbarch;
967 /* Instruction format implies fetch single bytes
968 regardless of the specified size.
969 The case of strings is handled in decode_format, only explicit
970 size operator are not changed to 'b'. */
976 /* Pick the appropriate size for an address. */
977 if (gdbarch_ptr_bit (next_gdbarch) == 64)
979 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
981 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
984 /* Bad value for gdbarch_ptr_bit. */
985 internal_error (__FILE__, __LINE__,
986 _("failed internal consistency check"));
990 val_type = builtin_type (next_gdbarch)->builtin_int8;
991 else if (size == 'h')
992 val_type = builtin_type (next_gdbarch)->builtin_int16;
993 else if (size == 'w')
994 val_type = builtin_type (next_gdbarch)->builtin_int32;
995 else if (size == 'g')
996 val_type = builtin_type (next_gdbarch)->builtin_int64;
1000 struct type *char_type = NULL;
1002 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1003 if type is not found. */
1005 char_type = builtin_type (next_gdbarch)->builtin_char16;
1006 else if (size == 'w')
1007 char_type = builtin_type (next_gdbarch)->builtin_char32;
1009 val_type = char_type;
1012 if (size != '\0' && size != 'b')
1013 warning (_("Unable to display strings with "
1014 "size '%c', using 'b' instead."), size);
1016 val_type = builtin_type (next_gdbarch)->builtin_int8;
1025 if (format == 's' || format == 'i')
1028 get_formatted_print_options (&opts, format);
1032 /* This is the negative repeat count case.
1033 We rewind the address based on the given repeat count and format,
1034 then examine memory from there in forward direction. */
1039 next_address = find_instruction_backward (gdbarch, addr, count,
1042 else if (format == 's')
1044 next_address = find_string_backward (gdbarch, addr, count,
1045 TYPE_LENGTH (val_type),
1050 next_address = addr - count * TYPE_LENGTH (val_type);
1053 /* The following call to print_formatted updates next_address in every
1054 iteration. In backward case, we store the start address here
1055 and update next_address with it before exiting the function. */
1056 addr_rewound = (format == 's'
1057 ? next_address - TYPE_LENGTH (val_type)
1059 need_to_update_next_address = 1;
1062 /* Print as many objects as specified in COUNT, at most maxelts per line,
1063 with the address of the next one at the start of each line. */
1069 fputs_filtered (pc_prefix (next_address), gdb_stdout);
1070 print_address (next_gdbarch, next_address, gdb_stdout);
1071 printf_filtered (":");
1076 printf_filtered ("\t");
1077 /* Note that print_formatted sets next_address for the next
1079 last_examine_address = next_address;
1081 /* The value to be displayed is not fetched greedily.
1082 Instead, to avoid the possibility of a fetched value not
1083 being used, its retrieval is delayed until the print code
1084 uses it. When examining an instruction stream, the
1085 disassembler will perform its own memory fetch using just
1086 the address stored in LAST_EXAMINE_VALUE. FIXME: Should
1087 the disassembler be modified so that LAST_EXAMINE_VALUE
1088 is left with the byte sequence from the last complete
1089 instruction fetched from memory? */
1091 = release_value (value_at_lazy (val_type, next_address));
1093 print_formatted (last_examine_value.get (), size, &opts, gdb_stdout);
1095 /* Display any branch delay slots following the final insn. */
1096 if (format == 'i' && count == 1)
1097 count += branch_delay_insns;
1099 printf_filtered ("\n");
1100 gdb_flush (gdb_stdout);
1103 if (need_to_update_next_address)
1104 next_address = addr_rewound;
1108 validate_format (struct format_data fmt, const char *cmdname)
1111 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
1113 error (_("Item count other than 1 is meaningless in \"%s\" command."),
1115 if (fmt.format == 'i')
1116 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
1117 fmt.format, cmdname);
1120 /* Parse print command format string into *FMTP and update *EXPP.
1121 CMDNAME should name the current command. */
1124 print_command_parse_format (const char **expp, const char *cmdname,
1125 struct format_data *fmtp)
1127 const char *exp = *expp;
1129 if (exp && *exp == '/')
1132 *fmtp = decode_format (&exp, last_format, 0);
1133 validate_format (*fmtp, cmdname);
1134 last_format = fmtp->format;
1147 /* Print VAL to console according to *FMTP, including recording it to
1151 print_value (struct value *val, const struct format_data *fmtp)
1153 struct value_print_options opts;
1154 int histindex = record_latest_value (val);
1156 annotate_value_history_begin (histindex, value_type (val));
1158 printf_filtered ("$%d = ", histindex);
1160 annotate_value_history_value ();
1162 get_formatted_print_options (&opts, fmtp->format);
1163 opts.raw = fmtp->raw;
1165 print_formatted (val, fmtp->size, &opts, gdb_stdout);
1166 printf_filtered ("\n");
1168 annotate_value_history_end ();
1171 /* Evaluate string EXP as an expression in the current language and
1172 print the resulting value. EXP may contain a format specifier as the
1173 first argument ("/x myvar" for example, to print myvar in hex). */
1176 print_command_1 (const char *exp, int voidprint)
1179 struct format_data fmt;
1181 print_command_parse_format (&exp, "print", &fmt);
1185 expression_up expr = parse_expression (exp);
1186 val = evaluate_expression (expr.get ());
1189 val = access_value_history (0);
1191 if (voidprint || (val && value_type (val) &&
1192 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
1193 print_value (val, &fmt);
1197 print_command (const char *exp, int from_tty)
1199 print_command_1 (exp, 1);
1202 /* Same as print, except it doesn't print void results. */
1204 call_command (const char *exp, int from_tty)
1206 print_command_1 (exp, 0);
1209 /* Implementation of the "output" command. */
1212 output_command (const char *exp, int from_tty)
1216 struct format_data fmt;
1217 struct value_print_options opts;
1222 if (exp && *exp == '/')
1225 fmt = decode_format (&exp, 0, 0);
1226 validate_format (fmt, "output");
1227 format = fmt.format;
1230 expression_up expr = parse_expression (exp);
1232 val = evaluate_expression (expr.get ());
1234 annotate_value_begin (value_type (val));
1236 get_formatted_print_options (&opts, format);
1238 print_formatted (val, fmt.size, &opts, gdb_stdout);
1240 annotate_value_end ();
1243 gdb_flush (gdb_stdout);
1247 set_command (const char *exp, int from_tty)
1249 expression_up expr = parse_expression (exp);
1251 if (expr->nelts >= 1)
1252 switch (expr->elts[0].opcode)
1254 case UNOP_PREINCREMENT:
1255 case UNOP_POSTINCREMENT:
1256 case UNOP_PREDECREMENT:
1257 case UNOP_POSTDECREMENT:
1259 case BINOP_ASSIGN_MODIFY:
1264 (_("Expression is not an assignment (and might have no effect)"));
1267 evaluate_expression (expr.get ());
1271 info_symbol_command (const char *arg, int from_tty)
1273 struct minimal_symbol *msymbol;
1274 struct objfile *objfile;
1275 struct obj_section *osect;
1276 CORE_ADDR addr, sect_addr;
1278 unsigned int offset;
1281 error_no_arg (_("address"));
1283 addr = parse_and_eval_address (arg);
1284 ALL_OBJSECTIONS (objfile, osect)
1286 /* Only process each object file once, even if there's a separate
1288 if (objfile->separate_debug_objfile_backlink)
1291 sect_addr = overlay_mapped_address (addr, osect);
1293 if (obj_section_addr (osect) <= sect_addr
1294 && sect_addr < obj_section_endaddr (osect)
1296 = lookup_minimal_symbol_by_pc_section (sect_addr, osect).minsym))
1298 const char *obj_name, *mapped, *sec_name, *msym_name;
1299 const char *loc_string;
1300 struct cleanup *old_chain;
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_START (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 fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
2164 struct value_print_options opts;
2166 /* READ_VAR_VALUE needs a block in order to deal with non-local
2167 references (i.e. to handle nested functions). In this context, we
2168 print variables that are local to this frame, so we can avoid passing
2170 val = read_var_value (var, NULL, frame);
2171 get_user_print_options (&opts);
2173 common_val_print (val, stream, indent, &opts, current_language);
2175 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2179 CATCH (except, RETURN_MASK_ERROR)
2181 fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
2186 fprintf_filtered (stream, "\n");
2189 /* Subroutine of ui_printf to simplify it.
2190 Print VALUE to STREAM using FORMAT.
2191 VALUE is a C-style string on the target. */
2194 printf_c_string (struct ui_file *stream, const char *format,
2195 struct value *value)
2201 tem = value_as_address (value);
2204 fprintf_filtered (stream, format, "(null)");
2208 /* This is a %s argument. Find the length of the string. */
2214 read_memory (tem + j, &c, 1);
2219 /* Copy the string contents into a string inside GDB. */
2220 str = (gdb_byte *) alloca (j + 1);
2222 read_memory (tem, str, j);
2225 fprintf_filtered (stream, format, (char *) str);
2228 /* Subroutine of ui_printf to simplify it.
2229 Print VALUE to STREAM using FORMAT.
2230 VALUE is a wide C-style string on the target. */
2233 printf_wide_c_string (struct ui_file *stream, const char *format,
2234 struct value *value)
2239 struct gdbarch *gdbarch = get_type_arch (value_type (value));
2240 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2241 struct type *wctype = lookup_typename (current_language, gdbarch,
2242 "wchar_t", NULL, 0);
2243 int wcwidth = TYPE_LENGTH (wctype);
2244 gdb_byte *buf = (gdb_byte *) alloca (wcwidth);
2246 tem = value_as_address (value);
2249 fprintf_filtered (stream, format, "(null)");
2253 /* This is a %s argument. Find the length of the string. */
2254 for (j = 0;; j += wcwidth)
2257 read_memory (tem + j, buf, wcwidth);
2258 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2262 /* Copy the string contents into a string inside GDB. */
2263 str = (gdb_byte *) alloca (j + wcwidth);
2265 read_memory (tem, str, j);
2266 memset (&str[j], 0, wcwidth);
2268 auto_obstack output;
2270 convert_between_encodings (target_wide_charset (gdbarch),
2273 &output, translit_char);
2274 obstack_grow_str0 (&output, "");
2276 fprintf_filtered (stream, format, obstack_base (&output));
2279 /* Subroutine of ui_printf to simplify it.
2280 Print VALUE, a floating point value, to STREAM using FORMAT. */
2283 printf_floating (struct ui_file *stream, const char *format,
2284 struct value *value, enum argclass argclass)
2286 /* Parameter data. */
2287 struct type *param_type = value_type (value);
2288 struct gdbarch *gdbarch = get_type_arch (param_type);
2289 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2291 /* Determine target type corresponding to the format string. */
2292 struct type *fmt_type;
2296 fmt_type = builtin_type (gdbarch)->builtin_double;
2298 case long_double_arg:
2299 fmt_type = builtin_type (gdbarch)->builtin_long_double;
2301 case dec32float_arg:
2302 fmt_type = builtin_type (gdbarch)->builtin_decfloat;
2304 case dec64float_arg:
2305 fmt_type = builtin_type (gdbarch)->builtin_decdouble;
2307 case dec128float_arg:
2308 fmt_type = builtin_type (gdbarch)->builtin_declong;
2311 gdb_assert_not_reached ("unexpected argument class");
2314 /* To match the traditional GDB behavior, the conversion is
2315 done differently depending on the type of the parameter:
2317 - if the parameter has floating-point type, it's value
2318 is converted to the target type;
2320 - otherwise, if the parameter has a type that is of the
2321 same size as a built-in floating-point type, the value
2322 bytes are interpreted as if they were of that type, and
2323 then converted to the target type (this is not done for
2324 decimal floating-point argument classes);
2326 - otherwise, if the source value has an integer value,
2327 it's value is converted to the target type;
2329 - otherwise, an error is raised.
2331 In either case, the result of the conversion is a byte buffer
2332 formatted in the target format for the target type. */
2334 if (TYPE_CODE (fmt_type) == TYPE_CODE_FLT)
2336 param_type = float_type_from_length (param_type);
2337 if (param_type != value_type (value))
2338 value = value_from_contents (param_type, value_contents (value));
2341 value = value_cast (fmt_type, value);
2343 /* Convert the value to a string and print it. */
2345 = target_float_to_string (value_contents (value), fmt_type, format);
2346 fputs_filtered (str.c_str (), stream);
2349 /* Subroutine of ui_printf to simplify it.
2350 Print VALUE, a target pointer, to STREAM using FORMAT. */
2353 printf_pointer (struct ui_file *stream, const char *format,
2354 struct value *value)
2356 /* We avoid the host's %p because pointers are too
2357 likely to be the wrong size. The only interesting
2358 modifier for %p is a width; extract that, and then
2359 handle %p as glibc would: %#x or a literal "(nil)". */
2363 #ifdef PRINTF_HAS_LONG_LONG
2364 long long val = value_as_long (value);
2366 long val = value_as_long (value);
2369 fmt = (char *) alloca (strlen (format) + 5);
2371 /* Copy up to the leading %. */
2376 int is_percent = (*p == '%');
2391 /* Copy any width or flags. Only the "-" flag is valid for pointers
2392 -- see the format_pieces constructor. */
2393 while (*p == '-' || (*p >= '0' && *p < '9'))
2396 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2399 #ifdef PRINTF_HAS_LONG_LONG
2405 fprintf_filtered (stream, fmt, val);
2411 fprintf_filtered (stream, fmt, "(nil)");
2415 /* printf "printf format string" ARG to STREAM. */
2418 ui_printf (const char *arg, struct ui_file *stream)
2420 const char *s = arg;
2421 std::vector<struct value *> val_args;
2424 error_no_arg (_("format-control string and values to print"));
2426 s = skip_spaces (s);
2428 /* A format string should follow, enveloped in double quotes. */
2430 error (_("Bad format string, missing '\"'."));
2432 format_pieces fpieces (&s);
2435 error (_("Bad format string, non-terminated '\"'."));
2437 s = skip_spaces (s);
2439 if (*s != ',' && *s != 0)
2440 error (_("Invalid argument syntax"));
2444 s = skip_spaces (s);
2449 const char *current_substring;
2452 for (auto &&piece : fpieces)
2453 if (piece.argclass != literal_piece)
2456 /* Now, parse all arguments and evaluate them.
2457 Store the VALUEs in VAL_ARGS. */
2464 val_args.push_back (parse_to_comma_and_eval (&s1));
2471 if (val_args.size () != nargs_wanted)
2472 error (_("Wrong number of arguments for specified format-string"));
2474 /* Now actually print them. */
2476 for (auto &&piece : fpieces)
2478 current_substring = piece.string;
2479 switch (piece.argclass)
2482 printf_c_string (stream, current_substring, val_args[i]);
2484 case wide_string_arg:
2485 printf_wide_c_string (stream, current_substring, val_args[i]);
2489 struct gdbarch *gdbarch
2490 = get_type_arch (value_type (val_args[i]));
2491 struct type *wctype = lookup_typename (current_language, gdbarch,
2492 "wchar_t", NULL, 0);
2493 struct type *valtype;
2494 const gdb_byte *bytes;
2496 valtype = value_type (val_args[i]);
2497 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2498 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2499 error (_("expected wchar_t argument for %%lc"));
2501 bytes = value_contents (val_args[i]);
2503 auto_obstack output;
2505 convert_between_encodings (target_wide_charset (gdbarch),
2507 bytes, TYPE_LENGTH (valtype),
2508 TYPE_LENGTH (valtype),
2509 &output, translit_char);
2510 obstack_grow_str0 (&output, "");
2512 fprintf_filtered (stream, current_substring,
2513 obstack_base (&output));
2517 #ifdef PRINTF_HAS_LONG_LONG
2519 long long val = value_as_long (val_args[i]);
2521 fprintf_filtered (stream, current_substring, val);
2525 error (_("long long not supported in printf"));
2529 int val = value_as_long (val_args[i]);
2531 fprintf_filtered (stream, current_substring, val);
2536 long val = value_as_long (val_args[i]);
2538 fprintf_filtered (stream, current_substring, val);
2541 /* Handles floating-point values. */
2543 case long_double_arg:
2544 case dec32float_arg:
2545 case dec64float_arg:
2546 case dec128float_arg:
2547 printf_floating (stream, current_substring, val_args[i],
2551 printf_pointer (stream, current_substring, val_args[i]);
2554 /* Print a portion of the format string that has no
2555 directives. Note that this will not include any
2556 ordinary %-specs, but it might include "%%". That is
2557 why we use printf_filtered and not puts_filtered here.
2558 Also, we pass a dummy argument because some platforms
2559 have modified GCC to include -Wformat-security by
2560 default, which will warn here if there is no
2562 fprintf_filtered (stream, current_substring, 0);
2565 internal_error (__FILE__, __LINE__,
2566 _("failed internal consistency check"));
2568 /* Maybe advance to the next argument. */
2569 if (piece.argclass != literal_piece)
2575 /* Implement the "printf" command. */
2578 printf_command (const char *arg, int from_tty)
2580 ui_printf (arg, gdb_stdout);
2581 gdb_flush (gdb_stdout);
2584 /* Implement the "eval" command. */
2587 eval_command (const char *arg, int from_tty)
2591 ui_printf (arg, &stb);
2593 std::string expanded = insert_user_defined_cmd_args (stb.c_str ());
2595 execute_command (expanded.c_str (), from_tty);
2599 _initialize_printcmd (void)
2601 struct cmd_list_element *c;
2603 current_display_number = -1;
2605 gdb::observers::free_objfile.attach (clear_dangling_display_expressions);
2607 add_info ("address", info_address_command,
2608 _("Describe where symbol SYM is stored."));
2610 add_info ("symbol", info_symbol_command, _("\
2611 Describe what symbol is at location ADDR.\n\
2612 Only for symbols with fixed locations (global or static scope)."));
2614 add_com ("x", class_vars, x_command, _("\
2615 Examine memory: x/FMT ADDRESS.\n\
2616 ADDRESS is an expression for the memory address to examine.\n\
2617 FMT is a repeat count followed by a format letter and a size letter.\n\
2618 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2619 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2620 and z(hex, zero padded on the left).\n\
2621 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2622 The specified number of objects of the specified size are printed\n\
2623 according to the format. If a negative number is specified, memory is\n\
2624 examined backward from the address.\n\n\
2625 Defaults for format and size letters are those previously used.\n\
2626 Default count is 1. Default address is following last thing printed\n\
2627 with this command or \"print\"."));
2630 add_com ("whereis", class_vars, whereis_command,
2631 _("Print line number and file of definition of variable."));
2634 add_info ("display", info_display_command, _("\
2635 Expressions to display when program stops, with code numbers."));
2637 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2638 Cancel some expressions to be displayed when program stops.\n\
2639 Arguments are the code numbers of the expressions to stop displaying.\n\
2640 No argument means cancel all automatic-display expressions.\n\
2641 \"delete display\" has the same effect as this command.\n\
2642 Do \"info display\" to see current list of code numbers."),
2645 add_com ("display", class_vars, display_command, _("\
2646 Print value of expression EXP each time the program stops.\n\
2647 /FMT may be used before EXP as in the \"print\" command.\n\
2648 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2649 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2650 and examining is done as in the \"x\" command.\n\n\
2651 With no argument, display all currently requested auto-display expressions.\n\
2652 Use \"undisplay\" to cancel display requests previously made."));
2654 add_cmd ("display", class_vars, enable_display_command, _("\
2655 Enable some expressions to be displayed when program stops.\n\
2656 Arguments are the code numbers of the expressions to resume displaying.\n\
2657 No argument means enable all automatic-display expressions.\n\
2658 Do \"info display\" to see current list of code numbers."), &enablelist);
2660 add_cmd ("display", class_vars, disable_display_command, _("\
2661 Disable some expressions to be displayed when program stops.\n\
2662 Arguments are the code numbers of the expressions to stop displaying.\n\
2663 No argument means disable all automatic-display expressions.\n\
2664 Do \"info display\" to see current list of code numbers."), &disablelist);
2666 add_cmd ("display", class_vars, undisplay_command, _("\
2667 Cancel some expressions to be displayed when program stops.\n\
2668 Arguments are the code numbers of the expressions to stop displaying.\n\
2669 No argument means cancel all automatic-display expressions.\n\
2670 Do \"info display\" to see current list of code numbers."), &deletelist);
2672 add_com ("printf", class_vars, printf_command, _("\
2673 Formatted printing, like the C \"printf\" function.\n\
2674 Usage: printf \"format string\", arg1, arg2, arg3, ..., argn\n\
2675 This supports most C printf format specifications, like %s, %d, etc."));
2677 add_com ("output", class_vars, output_command, _("\
2678 Like \"print\" but don't put in value history and don't print newline.\n\
2679 This is useful in user-defined commands."));
2681 add_prefix_cmd ("set", class_vars, set_command, _("\
2682 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2683 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2684 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2685 with $), a register (a few standard names starting with $), or an actual\n\
2686 variable in the program being debugged. EXP is any valid expression.\n\
2687 Use \"set variable\" for variables with names identical to set subcommands.\n\
2689 With a subcommand, this command modifies parts of the gdb environment.\n\
2690 You can see these environment settings with the \"show\" command."),
2691 &setlist, "set ", 1, &cmdlist);
2693 add_com ("assign", class_vars, set_command, _("\
2694 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2695 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2696 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2697 with $), a register (a few standard names starting with $), or an actual\n\
2698 variable in the program being debugged. EXP is any valid expression.\n\
2699 Use \"set variable\" for variables with names identical to set subcommands.\n\
2700 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2701 You can see these environment settings with the \"show\" command."));
2703 /* "call" is the same as "set", but handy for dbx users to call fns. */
2704 c = add_com ("call", class_vars, call_command, _("\
2705 Call a function in the program.\n\
2706 The argument is the function name and arguments, in the notation of the\n\
2707 current working language. The result is printed and saved in the value\n\
2708 history, if it is not void."));
2709 set_cmd_completer (c, expression_completer);
2711 add_cmd ("variable", class_vars, set_command, _("\
2712 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2713 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2714 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2715 with $), a register (a few standard names starting with $), or an actual\n\
2716 variable in the program being debugged. EXP is any valid expression.\n\
2717 This may usually be abbreviated to simply \"set\"."),
2719 add_alias_cmd ("var", "variable", class_vars, 0, &setlist);
2721 c = add_com ("print", class_vars, print_command, _("\
2722 Print value of expression EXP.\n\
2723 Variables accessible are those of the lexical environment of the selected\n\
2724 stack frame, plus all those whose scope is global or an entire file.\n\
2726 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2727 $$NUM refers to NUM'th value back from the last one.\n\
2728 Names starting with $ refer to registers (with the values they would have\n\
2729 if the program were to return to the stack frame now selected, restoring\n\
2730 all registers saved by frames farther in) or else to debugger\n\
2731 \"convenience\" variables (any such name not a known register).\n\
2732 Use assignment expressions to give values to convenience variables.\n\
2734 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2735 @ is a binary operator for treating consecutive data objects\n\
2736 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2737 element is FOO, whose second element is stored in the space following\n\
2738 where FOO is stored, etc. FOO must be an expression whose value\n\
2739 resides in memory.\n\
2741 EXP may be preceded with /FMT, where FMT is a format letter\n\
2742 but no count or size letter (see \"x\" command)."));
2743 set_cmd_completer (c, expression_completer);
2744 add_com_alias ("p", "print", class_vars, 1);
2745 add_com_alias ("inspect", "print", class_vars, 1);
2747 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2748 &max_symbolic_offset, _("\
2749 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2750 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2751 Tell GDB to only display the symbolic form of an address if the\n\
2752 offset between the closest earlier symbol and the address is less than\n\
2753 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2754 to always print the symbolic form of an address if any symbol precedes\n\
2755 it. Zero is equivalent to \"unlimited\"."),
2757 show_max_symbolic_offset,
2758 &setprintlist, &showprintlist);
2759 add_setshow_boolean_cmd ("symbol-filename", no_class,
2760 &print_symbol_filename, _("\
2761 Set printing of source filename and line number with <symbol>."), _("\
2762 Show printing of source filename and line number with <symbol>."), NULL,
2764 show_print_symbol_filename,
2765 &setprintlist, &showprintlist);
2767 add_com ("eval", no_class, eval_command, _("\
2768 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2769 a command line, and call it."));