Allow really large fortran array bounds: fortran type/value printers
[deliverable/binutils-gdb.git] / gdb / printcmd.c
CommitLineData
c906108c 1/* Print values for GNU debugger GDB.
e2ad119d 2
42a4f53d 3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
c906108c
SS
21#include "frame.h"
22#include "symtab.h"
23#include "gdbtypes.h"
24#include "value.h"
25#include "language.h"
26#include "expression.h"
27#include "gdbcore.h"
28#include "gdbcmd.h"
29#include "target.h"
30#include "breakpoint.h"
31#include "demangle.h"
50f182aa 32#include "gdb-demangle.h"
c906108c
SS
33#include "valprint.h"
34#include "annotate.h"
c5aa993b
JM
35#include "symfile.h" /* for overlay functions */
36#include "objfiles.h" /* ditto */
c94fdfd0 37#include "completer.h" /* for completion functions */
8b93c638 38#include "ui-out.h"
fe898f56 39#include "block.h"
92bf2b80 40#include "disasm.h"
f69fdf9b 41#include "target-float.h"
76727919 42#include "observable.h"
a3247a22 43#include "solist.h"
a3247a22 44#include "parser-defs.h"
6c7a06a3 45#include "charset.h"
704e9165 46#include "arch-utils.h"
e9cafbcc 47#include "cli/cli-utils.h"
01770bbd 48#include "cli/cli-script.h"
80ae2043 49#include "cli/cli-style.h"
0747795c 50#include "common/format.h"
05cba821 51#include "source.h"
d5722aa2 52#include "common/byte-vector.h"
c906108c 53
c906108c
SS
54/* Last specified output format. */
55
a6bac58e 56static char last_format = 0;
c906108c
SS
57
58/* Last specified examination size. 'b', 'h', 'w' or `q'. */
59
60static char last_size = 'w';
61
9be2ae8f
TT
62/* Last specified count for the 'x' command. */
63
64static int last_count;
65
5d3729b5 66/* Default address to examine next, and associated architecture. */
c906108c 67
5d3729b5 68static struct gdbarch *next_gdbarch;
c906108c
SS
69static CORE_ADDR next_address;
70
a4642986
MR
71/* Number of delay instructions following current disassembled insn. */
72
73static int branch_delay_insns;
74
c906108c
SS
75/* Last address examined. */
76
77static CORE_ADDR last_examine_address;
78
79/* Contents of last address examined.
80 This is not valid past the end of the `x' command! */
81
9b558729 82static value_ref_ptr last_examine_value;
c906108c
SS
83
84/* Largest offset between a symbolic value and an address, that will be
85 printed as `0x1234 <symbol+offset>'. */
86
87static unsigned int max_symbolic_offset = UINT_MAX;
920d2a44
AC
88static void
89show_max_symbolic_offset (struct ui_file *file, int from_tty,
90 struct cmd_list_element *c, const char *value)
91{
3e43a32a
MS
92 fprintf_filtered (file,
93 _("The largest offset that will be "
94 "printed in <symbol+1234> form is %s.\n"),
920d2a44
AC
95 value);
96}
c906108c
SS
97
98/* Append the source filename and linenumber of the symbol when
99 printing a symbolic value as `<symbol at filename:linenum>' if set. */
100static int print_symbol_filename = 0;
920d2a44
AC
101static void
102show_print_symbol_filename (struct ui_file *file, int from_tty,
103 struct cmd_list_element *c, const char *value)
104{
3e43a32a
MS
105 fprintf_filtered (file, _("Printing of source filename and "
106 "line number with <symbol> is %s.\n"),
920d2a44
AC
107 value);
108}
c906108c
SS
109
110/* Number of auto-display expression currently being displayed.
9d8fa392 111 So that we can disable it if we get a signal within it.
c906108c
SS
112 -1 when not doing one. */
113
5a18e302 114static int current_display_number;
c906108c 115
c906108c 116struct display
c5aa993b
JM
117 {
118 /* Chain link to next auto-display item. */
119 struct display *next;
6c95b8df 120
fa8a61dc
TT
121 /* The expression as the user typed it. */
122 char *exp_string;
6c95b8df 123
c5aa993b 124 /* Expression to be evaluated and displayed. */
4d01a485 125 expression_up exp;
6c95b8df 126
c5aa993b
JM
127 /* Item number of this auto-display item. */
128 int number;
6c95b8df 129
c5aa993b
JM
130 /* Display format specified. */
131 struct format_data format;
6c95b8df
PA
132
133 /* Program space associated with `block'. */
134 struct program_space *pspace;
135
0df8b418 136 /* Innermost block required by this expression when evaluated. */
270140bd 137 const struct block *block;
6c95b8df 138
0df8b418 139 /* Status of this display (enabled or disabled). */
b5de0fa7 140 int enabled_p;
c5aa993b 141 };
c906108c
SS
142
143/* Chain of expressions whose values should be displayed
144 automatically each time the program stops. */
145
146static struct display *display_chain;
147
148static int display_number;
149
c9174737
PA
150/* Walk the following statement or block through all displays.
151 ALL_DISPLAYS_SAFE does so even if the statement deletes the current
152 display. */
3c3fe74c
PA
153
154#define ALL_DISPLAYS(B) \
155 for (B = display_chain; B; B = B->next)
156
c9174737
PA
157#define ALL_DISPLAYS_SAFE(B,TMP) \
158 for (B = display_chain; \
159 B ? (TMP = B->next, 1): 0; \
160 B = TMP)
161
0df8b418 162/* Prototypes for local functions. */
c906108c 163
a14ed312 164static void do_one_display (struct display *);
c906108c 165\f
c5aa993b 166
c906108c
SS
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
172 user.
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. */
176
177static struct format_data
6f937416 178decode_format (const char **string_ptr, int oformat, int osize)
c906108c
SS
179{
180 struct format_data val;
6f937416 181 const char *p = *string_ptr;
c906108c
SS
182
183 val.format = '?';
184 val.size = '?';
185 val.count = 1;
a6bac58e 186 val.raw = 0;
c906108c 187
bb556f1f
TK
188 if (*p == '-')
189 {
190 val.count = -1;
191 p++;
192 }
c906108c 193 if (*p >= '0' && *p <= '9')
bb556f1f 194 val.count *= atoi (p);
c5aa993b
JM
195 while (*p >= '0' && *p <= '9')
196 p++;
c906108c
SS
197
198 /* Now process size or format letters that follow. */
199
200 while (1)
201 {
202 if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
203 val.size = *p++;
a6bac58e
TT
204 else if (*p == 'r')
205 {
206 val.raw = 1;
207 p++;
208 }
c906108c
SS
209 else if (*p >= 'a' && *p <= 'z')
210 val.format = *p++;
211 else
212 break;
213 }
214
2f433492 215 *string_ptr = skip_spaces (p);
c906108c
SS
216
217 /* Set defaults for format and size if not specified. */
218 if (val.format == '?')
219 {
220 if (val.size == '?')
221 {
222 /* Neither has been specified. */
223 val.format = oformat;
224 val.size = osize;
225 }
226 else
227 /* If a size is specified, any format makes a reasonable
228 default except 'i'. */
229 val.format = oformat == 'i' ? 'x' : oformat;
230 }
231 else if (val.size == '?')
232 switch (val.format)
233 {
234 case 'a':
5d3729b5
UW
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;
c906108c
SS
239 break;
240 case 'f':
241 /* Floating point has to be word or giantword. */
242 if (osize == 'w' || osize == 'g')
243 val.size = osize;
244 else
245 /* Default it to giantword if the last used size is not
246 appropriate. */
247 val.size = osize ? 'g' : osize;
248 break;
249 case 'c':
250 /* Characters default to one byte. */
251 val.size = osize ? 'b' : osize;
252 break;
9a22f0d0 253 case 's':
3e43a32a
MS
254 /* Display strings with byte size chars unless explicitly
255 specified. */
9a22f0d0
PM
256 val.size = '\0';
257 break;
258
c906108c
SS
259 default:
260 /* The default is the size most recently specified. */
261 val.size = osize;
262 }
263
264 return val;
265}
266\f
79a45b7d 267/* Print value VAL on stream according to OPTIONS.
c906108c 268 Do not end with a newline.
c906108c 269 SIZE is the letter for the size of datum being printed.
ea37ba09
DJ
270 This is used to pad hex numbers so they line up. SIZE is 0
271 for print / output and set for examine. */
c906108c
SS
272
273static void
79a45b7d
TT
274print_formatted (struct value *val, int size,
275 const struct value_print_options *options,
fba45db2 276 struct ui_file *stream)
c906108c 277{
df407dfe 278 struct type *type = check_typedef (value_type (val));
c906108c
SS
279 int len = TYPE_LENGTH (type);
280
281 if (VALUE_LVAL (val) == lval_memory)
42ae5230 282 next_address = value_address (val) + len;
c906108c 283
ea37ba09 284 if (size)
c906108c 285 {
79a45b7d 286 switch (options->format)
ea37ba09
DJ
287 {
288 case 's':
6c7a06a3
TT
289 {
290 struct type *elttype = value_type (val);
ad3bbd48 291
42ae5230 292 next_address = (value_address (val)
09ca9e2e 293 + val_print_string (elttype, NULL,
42ae5230 294 value_address (val), -1,
9a22f0d0 295 stream, options) * len);
6c7a06a3 296 }
ea37ba09 297 return;
c906108c 298
ea37ba09
DJ
299 case 'i':
300 /* We often wrap here if there are long symbolic names. */
301 wrap_here (" ");
42ae5230 302 next_address = (value_address (val)
13274fc3
UW
303 + gdb_print_insn (get_type_arch (type),
304 value_address (val), stream,
ea37ba09
DJ
305 &branch_delay_insns));
306 return;
307 }
c906108c 308 }
ea37ba09 309
79a45b7d 310 if (options->format == 0 || options->format == 's'
4e885b20 311 || TYPE_CODE (type) == TYPE_CODE_REF
ea37ba09
DJ
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)
79a45b7d 317 value_print (val, stream, options);
ea37ba09 318 else
b021a221
MS
319 /* User specified format, so don't look to the type to tell us
320 what to do. */
ab2188aa 321 val_print_scalar_formatted (type,
ab2188aa
PA
322 value_embedded_offset (val),
323 val,
324 options, size, stream);
c906108c
SS
325}
326
b806fb9a
UW
327/* Return builtin floating point type of same length as TYPE.
328 If no such type is found, return TYPE itself. */
329static struct type *
50810684 330float_type_from_length (struct type *type)
b806fb9a 331{
50810684 332 struct gdbarch *gdbarch = get_type_arch (type);
b806fb9a 333 const struct builtin_type *builtin = builtin_type (gdbarch);
b806fb9a 334
744a8059 335 if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
b806fb9a 336 type = builtin->builtin_float;
744a8059 337 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
b806fb9a 338 type = builtin->builtin_double;
744a8059 339 else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
b806fb9a
UW
340 type = builtin->builtin_long_double;
341
342 return type;
343}
344
c906108c 345/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
ab2188aa
PA
346 according to OPTIONS and SIZE on STREAM. Formats s and i are not
347 supported at this level. */
c906108c
SS
348
349void
7c543f7b 350print_scalar_formatted (const gdb_byte *valaddr, struct type *type,
79a45b7d
TT
351 const struct value_print_options *options,
352 int size, struct ui_file *stream)
c906108c 353{
50810684 354 struct gdbarch *gdbarch = get_type_arch (type);
c906108c 355 unsigned int len = TYPE_LENGTH (type);
69feb676 356 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
c906108c 357
ab2188aa
PA
358 /* String printing should go through val_print_scalar_formatted. */
359 gdb_assert (options->format != 's');
ea37ba09 360
ef166cf4 361 /* If the value is a pointer, and pointers and addresses are not the
d0aee0c4 362 same, then at this point, the value's length (in target bytes) is
17a912b6 363 gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
ef166cf4 364 if (TYPE_CODE (type) == TYPE_CODE_PTR)
69feb676 365 len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
ef166cf4 366
c906108c
SS
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). */
d9109c80
TT
370 if (options->format != 'c'
371 && (options->format != 'd' || TYPE_UNSIGNED (type)))
c906108c 372 {
d9109c80
TT
373 if (len < TYPE_LENGTH (type) && byte_order == BFD_ENDIAN_BIG)
374 valaddr += TYPE_LENGTH (type) - len;
c906108c
SS
375 }
376
d9109c80 377 if (size != 0 && (options->format == 'x' || options->format == 't'))
c906108c 378 {
d9109c80
TT
379 /* Truncate to fit. */
380 unsigned newlen;
381 switch (size)
c906108c 382 {
d9109c80
TT
383 case 'b':
384 newlen = 1;
385 break;
386 case 'h':
387 newlen = 2;
388 break;
389 case 'w':
390 newlen = 4;
391 break;
392 case 'g':
393 newlen = 8;
394 break;
395 default:
396 error (_("Undefined output size \"%c\"."), size);
c906108c 397 }
d9109c80
TT
398 if (newlen < len && byte_order == BFD_ENDIAN_BIG)
399 valaddr += len - newlen;
400 len = newlen;
401 }
c906108c 402
d9109c80
TT
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. */
d5722aa2 406 gdb::byte_vector converted_float_bytes;
d9109c80
TT
407 if (TYPE_CODE (type) == TYPE_CODE_FLT
408 && (options->format == 'o'
409 || options->format == 'x'
410 || options->format == 't'
d6382fff
TT
411 || options->format == 'z'
412 || options->format == 'd'
413 || options->format == 'u'))
d9109c80
TT
414 {
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 ();
420 }
c906108c 421
fdf0cbc2
UW
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)
427 {
428 type = float_type_from_length (type);
429 if (TYPE_CODE (type) != TYPE_CODE_FLT)
430 format = 0;
431 }
432
433 switch (format)
d9109c80
TT
434 {
435 case 'o':
436 print_octal_chars (stream, valaddr, len, byte_order);
437 break;
d6382fff
TT
438 case 'd':
439 print_decimal_chars (stream, valaddr, len, true, byte_order);
440 break;
c906108c 441 case 'u':
d9109c80 442 print_decimal_chars (stream, valaddr, len, false, byte_order);
c906108c 443 break;
d9109c80 444 case 0:
d9109c80
TT
445 if (TYPE_CODE (type) != TYPE_CODE_FLT)
446 {
447 print_decimal_chars (stream, valaddr, len, !TYPE_UNSIGNED (type),
448 byte_order);
449 break;
450 }
451 /* FALLTHROUGH */
452 case 'f':
d9109c80 453 print_floating (valaddr, type, stream);
c906108c
SS
454 break;
455
d9109c80
TT
456 case 't':
457 print_binary_chars (stream, valaddr, len, byte_order, size > 0);
458 break;
459 case 'x':
460 print_hex_chars (stream, valaddr, len, byte_order, size > 0);
461 break;
462 case 'z':
463 print_hex_chars (stream, valaddr, len, byte_order, true);
c906108c 464 break;
c906108c 465 case 'c':
79a45b7d
TT
466 {
467 struct value_print_options opts = *options;
69feb676 468
d9109c80
TT
469 LONGEST val_long = unpack_long (type, valaddr);
470
ad3bbd48 471 opts.format = 0;
79a45b7d 472 if (TYPE_UNSIGNED (type))
69feb676
UW
473 type = builtin_type (gdbarch)->builtin_true_unsigned_char;
474 else
475 type = builtin_type (gdbarch)->builtin_true_char;
476
477 value_print (value_from_longest (type, val_long), stream, &opts);
79a45b7d 478 }
c906108c
SS
479 break;
480
d9109c80 481 case 'a':
c906108c 482 {
d9109c80 483 CORE_ADDR addr = unpack_pointer (type, valaddr);
c906108c 484
d9109c80 485 print_address (gdbarch, addr, stream);
c906108c
SS
486 }
487 break;
488
489 default:
fdf0cbc2 490 error (_("Undefined output format \"%c\"."), format);
c906108c
SS
491 }
492}
493
494/* Specify default address for `x' command.
675dcf4f 495 The `info lines' command uses this. */
c906108c
SS
496
497void
8b9b9e1a 498set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
c906108c 499{
8b9b9e1a
UW
500 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
501
5d3729b5 502 next_gdbarch = gdbarch;
c906108c
SS
503 next_address = addr;
504
505 /* Make address available to the user as $_. */
506 set_internalvar (lookup_internalvar ("_"),
8b9b9e1a 507 value_from_pointer (ptr_type, addr));
c906108c
SS
508}
509
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
9cb709b6
TT
516 settings of the demangle and asm_demangle variables. Returns
517 non-zero if anything was printed; zero otherwise. */
c906108c 518
9cb709b6 519int
22e722e1
DJ
520print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
521 struct ui_file *stream,
a121b7c1 522 int do_demangle, const char *leadin)
dfcd3bfb 523{
c7110220 524 std::string name, filename;
dfcd3bfb
JM
525 int unmapped = 0;
526 int offset = 0;
527 int line = 0;
528
22e722e1 529 if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
675dcf4f 530 &filename, &line, &unmapped))
c7110220 531 return 0;
dfcd3bfb
JM
532
533 fputs_filtered (leadin, stream);
534 if (unmapped)
535 fputs_filtered ("<*", stream);
536 else
537 fputs_filtered ("<", stream);
af79b68d 538 fputs_styled (name.c_str (), function_name_style.style (), stream);
dfcd3bfb
JM
539 if (offset != 0)
540 fprintf_filtered (stream, "+%u", (unsigned int) offset);
541
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. */
c7110220 544 if (print_symbol_filename && !filename.empty ())
dfcd3bfb 545 {
af79b68d
TT
546 fputs_filtered (line == -1 ? " in " : " at ", stream);
547 fputs_styled (filename.c_str (), file_name_style.style (), stream);
dfcd3bfb 548 if (line != -1)
af79b68d 549 fprintf_filtered (stream, ":%d", line);
dfcd3bfb
JM
550 }
551 if (unmapped)
552 fputs_filtered ("*>", stream);
553 else
554 fputs_filtered (">", stream);
555
9cb709b6 556 return 1;
dfcd3bfb
JM
557}
558
c7110220
TT
559/* See valprint.h. */
560
dfcd3bfb 561int
22e722e1
DJ
562build_address_symbolic (struct gdbarch *gdbarch,
563 CORE_ADDR addr, /* IN */
dfcd3bfb 564 int do_demangle, /* IN */
c7110220 565 std::string *name, /* OUT */
dfcd3bfb 566 int *offset, /* OUT */
c7110220 567 std::string *filename, /* OUT */
dfcd3bfb
JM
568 int *line, /* OUT */
569 int *unmapped) /* OUT */
c906108c 570{
77e371c0 571 struct bound_minimal_symbol msymbol;
c906108c 572 struct symbol *symbol;
c906108c 573 CORE_ADDR name_location = 0;
714835d5 574 struct obj_section *section = NULL;
0d5cff50 575 const char *name_temp = "";
dfcd3bfb 576
89c83b10 577 /* Let's say it is mapped (not unmapped). */
dfcd3bfb 578 *unmapped = 0;
c906108c 579
dfcd3bfb 580 /* Determine if the address is in an overlay, and whether it is
675dcf4f 581 mapped. */
c906108c
SS
582 if (overlay_debugging)
583 {
584 section = find_pc_overlay (addr);
585 if (pc_in_unmapped_range (addr, section))
586 {
dfcd3bfb 587 *unmapped = 1;
c906108c
SS
588 addr = overlay_mapped_address (addr, section);
589 }
590 }
591
c906108c
SS
592 /* First try to find the address in the symbol table, then
593 in the minsyms. Take the closest one. */
594
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
600 symbols anyway). */
77e371c0 601 msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
c906108c
SS
602 symbol = find_pc_sect_function (addr, section);
603
604 if (symbol)
605 {
22e722e1
DJ
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);
612
2b1ffcfd 613 name_location = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (symbol));
406fc7fb 614 if (do_demangle || asm_demangle)
de5ad195 615 name_temp = SYMBOL_PRINT_NAME (symbol);
c906108c 616 else
3567439c 617 name_temp = SYMBOL_LINKAGE_NAME (symbol);
c906108c
SS
618 }
619
77e371c0
TT
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;
9cb709b6 627
77e371c0 628 if (msymbol.minsym != NULL)
c906108c 629 {
77e371c0 630 if (BMSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
c906108c 631 {
fe8400b4
WN
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. */
77e371c0
TT
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)
fe8400b4
WN
641 addr = gdbarch_addr_bits_remove (gdbarch, addr);
642
c906108c
SS
643 /* The msymbol is closer to the address than the symbol;
644 use the msymbol instead. */
645 symbol = 0;
77e371c0 646 name_location = BMSYMBOL_VALUE_ADDRESS (msymbol);
406fc7fb 647 if (do_demangle || asm_demangle)
77e371c0 648 name_temp = MSYMBOL_PRINT_NAME (msymbol.minsym);
c906108c 649 else
77e371c0 650 name_temp = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
c906108c
SS
651 }
652 }
77e371c0 653 if (symbol == NULL && msymbol.minsym == NULL)
dfcd3bfb 654 return 1;
c906108c 655
c906108c
SS
656 /* If the nearest symbol is too far away, don't print anything symbolic. */
657
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)
dfcd3bfb 665 return 1;
c906108c 666
dfcd3bfb
JM
667 *offset = addr - name_location;
668
c7110220 669 *name = name_temp;
c906108c 670
c906108c
SS
671 if (print_symbol_filename)
672 {
673 struct symtab_and_line sal;
674
675 sal = find_pc_sect_line (addr, section, 0);
676
677 if (sal.symtab)
dfcd3bfb 678 {
c7110220 679 *filename = symtab_to_filename_for_display (sal.symtab);
dfcd3bfb
JM
680 *line = sal.line;
681 }
c906108c 682 }
dfcd3bfb 683 return 0;
c906108c
SS
684}
685
c906108c
SS
686
687/* Print address ADDR symbolically on STREAM.
688 First print it as a number. Then perhaps print
689 <SYMBOL + OFFSET> after the number. */
690
691void
5af949e3
UW
692print_address (struct gdbarch *gdbarch,
693 CORE_ADDR addr, struct ui_file *stream)
c906108c 694{
35fb8261 695 fputs_styled (paddress (gdbarch, addr), address_style.style (), stream);
22e722e1 696 print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
c906108c
SS
697}
698
2b28d209
PP
699/* Return a prefix for instruction address:
700 "=> " for current instruction, else " ". */
701
702const char *
703pc_prefix (CORE_ADDR addr)
704{
705 if (has_stack_frames ())
706 {
707 struct frame_info *frame;
708 CORE_ADDR pc;
709
710 frame = get_selected_frame (NULL);
ce406537 711 if (get_frame_pc_if_available (frame, &pc) && pc == addr)
2b28d209
PP
712 return "=> ";
713 }
714 return " ";
715}
716
c906108c
SS
717/* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
718 controls whether to print the symbolic name "raw" or demangled.
9cb709b6 719 Return non-zero if anything was printed; zero otherwise. */
c906108c 720
9cb709b6 721int
edf0c1b7
TT
722print_address_demangle (const struct value_print_options *opts,
723 struct gdbarch *gdbarch, CORE_ADDR addr,
5af949e3 724 struct ui_file *stream, int do_demangle)
c906108c 725{
1d51a733 726 if (opts->addressprint)
c906108c 727 {
35fb8261 728 fputs_styled (paddress (gdbarch, addr), address_style.style (), stream);
22e722e1 729 print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
c906108c
SS
730 }
731 else
732 {
9cb709b6 733 return print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
c906108c 734 }
9cb709b6 735 return 1;
c906108c
SS
736}
737\f
738
bb556f1f
TK
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. */
747
748static CORE_ADDR
749find_instruction_backward (struct gdbarch *gdbarch, CORE_ADDR addr,
750 int inst_count, int *inst_read)
751{
752 /* The vector PCS is used to store instruction addresses within
753 a pc range. */
754 CORE_ADDR loop_start, loop_end, p;
52d214d3 755 std::vector<CORE_ADDR> pcs;
bb556f1f 756 struct symtab_and_line sal;
bb556f1f
TK
757
758 *inst_read = 0;
759 loop_start = loop_end = addr;
760
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. */
768 do
769 {
52d214d3 770 pcs.clear ();
bb556f1f
TK
771 sal = find_pc_sect_line (loop_start, NULL, 1);
772 if (sal.line <= 0)
773 {
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 "
778 "for address "));
779 wrap_here (" ");
780 print_address (gdbarch, loop_start - 1, gdb_stdout);
781 printf_filtered ("\n");
782 break;
783 }
784
785 loop_end = loop_start;
786 loop_start = sal.pc;
787
788 /* This loop pushes instruction addresses in the range from
789 LOOP_START to LOOP_END. */
790 for (p = loop_start; p < loop_end;)
791 {
52d214d3 792 pcs.push_back (p);
bb556f1f
TK
793 p += gdb_insn_length (gdbarch, p);
794 }
795
52d214d3
TT
796 inst_count -= pcs.size ();
797 *inst_read += pcs.size ();
bb556f1f
TK
798 }
799 while (inst_count > 0);
800
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
804 the reason below.
805 Let's assume the following instruction addresses and run 'x/-4i 0x400e'.
806 Line X of File
807 0x4000
808 0x4001
809 0x4005
810 Line Y of File
811 0x4009
812 0x400c
813 => 0x400e
814 0x4011
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. */
52d214d3 823 p = pcs.size () > 0 ? pcs[-inst_count] : loop_start;
bb556f1f
TK
824
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. */
828 if (inst_count < 0)
829 *inst_read += inst_count;
830
bb556f1f
TK
831 return p;
832}
833
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. */
837
838static int
839read_memory_backward (struct gdbarch *gdbarch,
840 CORE_ADDR memaddr, gdb_byte *myaddr, int len)
841{
842 int errcode;
843 int nread; /* Number of bytes actually read. */
844
845 /* First try a complete read. */
846 errcode = target_read_memory (memaddr, myaddr, len);
847 if (errcode == 0)
848 {
849 /* Got it all. */
850 nread = len;
851 }
852 else
853 {
854 /* Loop, reading one byte at a time until we get as much as we can. */
855 memaddr += len;
856 myaddr += len;
857 for (nread = 0; nread < len; ++nread)
858 {
859 errcode = target_read_memory (--memaddr, --myaddr, 1);
860 if (errcode != 0)
861 {
862 /* The read was unsuccessful, so exit the loop. */
863 printf_filtered (_("Cannot access memory at address %s\n"),
864 paddress (gdbarch, memaddr));
865 break;
866 }
867 }
868 }
869 return nread;
870}
871
872/* Returns true if X (which is LEN bytes wide) is the number zero. */
873
874static int
875integer_is_zero (const gdb_byte *x, int len)
876{
877 int i = 0;
878
879 while (i < len && x[i] == 0)
880 ++i;
881 return (i == len);
882}
883
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. */
889
890static CORE_ADDR
891find_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)
895{
896 const int chunk_size = 0x20;
bb556f1f
TK
897 int read_error = 0;
898 int chars_read = 0;
899 int chars_to_read = chunk_size;
900 int chars_counted = 0;
901 int count_original = count;
902 CORE_ADDR string_start_addr = addr;
903
904 gdb_assert (char_size == 1 || char_size == 2 || char_size == 4);
26fcd5d7 905 gdb::byte_vector buffer (chars_to_read * char_size);
bb556f1f
TK
906 while (count > 0 && read_error == 0)
907 {
908 int i;
909
910 addr -= chars_to_read * char_size;
26fcd5d7 911 chars_read = read_memory_backward (gdbarch, addr, buffer.data (),
bb556f1f
TK
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)
917 {
918 int offset = (chars_to_read - i - 1) * char_size;
919
26fcd5d7 920 if (integer_is_zero (&buffer[offset], char_size)
bb556f1f
TK
921 || chars_counted == options->print_max)
922 {
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
925 a string. */
926 --count;
927 string_start_addr = addr + offset + char_size;
928 chars_counted = 0;
929 }
930 }
931 }
932
933 /* Update STRINGS_COUNTED with the actual number of loaded strings. */
934 *strings_counted = count_original - count;
935
936 if (read_error != 0)
937 {
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;
941 }
942
bb556f1f
TK
943 return string_start_addr;
944}
945
c906108c
SS
946/* Examine data at address ADDR in format FMT.
947 Fetch it from memory and print on gdb_stdout. */
948
949static void
5d3729b5 950do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
c906108c 951{
52f0bd74
AC
952 char format = 0;
953 char size;
954 int count = 1;
c906108c 955 struct type *val_type = NULL;
52f0bd74
AC
956 int i;
957 int maxelts;
79a45b7d 958 struct value_print_options opts;
bb556f1f
TK
959 int need_to_update_next_address = 0;
960 CORE_ADDR addr_rewound = 0;
c906108c
SS
961
962 format = fmt.format;
963 size = fmt.size;
964 count = fmt.count;
5d3729b5 965 next_gdbarch = gdbarch;
c906108c 966 next_address = addr;
c906108c 967
9a22f0d0
PM
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'. */
972 if (format == 'i')
c906108c
SS
973 size = 'b';
974
5d3729b5
UW
975 if (size == 'a')
976 {
977 /* Pick the appropriate size for an address. */
978 if (gdbarch_ptr_bit (next_gdbarch) == 64)
979 size = 'g';
980 else if (gdbarch_ptr_bit (next_gdbarch) == 32)
981 size = 'w';
982 else if (gdbarch_ptr_bit (next_gdbarch) == 16)
983 size = 'h';
984 else
985 /* Bad value for gdbarch_ptr_bit. */
986 internal_error (__FILE__, __LINE__,
987 _("failed internal consistency check"));
988 }
989
990 if (size == 'b')
df4df182 991 val_type = builtin_type (next_gdbarch)->builtin_int8;
c906108c 992 else if (size == 'h')
df4df182 993 val_type = builtin_type (next_gdbarch)->builtin_int16;
c906108c 994 else if (size == 'w')
df4df182 995 val_type = builtin_type (next_gdbarch)->builtin_int32;
c906108c 996 else if (size == 'g')
df4df182 997 val_type = builtin_type (next_gdbarch)->builtin_int64;
c906108c 998
9a22f0d0
PM
999 if (format == 's')
1000 {
1001 struct type *char_type = NULL;
ad3bbd48 1002
9a22f0d0
PM
1003 /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
1004 if type is not found. */
1005 if (size == 'h')
1006 char_type = builtin_type (next_gdbarch)->builtin_char16;
1007 else if (size == 'w')
1008 char_type = builtin_type (next_gdbarch)->builtin_char32;
1009 if (char_type)
1010 val_type = char_type;
1011 else
1012 {
1013 if (size != '\0' && size != 'b')
0df8b418
MS
1014 warning (_("Unable to display strings with "
1015 "size '%c', using 'b' instead."), size);
9a22f0d0
PM
1016 size = 'b';
1017 val_type = builtin_type (next_gdbarch)->builtin_int8;
1018 }
1019 }
1020
c906108c
SS
1021 maxelts = 8;
1022 if (size == 'w')
1023 maxelts = 4;
1024 if (size == 'g')
1025 maxelts = 2;
1026 if (format == 's' || format == 'i')
1027 maxelts = 1;
1028
79a45b7d
TT
1029 get_formatted_print_options (&opts, format);
1030
bb556f1f
TK
1031 if (count < 0)
1032 {
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. */
1036
1037 count = -count;
1038 if (format == 'i')
1039 {
1040 next_address = find_instruction_backward (gdbarch, addr, count,
1041 &count);
1042 }
1043 else if (format == 's')
1044 {
1045 next_address = find_string_backward (gdbarch, addr, count,
1046 TYPE_LENGTH (val_type),
1047 &opts, &count);
1048 }
1049 else
1050 {
1051 next_address = addr - count * TYPE_LENGTH (val_type);
1052 }
1053
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)
1059 : next_address);
1060 need_to_update_next_address = 1;
1061 }
1062
c906108c
SS
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. */
1065
1066 while (count > 0)
1067 {
1068 QUIT;
2b28d209
PP
1069 if (format == 'i')
1070 fputs_filtered (pc_prefix (next_address), gdb_stdout);
5af949e3 1071 print_address (next_gdbarch, next_address, gdb_stdout);
c906108c
SS
1072 printf_filtered (":");
1073 for (i = maxelts;
1074 i > 0 && count > 0;
1075 i--, count--)
1076 {
1077 printf_filtered ("\t");
1078 /* Note that print_formatted sets next_address for the next
1079 object. */
1080 last_examine_address = next_address;
1081
c906108c 1082 /* The value to be displayed is not fetched greedily.
5d51a2db
MR
1083 Instead, to avoid the possibility of a fetched value not
1084 being used, its retrieval is delayed until the print code
c5aa993b
JM
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
0df8b418 1090 instruction fetched from memory? */
9b558729
TT
1091 last_examine_value
1092 = release_value (value_at_lazy (val_type, next_address));
c906108c 1093
9b558729 1094 print_formatted (last_examine_value.get (), size, &opts, gdb_stdout);
a4642986
MR
1095
1096 /* Display any branch delay slots following the final insn. */
1097 if (format == 'i' && count == 1)
1098 count += branch_delay_insns;
c906108c
SS
1099 }
1100 printf_filtered ("\n");
c906108c 1101 }
bb556f1f
TK
1102
1103 if (need_to_update_next_address)
1104 next_address = addr_rewound;
c906108c
SS
1105}
1106\f
1107static void
8d89f51a 1108validate_format (struct format_data fmt, const char *cmdname)
c906108c
SS
1109{
1110 if (fmt.size != 0)
8a3fe4f8 1111 error (_("Size letters are meaningless in \"%s\" command."), cmdname);
c906108c 1112 if (fmt.count != 1)
8a3fe4f8 1113 error (_("Item count other than 1 is meaningless in \"%s\" command."),
c906108c 1114 cmdname);
ea37ba09 1115 if (fmt.format == 'i')
8a3fe4f8 1116 error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
c906108c
SS
1117 fmt.format, cmdname);
1118}
1119
1c88ceb1
JK
1120/* Parse print command format string into *FMTP and update *EXPP.
1121 CMDNAME should name the current command. */
1122
1123void
1124print_command_parse_format (const char **expp, const char *cmdname,
1125 struct format_data *fmtp)
1126{
1127 const char *exp = *expp;
1128
1129 if (exp && *exp == '/')
1130 {
1131 exp++;
1132 *fmtp = decode_format (&exp, last_format, 0);
1133 validate_format (*fmtp, cmdname);
1134 last_format = fmtp->format;
1135 }
1136 else
1137 {
1138 fmtp->count = 1;
1139 fmtp->format = 0;
1140 fmtp->size = 0;
1141 fmtp->raw = 0;
1142 }
1143
1144 *expp = exp;
1145}
1146
1147/* Print VAL to console according to *FMTP, including recording it to
1148 the history. */
1149
1150void
1151print_value (struct value *val, const struct format_data *fmtp)
1152{
1153 struct value_print_options opts;
1154 int histindex = record_latest_value (val);
1155
1156 annotate_value_history_begin (histindex, value_type (val));
1157
1158 printf_filtered ("$%d = ", histindex);
1159
1160 annotate_value_history_value ();
1161
1162 get_formatted_print_options (&opts, fmtp->format);
1163 opts.raw = fmtp->raw;
1164
1165 print_formatted (val, fmtp->size, &opts, gdb_stdout);
1166 printf_filtered ("\n");
1167
1168 annotate_value_history_end ();
1169}
1170
675dcf4f 1171/* Evaluate string EXP as an expression in the current language and
c5aa993b 1172 print the resulting value. EXP may contain a format specifier as the
675dcf4f 1173 first argument ("/x myvar" for example, to print myvar in hex). */
c906108c
SS
1174
1175static void
6f937416 1176print_command_1 (const char *exp, int voidprint)
c906108c 1177{
3d6d86c6 1178 struct value *val;
c906108c 1179 struct format_data fmt;
c906108c 1180
1c88ceb1 1181 print_command_parse_format (&exp, "print", &fmt);
c906108c
SS
1182
1183 if (exp && *exp)
1184 {
4d01a485
PA
1185 expression_up expr = parse_expression (exp);
1186 val = evaluate_expression (expr.get ());
c906108c
SS
1187 }
1188 else
1189 val = access_value_history (0);
1190
df407dfe
AC
1191 if (voidprint || (val && value_type (val) &&
1192 TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
1c88ceb1 1193 print_value (val, &fmt);
c906108c
SS
1194}
1195
c906108c 1196static void
0b39b52e 1197print_command (const char *exp, int from_tty)
c906108c 1198{
e93a8774 1199 print_command_1 (exp, 1);
c906108c
SS
1200}
1201
675dcf4f 1202/* Same as print, except it doesn't print void results. */
c906108c 1203static void
0b39b52e 1204call_command (const char *exp, int from_tty)
c906108c 1205{
e93a8774 1206 print_command_1 (exp, 0);
c906108c
SS
1207}
1208
6f937416
PA
1209/* Implementation of the "output" command. */
1210
6f937416 1211void
122b53ea 1212output_command (const char *exp, int from_tty)
c906108c 1213{
52f0bd74 1214 char format = 0;
3d6d86c6 1215 struct value *val;
c906108c 1216 struct format_data fmt;
79a45b7d 1217 struct value_print_options opts;
c906108c 1218
777ea8f1 1219 fmt.size = 0;
a6bac58e 1220 fmt.raw = 0;
777ea8f1 1221
c906108c
SS
1222 if (exp && *exp == '/')
1223 {
1224 exp++;
1225 fmt = decode_format (&exp, 0, 0);
1226 validate_format (fmt, "output");
1227 format = fmt.format;
1228 }
1229
4d01a485 1230 expression_up expr = parse_expression (exp);
c906108c 1231
4d01a485 1232 val = evaluate_expression (expr.get ());
c906108c 1233
df407dfe 1234 annotate_value_begin (value_type (val));
c906108c 1235
79a45b7d 1236 get_formatted_print_options (&opts, format);
a6bac58e 1237 opts.raw = fmt.raw;
79a45b7d 1238 print_formatted (val, fmt.size, &opts, gdb_stdout);
c906108c
SS
1239
1240 annotate_value_end ();
1241
2acceee2
JM
1242 wrap_here ("");
1243 gdb_flush (gdb_stdout);
c906108c
SS
1244}
1245
c906108c 1246static void
981a3fb3 1247set_command (const char *exp, int from_tty)
c906108c 1248{
4d01a485 1249 expression_up expr = parse_expression (exp);
ad3bbd48 1250
0ece64fd
TG
1251 if (expr->nelts >= 1)
1252 switch (expr->elts[0].opcode)
1253 {
1254 case UNOP_PREINCREMENT:
1255 case UNOP_POSTINCREMENT:
1256 case UNOP_PREDECREMENT:
1257 case UNOP_POSTDECREMENT:
1258 case BINOP_ASSIGN:
1259 case BINOP_ASSIGN_MODIFY:
1260 case BINOP_COMMA:
1261 break;
1262 default:
1263 warning
1264 (_("Expression is not an assignment (and might have no effect)"));
1265 }
52b3699b 1266
4d01a485 1267 evaluate_expression (expr.get ());
c906108c
SS
1268}
1269
c906108c 1270static void
1d12d88f 1271info_symbol_command (const char *arg, int from_tty)
c906108c
SS
1272{
1273 struct minimal_symbol *msymbol;
c5aa993b 1274 struct obj_section *osect;
c5aa993b
JM
1275 CORE_ADDR addr, sect_addr;
1276 int matches = 0;
1277 unsigned int offset;
c906108c
SS
1278
1279 if (!arg)
e2e0b3e5 1280 error_no_arg (_("address"));
c906108c
SS
1281
1282 addr = parse_and_eval_address (arg);
2030c079 1283 for (objfile *objfile : current_program_space->objfiles ())
3b9d3ac2 1284 ALL_OBJFILE_OSECTIONS (objfile, osect)
c5aa993b 1285 {
3b9d3ac2
TT
1286 /* Only process each object file once, even if there's a separate
1287 debug file. */
1288 if (objfile->separate_debug_objfile_backlink)
1289 continue;
1290
1291 sect_addr = overlay_mapped_address (addr, osect);
1292
1293 if (obj_section_addr (osect) <= sect_addr
1294 && sect_addr < obj_section_endaddr (osect)
1295 && (msymbol
1296 = lookup_minimal_symbol_by_pc_section (sect_addr,
1297 osect).minsym))
5178ed48 1298 {
3b9d3ac2
TT
1299 const char *obj_name, *mapped, *sec_name, *msym_name;
1300 const char *loc_string;
1301
1302 matches = 1;
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);
1307
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;
1311 if (offset)
1312 {
1313 string_holder = string_printf ("%s + %u", msym_name, offset);
1314 loc_string = string_holder.c_str ();
1315 }
c14c28ba 1316 else
3b9d3ac2
TT
1317 loc_string = msym_name;
1318
1319 gdb_assert (osect->objfile && objfile_name (osect->objfile));
1320 obj_name = objfile_name (osect->objfile);
1321
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);
1328 else
1329 printf_filtered (_("%s in load address range of "
1330 "section %s of %s\n"),
1331 loc_string, sec_name, obj_name);
1332 else
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);
1336 else
1337 printf_filtered (_("%s in section %s of %s\n"),
1338 loc_string, sec_name, obj_name);
c14c28ba 1339 else
3b9d3ac2
TT
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 "
1343 "section %s\n"),
1344 loc_string, mapped, sec_name);
1345 else
1346 printf_filtered
1347 (_("%s in load address range of section %s\n"),
1348 loc_string, sec_name);
1349 else
1350 if (section_is_overlay (osect))
1351 printf_filtered (_("%s in %s overlay section %s\n"),
1352 loc_string, mapped, sec_name);
1353 else
1354 printf_filtered (_("%s in section %s\n"),
1355 loc_string, sec_name);
1356 }
c5aa993b 1357 }
c906108c 1358 if (matches == 0)
a3f17187 1359 printf_filtered (_("No symbol matches %s.\n"), arg);
c906108c
SS
1360}
1361
c906108c 1362static void
1d12d88f 1363info_address_command (const char *exp, int from_tty)
c906108c 1364{
768a979c
UW
1365 struct gdbarch *gdbarch;
1366 int regno;
52f0bd74 1367 struct symbol *sym;
7c7b6655 1368 struct bound_minimal_symbol msymbol;
52f0bd74 1369 long val;
714835d5 1370 struct obj_section *section;
08922a10 1371 CORE_ADDR load_addr, context_pc = 0;
1993b719 1372 struct field_of_this_result is_a_field_of_this;
c906108c
SS
1373
1374 if (exp == 0)
8a3fe4f8 1375 error (_("Argument required."));
c906108c 1376
08922a10 1377 sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
d12307c1 1378 &is_a_field_of_this).symbol;
c906108c
SS
1379 if (sym == NULL)
1380 {
1993b719 1381 if (is_a_field_of_this.type != NULL)
c906108c
SS
1382 {
1383 printf_filtered ("Symbol \"");
1384 fprintf_symbol_filtered (gdb_stdout, exp,
1385 current_language->la_language, DMGL_ANSI);
e2b23ee9
AF
1386 printf_filtered ("\" is a field of the local class variable ");
1387 if (current_language->la_language == language_objc)
2625d86c 1388 printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
e2b23ee9 1389 else
2625d86c 1390 printf_filtered ("`this'\n");
c906108c
SS
1391 return;
1392 }
1393
7c7b6655 1394 msymbol = lookup_bound_minimal_symbol (exp);
c906108c 1395
7c7b6655 1396 if (msymbol.minsym != NULL)
c906108c 1397 {
7c7b6655 1398 struct objfile *objfile = msymbol.objfile;
e27d198c
TT
1399
1400 gdbarch = get_objfile_arch (objfile);
77e371c0 1401 load_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
c906108c
SS
1402
1403 printf_filtered ("Symbol \"");
1404 fprintf_symbol_filtered (gdb_stdout, exp,
1405 current_language->la_language, DMGL_ANSI);
1406 printf_filtered ("\" is at ");
35fb8261
TT
1407 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1408 gdb_stdout);
c906108c 1409 printf_filtered (" in a file compiled without debugging");
efd66ac6 1410 section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
c906108c
SS
1411 if (section_is_overlay (section))
1412 {
1413 load_addr = overlay_unmapped_address (load_addr, section);
1414 printf_filtered (",\n -- loaded at ");
35fb8261
TT
1415 fputs_styled (paddress (gdbarch, load_addr),
1416 address_style.style (),
1417 gdb_stdout);
714835d5
UW
1418 printf_filtered (" in overlay section %s",
1419 section->the_bfd_section->name);
c906108c
SS
1420 }
1421 printf_filtered (".\n");
1422 }
1423 else
8a3fe4f8 1424 error (_("No symbol \"%s\" in current context."), exp);
c906108c
SS
1425 return;
1426 }
1427
1428 printf_filtered ("Symbol \"");
3567439c 1429 fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
c906108c
SS
1430 current_language->la_language, DMGL_ANSI);
1431 printf_filtered ("\" is ");
c5aa993b 1432 val = SYMBOL_VALUE (sym);
1994afbf
DE
1433 if (SYMBOL_OBJFILE_OWNED (sym))
1434 section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
1435 else
1436 section = NULL;
08be3fe3 1437 gdbarch = symbol_arch (sym);
c906108c 1438
24d6c2a0
TT
1439 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
1440 {
1441 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
1442 gdb_stdout);
1443 printf_filtered (".\n");
1444 return;
1445 }
1446
c906108c
SS
1447 switch (SYMBOL_CLASS (sym))
1448 {
1449 case LOC_CONST:
1450 case LOC_CONST_BYTES:
1451 printf_filtered ("constant");
1452 break;
1453
1454 case LOC_LABEL:
1455 printf_filtered ("a label at address ");
5af949e3 1456 load_addr = SYMBOL_VALUE_ADDRESS (sym);
35fb8261
TT
1457 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1458 gdb_stdout);
c906108c
SS
1459 if (section_is_overlay (section))
1460 {
1461 load_addr = overlay_unmapped_address (load_addr, section);
1462 printf_filtered (",\n -- loaded at ");
35fb8261
TT
1463 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1464 gdb_stdout);
714835d5
UW
1465 printf_filtered (" in overlay section %s",
1466 section->the_bfd_section->name);
c906108c
SS
1467 }
1468 break;
1469
4c2df51b 1470 case LOC_COMPUTED:
24d6c2a0 1471 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
4c2df51b 1472
c906108c 1473 case LOC_REGISTER:
768a979c
UW
1474 /* GDBARCH is the architecture associated with the objfile the symbol
1475 is defined in; the target architecture may be different, and may
1476 provide additional registers. However, we do not know the target
1477 architecture at this point. We assume the objfile architecture
1478 will contain all the standard registers that occur in debug info
1479 in that objfile. */
1480 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1481
2a2d4dc3
AS
1482 if (SYMBOL_IS_ARGUMENT (sym))
1483 printf_filtered (_("an argument in register %s"),
768a979c 1484 gdbarch_register_name (gdbarch, regno));
2a2d4dc3
AS
1485 else
1486 printf_filtered (_("a variable in register %s"),
768a979c 1487 gdbarch_register_name (gdbarch, regno));
c906108c
SS
1488 break;
1489
1490 case LOC_STATIC:
a3f17187 1491 printf_filtered (_("static storage at address "));
5af949e3 1492 load_addr = SYMBOL_VALUE_ADDRESS (sym);
35fb8261
TT
1493 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1494 gdb_stdout);
c906108c
SS
1495 if (section_is_overlay (section))
1496 {
1497 load_addr = overlay_unmapped_address (load_addr, section);
a3f17187 1498 printf_filtered (_(",\n -- loaded at "));
35fb8261
TT
1499 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1500 gdb_stdout);
714835d5
UW
1501 printf_filtered (_(" in overlay section %s"),
1502 section->the_bfd_section->name);
c906108c
SS
1503 }
1504 break;
1505
c906108c 1506 case LOC_REGPARM_ADDR:
768a979c
UW
1507 /* Note comment at LOC_REGISTER. */
1508 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
675dcf4f 1509 printf_filtered (_("address of an argument in register %s"),
768a979c 1510 gdbarch_register_name (gdbarch, regno));
c906108c
SS
1511 break;
1512
1513 case LOC_ARG:
a3f17187 1514 printf_filtered (_("an argument at offset %ld"), val);
c906108c
SS
1515 break;
1516
c906108c 1517 case LOC_LOCAL:
a3f17187 1518 printf_filtered (_("a local variable at frame offset %ld"), val);
c906108c
SS
1519 break;
1520
1521 case LOC_REF_ARG:
a3f17187 1522 printf_filtered (_("a reference argument at offset %ld"), val);
c906108c
SS
1523 break;
1524
c906108c 1525 case LOC_TYPEDEF:
a3f17187 1526 printf_filtered (_("a typedef"));
c906108c
SS
1527 break;
1528
1529 case LOC_BLOCK:
a3f17187 1530 printf_filtered (_("a function at address "));
2b1ffcfd 1531 load_addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
35fb8261
TT
1532 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1533 gdb_stdout);
c906108c
SS
1534 if (section_is_overlay (section))
1535 {
1536 load_addr = overlay_unmapped_address (load_addr, section);
a3f17187 1537 printf_filtered (_(",\n -- loaded at "));
35fb8261
TT
1538 fputs_styled (paddress (gdbarch, load_addr), address_style.style (),
1539 gdb_stdout);
714835d5
UW
1540 printf_filtered (_(" in overlay section %s"),
1541 section->the_bfd_section->name);
c906108c
SS
1542 }
1543 break;
1544
1545 case LOC_UNRESOLVED:
1546 {
e27d198c 1547 struct bound_minimal_symbol msym;
c906108c 1548
64cc34d8 1549 msym = lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym));
e27d198c 1550 if (msym.minsym == NULL)
c906108c
SS
1551 printf_filtered ("unresolved");
1552 else
1553 {
efd66ac6 1554 section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
e0740f77
JK
1555
1556 if (section
1557 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
5382cfab
PW
1558 {
1559 load_addr = MSYMBOL_VALUE_RAW_ADDRESS (msym.minsym);
1560 printf_filtered (_("a thread-local variable at offset %s "
1561 "in the thread-local storage for `%s'"),
1562 paddress (gdbarch, load_addr),
1563 objfile_name (section->objfile));
1564 }
e0740f77 1565 else
c906108c 1566 {
5382cfab 1567 load_addr = BMSYMBOL_VALUE_ADDRESS (msym);
e0740f77 1568 printf_filtered (_("static storage at address "));
35fb8261
TT
1569 fputs_styled (paddress (gdbarch, load_addr),
1570 address_style.style (), gdb_stdout);
e0740f77
JK
1571 if (section_is_overlay (section))
1572 {
1573 load_addr = overlay_unmapped_address (load_addr, section);
1574 printf_filtered (_(",\n -- loaded at "));
35fb8261
TT
1575 fputs_styled (paddress (gdbarch, load_addr),
1576 address_style.style (),
1577 gdb_stdout);
e0740f77
JK
1578 printf_filtered (_(" in overlay section %s"),
1579 section->the_bfd_section->name);
1580 }
c906108c
SS
1581 }
1582 }
1583 }
1584 break;
1585
c906108c 1586 case LOC_OPTIMIZED_OUT:
a3f17187 1587 printf_filtered (_("optimized out"));
c906108c 1588 break;
c5aa993b 1589
c906108c 1590 default:
a3f17187 1591 printf_filtered (_("of unknown (botched) type"));
c906108c
SS
1592 break;
1593 }
1594 printf_filtered (".\n");
1595}
1596\f
675dcf4f
MK
1597
1598static void
0b39b52e 1599x_command (const char *exp, int from_tty)
c906108c 1600{
c906108c 1601 struct format_data fmt;
c906108c
SS
1602 struct value *val;
1603
a6bac58e 1604 fmt.format = last_format ? last_format : 'x';
c906108c
SS
1605 fmt.size = last_size;
1606 fmt.count = 1;
a6bac58e 1607 fmt.raw = 0;
c906108c 1608
9be2ae8f
TT
1609 /* If there is no expression and no format, use the most recent
1610 count. */
1611 if (exp == nullptr && last_count > 0)
1612 fmt.count = last_count;
1613
c906108c
SS
1614 if (exp && *exp == '/')
1615 {
6f937416
PA
1616 const char *tmp = exp + 1;
1617
1618 fmt = decode_format (&tmp, last_format, last_size);
1619 exp = (char *) tmp;
c906108c
SS
1620 }
1621
9be2ae8f
TT
1622 last_count = fmt.count;
1623
c906108c
SS
1624 /* If we have an expression, evaluate it and use it as the address. */
1625
1626 if (exp != 0 && *exp != 0)
1627 {
4d01a485 1628 expression_up expr = parse_expression (exp);
675dcf4f
MK
1629 /* Cause expression not to be there any more if this command is
1630 repeated with Newline. But don't clobber a user-defined
1631 command's definition. */
c906108c 1632 if (from_tty)
85c4be7c 1633 set_repeat_arguments ("");
4d01a485 1634 val = evaluate_expression (expr.get ());
aa006118 1635 if (TYPE_IS_REFERENCE (value_type (val)))
e1c34c5d 1636 val = coerce_ref (val);
c906108c 1637 /* In rvalue contexts, such as this, functions are coerced into
c5aa993b 1638 pointers to functions. This makes "x/i main" work. */
c0d8fd9a 1639 if (/* last_format == 'i' && */
df407dfe 1640 TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
c5aa993b 1641 && VALUE_LVAL (val) == lval_memory)
42ae5230 1642 next_address = value_address (val);
c906108c 1643 else
1aa20aa8 1644 next_address = value_as_address (val);
5d3729b5
UW
1645
1646 next_gdbarch = expr->gdbarch;
c906108c
SS
1647 }
1648
5d3729b5
UW
1649 if (!next_gdbarch)
1650 error_no_arg (_("starting display address"));
1651
1652 do_examine (fmt, next_gdbarch, next_address);
c906108c 1653
675dcf4f 1654 /* If the examine succeeds, we remember its size and format for next
9a22f0d0
PM
1655 time. Set last_size to 'b' for strings. */
1656 if (fmt.format == 's')
1657 last_size = 'b';
1658 else
1659 last_size = fmt.size;
c906108c
SS
1660 last_format = fmt.format;
1661
0df8b418 1662 /* Set a couple of internal variables if appropriate. */
9b558729 1663 if (last_examine_value != nullptr)
c906108c
SS
1664 {
1665 /* Make last address examined available to the user as $_. Use
c5aa993b 1666 the correct pointer type. */
4478b372 1667 struct type *pointer_type
9b558729 1668 = lookup_pointer_type (value_type (last_examine_value.get ()));
c906108c 1669 set_internalvar (lookup_internalvar ("_"),
4478b372
JB
1670 value_from_pointer (pointer_type,
1671 last_examine_address));
c5aa993b 1672
675dcf4f
MK
1673 /* Make contents of last address examined available to the user
1674 as $__. If the last value has not been fetched from memory
1675 then don't fetch it now; instead mark it by voiding the $__
1676 variable. */
9b558729 1677 if (value_lazy (last_examine_value.get ()))
4fa62494 1678 clear_internalvar (lookup_internalvar ("__"));
c906108c 1679 else
9b558729 1680 set_internalvar (lookup_internalvar ("__"), last_examine_value.get ());
c906108c
SS
1681 }
1682}
c906108c 1683\f
c5aa993b 1684
c906108c
SS
1685/* Add an expression to the auto-display chain.
1686 Specify the expression. */
1687
1688static void
0b39b52e 1689display_command (const char *arg, int from_tty)
c906108c
SS
1690{
1691 struct format_data fmt;
fe978cb0 1692 struct display *newobj;
6f937416 1693 const char *exp = arg;
c906108c 1694
7bd0be3a 1695 if (exp == 0)
c906108c 1696 {
7bd0be3a
AB
1697 do_displays ();
1698 return;
1699 }
c906108c 1700
7bd0be3a
AB
1701 if (*exp == '/')
1702 {
1703 exp++;
1704 fmt = decode_format (&exp, 0, 0);
1705 if (fmt.size && fmt.format == 0)
1706 fmt.format = 'x';
1707 if (fmt.format == 'i' || fmt.format == 's')
1708 fmt.size = 'b';
1709 }
1710 else
1711 {
1712 fmt.format = 0;
1713 fmt.size = 0;
1714 fmt.count = 0;
1715 fmt.raw = 0;
1716 }
c906108c 1717
4d01a485 1718 expression_up expr = parse_expression (exp);
c906108c 1719
4d01a485 1720 newobj = new display ();
c906108c 1721
7bd0be3a 1722 newobj->exp_string = xstrdup (exp);
b22e99fd 1723 newobj->exp = std::move (expr);
aee1fcdf 1724 newobj->block = innermost_block.block ();
7bd0be3a 1725 newobj->pspace = current_program_space;
7bd0be3a
AB
1726 newobj->number = ++display_number;
1727 newobj->format = fmt;
1728 newobj->enabled_p = 1;
62147a22
PA
1729 newobj->next = NULL;
1730
1731 if (display_chain == NULL)
1732 display_chain = newobj;
1733 else
1734 {
1735 struct display *last;
1736
1737 for (last = display_chain; last->next != NULL; last = last->next)
1738 ;
1739 last->next = newobj;
1740 }
c906108c 1741
7bd0be3a
AB
1742 if (from_tty)
1743 do_one_display (newobj);
c906108c 1744
7bd0be3a 1745 dont_repeat ();
c906108c
SS
1746}
1747
1748static void
fba45db2 1749free_display (struct display *d)
c906108c 1750{
fa8a61dc 1751 xfree (d->exp_string);
4d01a485 1752 delete d;
c906108c
SS
1753}
1754
675dcf4f
MK
1755/* Clear out the display_chain. Done when new symtabs are loaded,
1756 since this invalidates the types stored in many expressions. */
c906108c
SS
1757
1758void
fba45db2 1759clear_displays (void)
c906108c 1760{
52f0bd74 1761 struct display *d;
c906108c
SS
1762
1763 while ((d = display_chain) != NULL)
1764 {
c906108c 1765 display_chain = d->next;
fa8a61dc 1766 free_display (d);
c906108c
SS
1767 }
1768}
1769
3c3fe74c 1770/* Delete the auto-display DISPLAY. */
c906108c
SS
1771
1772static void
3c3fe74c 1773delete_display (struct display *display)
c906108c 1774{
3c3fe74c 1775 struct display *d;
c906108c 1776
3c3fe74c 1777 gdb_assert (display != NULL);
c906108c 1778
3c3fe74c
PA
1779 if (display_chain == display)
1780 display_chain = display->next;
1781
1782 ALL_DISPLAYS (d)
1783 if (d->next == display)
c906108c 1784 {
3c3fe74c
PA
1785 d->next = display->next;
1786 break;
c906108c 1787 }
3c3fe74c
PA
1788
1789 free_display (display);
c906108c
SS
1790}
1791
c9174737
PA
1792/* Call FUNCTION on each of the displays whose numbers are given in
1793 ARGS. DATA is passed unmodified to FUNCTION. */
c906108c
SS
1794
1795static void
77763700 1796map_display_numbers (const char *args,
c9174737
PA
1797 void (*function) (struct display *,
1798 void *),
1799 void *data)
c906108c 1800{
c9174737 1801 int num;
c906108c 1802
c9174737
PA
1803 if (args == NULL)
1804 error_no_arg (_("one or more display numbers"));
c906108c 1805
bfd28288 1806 number_or_range_parser parser (args);
c9174737 1807
bfd28288 1808 while (!parser.finished ())
c906108c 1809 {
bfd28288 1810 const char *p = parser.cur_tok ();
c906108c 1811
bfd28288 1812 num = parser.get_number ();
3c3fe74c
PA
1813 if (num == 0)
1814 warning (_("bad display number at or near '%s'"), p);
1815 else
1816 {
c9174737 1817 struct display *d, *tmp;
c906108c 1818
c9174737 1819 ALL_DISPLAYS_SAFE (d, tmp)
3c3fe74c
PA
1820 if (d->number == num)
1821 break;
1822 if (d == NULL)
1823 printf_unfiltered (_("No display number %d.\n"), num);
1824 else
c9174737 1825 function (d, data);
3c3fe74c 1826 }
c906108c 1827 }
c9174737
PA
1828}
1829
1830/* Callback for map_display_numbers, that deletes a display. */
1831
1832static void
1833do_delete_display (struct display *d, void *data)
1834{
1835 delete_display (d);
1836}
1837
1838/* "undisplay" command. */
1839
1840static void
77763700 1841undisplay_command (const char *args, int from_tty)
c9174737 1842{
c9174737
PA
1843 if (args == NULL)
1844 {
1845 if (query (_("Delete all auto-display expressions? ")))
1846 clear_displays ();
1847 dont_repeat ();
1848 return;
1849 }
1850
1851 map_display_numbers (args, do_delete_display, NULL);
c906108c
SS
1852 dont_repeat ();
1853}
1854
1855/* Display a single auto-display.
1856 Do nothing if the display cannot be printed in the current context,
0df8b418 1857 or if the display is disabled. */
c906108c
SS
1858
1859static void
fba45db2 1860do_one_display (struct display *d)
c906108c
SS
1861{
1862 int within_current_scope;
1863
b5de0fa7 1864 if (d->enabled_p == 0)
c906108c
SS
1865 return;
1866
704e9165
UW
1867 /* The expression carries the architecture that was used at parse time.
1868 This is a problem if the expression depends on architecture features
1869 (e.g. register numbers), and the current architecture is now different.
1870 For example, a display statement like "display/i $pc" is expected to
1871 display the PC register of the current architecture, not the arch at
1872 the time the display command was given. Therefore, we re-parse the
1873 expression if the current architecture has changed. */
1874 if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1875 {
4d01a485 1876 d->exp.reset ();
704e9165
UW
1877 d->block = NULL;
1878 }
1879
a3247a22
PP
1880 if (d->exp == NULL)
1881 {
ad3bbd48 1882
492d29ea 1883 TRY
a3247a22 1884 {
a3247a22 1885 d->exp = parse_expression (d->exp_string);
aee1fcdf 1886 d->block = innermost_block.block ();
a3247a22 1887 }
492d29ea 1888 CATCH (ex, RETURN_MASK_ALL)
a3247a22
PP
1889 {
1890 /* Can't re-parse the expression. Disable this display item. */
1891 d->enabled_p = 0;
1892 warning (_("Unable to display \"%s\": %s"),
1893 d->exp_string, ex.message);
1894 return;
1895 }
492d29ea 1896 END_CATCH
a3247a22
PP
1897 }
1898
c906108c 1899 if (d->block)
6c95b8df
PA
1900 {
1901 if (d->pspace == current_program_space)
1902 within_current_scope = contained_in (get_selected_block (0), d->block);
1903 else
1904 within_current_scope = 0;
1905 }
c906108c
SS
1906 else
1907 within_current_scope = 1;
1908 if (!within_current_scope)
1909 return;
1910
b7b633e9
TT
1911 scoped_restore save_display_number
1912 = make_scoped_restore (&current_display_number, d->number);
c906108c
SS
1913
1914 annotate_display_begin ();
1915 printf_filtered ("%d", d->number);
1916 annotate_display_number_end ();
1917 printf_filtered (": ");
1918 if (d->format.size)
1919 {
c906108c
SS
1920
1921 annotate_display_format ();
1922
1923 printf_filtered ("x/");
1924 if (d->format.count != 1)
1925 printf_filtered ("%d", d->format.count);
1926 printf_filtered ("%c", d->format.format);
1927 if (d->format.format != 'i' && d->format.format != 's')
1928 printf_filtered ("%c", d->format.size);
1929 printf_filtered (" ");
1930
1931 annotate_display_expression ();
1932
fa8a61dc 1933 puts_filtered (d->exp_string);
c906108c
SS
1934 annotate_display_expression_end ();
1935
6a2eb474 1936 if (d->format.count != 1 || d->format.format == 'i')
c906108c
SS
1937 printf_filtered ("\n");
1938 else
1939 printf_filtered (" ");
c5aa993b 1940
c906108c
SS
1941 annotate_display_value ();
1942
492d29ea 1943 TRY
9d8fa392
PA
1944 {
1945 struct value *val;
1946 CORE_ADDR addr;
1947
4d01a485 1948 val = evaluate_expression (d->exp.get ());
9d8fa392
PA
1949 addr = value_as_address (val);
1950 if (d->format.format == 'i')
1951 addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1952 do_examine (d->format, d->exp->gdbarch, addr);
1953 }
492d29ea
PA
1954 CATCH (ex, RETURN_MASK_ERROR)
1955 {
1956 fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
1957 }
1958 END_CATCH
c906108c
SS
1959 }
1960 else
1961 {
79a45b7d
TT
1962 struct value_print_options opts;
1963
c906108c
SS
1964 annotate_display_format ();
1965
1966 if (d->format.format)
1967 printf_filtered ("/%c ", d->format.format);
1968
1969 annotate_display_expression ();
1970
fa8a61dc 1971 puts_filtered (d->exp_string);
c906108c
SS
1972 annotate_display_expression_end ();
1973
1974 printf_filtered (" = ");
1975
1976 annotate_display_expression ();
1977
79a45b7d 1978 get_formatted_print_options (&opts, d->format.format);
a6bac58e 1979 opts.raw = d->format.raw;
9d8fa392 1980
492d29ea 1981 TRY
9d8fa392
PA
1982 {
1983 struct value *val;
1984
4d01a485 1985 val = evaluate_expression (d->exp.get ());
9d8fa392
PA
1986 print_formatted (val, d->format.size, &opts, gdb_stdout);
1987 }
492d29ea
PA
1988 CATCH (ex, RETURN_MASK_ERROR)
1989 {
1990 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1991 }
1992 END_CATCH
1993
c906108c
SS
1994 printf_filtered ("\n");
1995 }
1996
1997 annotate_display_end ();
1998
1999 gdb_flush (gdb_stdout);
c906108c
SS
2000}
2001
2002/* Display all of the values on the auto-display chain which can be
2003 evaluated in the current scope. */
2004
2005void
fba45db2 2006do_displays (void)
c906108c 2007{
52f0bd74 2008 struct display *d;
c906108c
SS
2009
2010 for (d = display_chain; d; d = d->next)
2011 do_one_display (d);
2012}
2013
2014/* Delete the auto-display which we were in the process of displaying.
2015 This is done when there is an error or a signal. */
2016
2017void
fba45db2 2018disable_display (int num)
c906108c 2019{
52f0bd74 2020 struct display *d;
c906108c
SS
2021
2022 for (d = display_chain; d; d = d->next)
2023 if (d->number == num)
2024 {
b5de0fa7 2025 d->enabled_p = 0;
c906108c
SS
2026 return;
2027 }
a3f17187 2028 printf_unfiltered (_("No display number %d.\n"), num);
c906108c 2029}
c5aa993b 2030
c906108c 2031void
fba45db2 2032disable_current_display (void)
c906108c
SS
2033{
2034 if (current_display_number >= 0)
2035 {
2036 disable_display (current_display_number);
3e43a32a
MS
2037 fprintf_unfiltered (gdb_stderr,
2038 _("Disabling display %d to "
2039 "avoid infinite recursion.\n"),
c5aa993b 2040 current_display_number);
c906108c
SS
2041 }
2042 current_display_number = -1;
2043}
2044
2045static void
1d12d88f 2046info_display_command (const char *ignore, int from_tty)
c906108c 2047{
52f0bd74 2048 struct display *d;
c906108c
SS
2049
2050 if (!display_chain)
a3f17187 2051 printf_unfiltered (_("There are no auto-display expressions now.\n"));
c906108c 2052 else
a3f17187
AC
2053 printf_filtered (_("Auto-display expressions now in effect:\n\
2054Num Enb Expression\n"));
c906108c
SS
2055
2056 for (d = display_chain; d; d = d->next)
2057 {
b5de0fa7 2058 printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
c906108c
SS
2059 if (d->format.size)
2060 printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
c5aa993b 2061 d->format.format);
c906108c
SS
2062 else if (d->format.format)
2063 printf_filtered ("/%c ", d->format.format);
fa8a61dc 2064 puts_filtered (d->exp_string);
ae767bfb 2065 if (d->block && !contained_in (get_selected_block (0), d->block))
a3f17187 2066 printf_filtered (_(" (cannot be evaluated in the current context)"));
c906108c 2067 printf_filtered ("\n");
c906108c
SS
2068 }
2069}
2070
c9174737
PA
2071/* Callback fo map_display_numbers, that enables or disables the
2072 passed in display D. */
2073
c906108c 2074static void
c9174737 2075do_enable_disable_display (struct display *d, void *data)
c906108c 2076{
c9174737
PA
2077 d->enabled_p = *(int *) data;
2078}
c906108c 2079
c9174737
PA
2080/* Implamentation of both the "disable display" and "enable display"
2081 commands. ENABLE decides what to do. */
2082
2083static void
77763700 2084enable_disable_display_command (const char *args, int from_tty, int enable)
c9174737
PA
2085{
2086 if (args == NULL)
c906108c 2087 {
c9174737 2088 struct display *d;
c5aa993b 2089
c9174737
PA
2090 ALL_DISPLAYS (d)
2091 d->enabled_p = enable;
2092 return;
2093 }
c5aa993b 2094
c9174737 2095 map_display_numbers (args, do_enable_disable_display, &enable);
c906108c
SS
2096}
2097
c9174737
PA
2098/* The "enable display" command. */
2099
c906108c 2100static void
77763700 2101enable_display_command (const char *args, int from_tty)
c906108c 2102{
c9174737
PA
2103 enable_disable_display_command (args, from_tty, 1);
2104}
c5aa993b 2105
c9174737 2106/* The "disable display" command. */
c906108c 2107
c9174737 2108static void
77763700 2109disable_display_command (const char *args, int from_tty)
c9174737
PA
2110{
2111 enable_disable_display_command (args, from_tty, 0);
c906108c 2112}
a3247a22 2113
a3247a22
PP
2114/* display_chain items point to blocks and expressions. Some expressions in
2115 turn may point to symbols.
2116 Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
2117 obstack_free'd when a shared library is unloaded.
2118 Clear pointers that are about to become dangling.
2119 Both .exp and .block fields will be restored next time we need to display
2120 an item by re-parsing .exp_string field in the new execution context. */
2121
2122static void
63644780 2123clear_dangling_display_expressions (struct objfile *objfile)
a3247a22
PP
2124{
2125 struct display *d;
63644780 2126 struct program_space *pspace;
a3247a22 2127
c0201579
JK
2128 /* With no symbol file we cannot have a block or expression from it. */
2129 if (objfile == NULL)
2130 return;
63644780 2131 pspace = objfile->pspace;
c0201579 2132 if (objfile->separate_debug_objfile_backlink)
63644780
NB
2133 {
2134 objfile = objfile->separate_debug_objfile_backlink;
2135 gdb_assert (objfile->pspace == pspace);
2136 }
c0201579
JK
2137
2138 for (d = display_chain; d != NULL; d = d->next)
a3247a22 2139 {
63644780 2140 if (d->pspace != pspace)
c0201579
JK
2141 continue;
2142
2143 if (lookup_objfile_from_block (d->block) == objfile
4d01a485 2144 || (d->exp != NULL && exp_uses_objfile (d->exp.get (), objfile)))
c0201579 2145 {
4d01a485 2146 d->exp.reset ();
c0201579
JK
2147 d->block = NULL;
2148 }
a3247a22
PP
2149 }
2150}
c906108c 2151\f
c5aa993b 2152
675dcf4f 2153/* Print the value in stack frame FRAME of a variable specified by a
aad95b57
TT
2154 struct symbol. NAME is the name to print; if NULL then VAR's print
2155 name will be used. STREAM is the ui_file on which to print the
2156 value. INDENT specifies the number of indent levels to print
8f043999
JK
2157 before printing the variable name.
2158
2159 This function invalidates FRAME. */
c906108c
SS
2160
2161void
aad95b57
TT
2162print_variable_and_value (const char *name, struct symbol *var,
2163 struct frame_info *frame,
2164 struct ui_file *stream, int indent)
c906108c 2165{
c906108c 2166
aad95b57
TT
2167 if (!name)
2168 name = SYMBOL_PRINT_NAME (var);
2169
80ae2043
TT
2170 fputs_filtered (n_spaces (2 * indent), stream);
2171 fputs_styled (name, variable_name_style.style (), stream);
2172 fputs_filtered (" = ", stream);
2173
492d29ea 2174 TRY
0f6a939d
PM
2175 {
2176 struct value *val;
2177 struct value_print_options opts;
aad95b57 2178
63e43d3a
PMR
2179 /* READ_VAR_VALUE needs a block in order to deal with non-local
2180 references (i.e. to handle nested functions). In this context, we
2181 print variables that are local to this frame, so we can avoid passing
2182 a block to it. */
2183 val = read_var_value (var, NULL, frame);
0f6a939d 2184 get_user_print_options (&opts);
3343315b 2185 opts.deref_ref = 1;
0f6a939d 2186 common_val_print (val, stream, indent, &opts, current_language);
8f043999
JK
2187
2188 /* common_val_print invalidates FRAME when a pretty printer calls inferior
2189 function. */
2190 frame = NULL;
0f6a939d 2191 }
492d29ea
PA
2192 CATCH (except, RETURN_MASK_ERROR)
2193 {
2194 fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
2195 except.message);
2196 }
2197 END_CATCH
2198
aad95b57 2199 fprintf_filtered (stream, "\n");
c906108c
SS
2200}
2201
c2792f5a
DE
2202/* Subroutine of ui_printf to simplify it.
2203 Print VALUE to STREAM using FORMAT.
e12f57ab 2204 VALUE is a C-style string on the target. */
c2792f5a
DE
2205
2206static void
2207printf_c_string (struct ui_file *stream, const char *format,
2208 struct value *value)
2209{
2210 gdb_byte *str;
2211 CORE_ADDR tem;
2212 int j;
2213
2214 tem = value_as_address (value);
3ae9ce5d
TT
2215 if (tem == 0)
2216 {
af39b1c2
SM
2217 DIAGNOSTIC_PUSH
2218 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
3ae9ce5d 2219 fprintf_filtered (stream, format, "(null)");
af39b1c2 2220 DIAGNOSTIC_POP
3ae9ce5d
TT
2221 return;
2222 }
c2792f5a
DE
2223
2224 /* This is a %s argument. Find the length of the string. */
2225 for (j = 0;; j++)
2226 {
2227 gdb_byte c;
2228
2229 QUIT;
2230 read_memory (tem + j, &c, 1);
2231 if (c == 0)
2232 break;
2233 }
2234
2235 /* Copy the string contents into a string inside GDB. */
2236 str = (gdb_byte *) alloca (j + 1);
2237 if (j != 0)
2238 read_memory (tem, str, j);
2239 str[j] = 0;
2240
af39b1c2
SM
2241 DIAGNOSTIC_PUSH
2242 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
c2792f5a 2243 fprintf_filtered (stream, format, (char *) str);
af39b1c2 2244 DIAGNOSTIC_POP
c2792f5a
DE
2245}
2246
2247/* Subroutine of ui_printf to simplify it.
2248 Print VALUE to STREAM using FORMAT.
e12f57ab 2249 VALUE is a wide C-style string on the target. */
c2792f5a
DE
2250
2251static void
2252printf_wide_c_string (struct ui_file *stream, const char *format,
2253 struct value *value)
2254{
2255 gdb_byte *str;
2256 CORE_ADDR tem;
2257 int j;
2258 struct gdbarch *gdbarch = get_type_arch (value_type (value));
2259 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2260 struct type *wctype = lookup_typename (current_language, gdbarch,
2261 "wchar_t", NULL, 0);
2262 int wcwidth = TYPE_LENGTH (wctype);
224c3ddb 2263 gdb_byte *buf = (gdb_byte *) alloca (wcwidth);
c2792f5a
DE
2264
2265 tem = value_as_address (value);
3ae9ce5d
TT
2266 if (tem == 0)
2267 {
af39b1c2
SM
2268 DIAGNOSTIC_PUSH
2269 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
3ae9ce5d 2270 fprintf_filtered (stream, format, "(null)");
af39b1c2 2271 DIAGNOSTIC_POP
3ae9ce5d
TT
2272 return;
2273 }
c2792f5a
DE
2274
2275 /* This is a %s argument. Find the length of the string. */
2276 for (j = 0;; j += wcwidth)
2277 {
2278 QUIT;
2279 read_memory (tem + j, buf, wcwidth);
2280 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2281 break;
2282 }
2283
2284 /* Copy the string contents into a string inside GDB. */
2285 str = (gdb_byte *) alloca (j + wcwidth);
2286 if (j != 0)
2287 read_memory (tem, str, j);
2288 memset (&str[j], 0, wcwidth);
2289
8268c778 2290 auto_obstack output;
c2792f5a
DE
2291
2292 convert_between_encodings (target_wide_charset (gdbarch),
2293 host_charset (),
2294 str, j, wcwidth,
2295 &output, translit_char);
2296 obstack_grow_str0 (&output, "");
2297
af39b1c2
SM
2298 DIAGNOSTIC_PUSH
2299 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
c2792f5a 2300 fprintf_filtered (stream, format, obstack_base (&output));
af39b1c2 2301 DIAGNOSTIC_POP
c2792f5a
DE
2302}
2303
2304/* Subroutine of ui_printf to simplify it.
16e812b2 2305 Print VALUE, a floating point value, to STREAM using FORMAT. */
c2792f5a
DE
2306
2307static void
16e812b2
UW
2308printf_floating (struct ui_file *stream, const char *format,
2309 struct value *value, enum argclass argclass)
c2792f5a 2310{
c2792f5a
DE
2311 /* Parameter data. */
2312 struct type *param_type = value_type (value);
2313 struct gdbarch *gdbarch = get_type_arch (param_type);
c2792f5a 2314
16e812b2
UW
2315 /* Determine target type corresponding to the format string. */
2316 struct type *fmt_type;
2317 switch (argclass)
c2792f5a 2318 {
16e812b2
UW
2319 case double_arg:
2320 fmt_type = builtin_type (gdbarch)->builtin_double;
2321 break;
2322 case long_double_arg:
2323 fmt_type = builtin_type (gdbarch)->builtin_long_double;
2324 break;
2325 case dec32float_arg:
2326 fmt_type = builtin_type (gdbarch)->builtin_decfloat;
2327 break;
2328 case dec64float_arg:
2329 fmt_type = builtin_type (gdbarch)->builtin_decdouble;
2330 break;
2331 case dec128float_arg:
2332 fmt_type = builtin_type (gdbarch)->builtin_declong;
2333 break;
2334 default:
2335 gdb_assert_not_reached ("unexpected argument class");
c2792f5a
DE
2336 }
2337
16e812b2
UW
2338 /* To match the traditional GDB behavior, the conversion is
2339 done differently depending on the type of the parameter:
2340
2341 - if the parameter has floating-point type, it's value
2342 is converted to the target type;
2343
2344 - otherwise, if the parameter has a type that is of the
2345 same size as a built-in floating-point type, the value
2346 bytes are interpreted as if they were of that type, and
2347 then converted to the target type (this is not done for
2348 decimal floating-point argument classes);
2349
2350 - otherwise, if the source value has an integer value,
2351 it's value is converted to the target type;
c2792f5a 2352
16e812b2 2353 - otherwise, an error is raised.
c2792f5a 2354
16e812b2
UW
2355 In either case, the result of the conversion is a byte buffer
2356 formatted in the target format for the target type. */
2357
2358 if (TYPE_CODE (fmt_type) == TYPE_CODE_FLT)
2359 {
2360 param_type = float_type_from_length (param_type);
2361 if (param_type != value_type (value))
2362 value = value_from_contents (param_type, value_contents (value));
2363 }
2364
2365 value = value_cast (fmt_type, value);
c2792f5a 2366
3b4b2f16 2367 /* Convert the value to a string and print it. */
f69fdf9b
UW
2368 std::string str
2369 = target_float_to_string (value_contents (value), fmt_type, format);
3b4b2f16 2370 fputs_filtered (str.c_str (), stream);
c2792f5a
DE
2371}
2372
2373/* Subroutine of ui_printf to simplify it.
2374 Print VALUE, a target pointer, to STREAM using FORMAT. */
2375
2376static void
2377printf_pointer (struct ui_file *stream, const char *format,
2378 struct value *value)
2379{
2380 /* We avoid the host's %p because pointers are too
2381 likely to be the wrong size. The only interesting
2382 modifier for %p is a width; extract that, and then
2383 handle %p as glibc would: %#x or a literal "(nil)". */
2384
2385 const char *p;
2386 char *fmt, *fmt_p;
2387#ifdef PRINTF_HAS_LONG_LONG
2388 long long val = value_as_long (value);
2389#else
2390 long val = value_as_long (value);
2391#endif
2392
224c3ddb 2393 fmt = (char *) alloca (strlen (format) + 5);
c2792f5a
DE
2394
2395 /* Copy up to the leading %. */
2396 p = format;
2397 fmt_p = fmt;
2398 while (*p)
2399 {
2400 int is_percent = (*p == '%');
2401
2402 *fmt_p++ = *p++;
2403 if (is_percent)
2404 {
2405 if (*p == '%')
2406 *fmt_p++ = *p++;
2407 else
2408 break;
2409 }
2410 }
2411
2412 if (val != 0)
2413 *fmt_p++ = '#';
2414
b8c2339b
TT
2415 /* Copy any width or flags. Only the "-" flag is valid for pointers
2416 -- see the format_pieces constructor. */
2417 while (*p == '-' || (*p >= '0' && *p < '9'))
c2792f5a
DE
2418 *fmt_p++ = *p++;
2419
2420 gdb_assert (*p == 'p' && *(p + 1) == '\0');
2421 if (val != 0)
2422 {
2423#ifdef PRINTF_HAS_LONG_LONG
2424 *fmt_p++ = 'l';
2425#endif
2426 *fmt_p++ = 'l';
2427 *fmt_p++ = 'x';
2428 *fmt_p++ = '\0';
af39b1c2
SM
2429 DIAGNOSTIC_PUSH
2430 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
c2792f5a 2431 fprintf_filtered (stream, fmt, val);
af39b1c2 2432 DIAGNOSTIC_POP
c2792f5a
DE
2433 }
2434 else
2435 {
2436 *fmt_p++ = 's';
2437 *fmt_p++ = '\0';
af39b1c2
SM
2438 DIAGNOSTIC_PUSH
2439 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
c2792f5a 2440 fprintf_filtered (stream, fmt, "(nil)");
af39b1c2 2441 DIAGNOSTIC_POP
c2792f5a
DE
2442 }
2443}
2444
a04b0428
JB
2445/* printf "printf format string" ARG to STREAM. */
2446
2447static void
bbc13ae3 2448ui_printf (const char *arg, struct ui_file *stream)
c906108c 2449{
bbc13ae3 2450 const char *s = arg;
8e481c3b 2451 std::vector<struct value *> val_args;
c906108c
SS
2452
2453 if (s == 0)
e2e0b3e5 2454 error_no_arg (_("format-control string and values to print"));
c906108c 2455
f1735a53 2456 s = skip_spaces (s);
c906108c 2457
675dcf4f 2458 /* A format string should follow, enveloped in double quotes. */
c906108c 2459 if (*s++ != '"')
8a3fe4f8 2460 error (_("Bad format string, missing '\"'."));
c906108c 2461
8e481c3b 2462 format_pieces fpieces (&s);
c906108c 2463
d3ce09f5
SS
2464 if (*s++ != '"')
2465 error (_("Bad format string, non-terminated '\"'."));
2466
f1735a53 2467 s = skip_spaces (s);
c906108c
SS
2468
2469 if (*s != ',' && *s != 0)
8a3fe4f8 2470 error (_("Invalid argument syntax"));
c906108c 2471
c5aa993b
JM
2472 if (*s == ',')
2473 s++;
f1735a53 2474 s = skip_spaces (s);
c906108c 2475
c906108c 2476 {
c906108c 2477 int nargs_wanted;
8e481c3b
TT
2478 int i;
2479 const char *current_substring;
c906108c 2480
c906108c 2481 nargs_wanted = 0;
8e481c3b
TT
2482 for (auto &&piece : fpieces)
2483 if (piece.argclass != literal_piece)
d3ce09f5 2484 ++nargs_wanted;
c906108c
SS
2485
2486 /* Now, parse all arguments and evaluate them.
2487 Store the VALUEs in VAL_ARGS. */
2488
2489 while (*s != '\0')
2490 {
bbc13ae3 2491 const char *s1;
ad3bbd48 2492
a04b0428 2493 s1 = s;
8e481c3b 2494 val_args.push_back (parse_to_comma_and_eval (&s1));
c5aa993b 2495
c906108c
SS
2496 s = s1;
2497 if (*s == ',')
2498 s++;
2499 }
c5aa993b 2500
8e481c3b 2501 if (val_args.size () != nargs_wanted)
8a3fe4f8 2502 error (_("Wrong number of arguments for specified format-string"));
c906108c
SS
2503
2504 /* Now actually print them. */
d3ce09f5 2505 i = 0;
8e481c3b 2506 for (auto &&piece : fpieces)
c906108c 2507 {
8e481c3b
TT
2508 current_substring = piece.string;
2509 switch (piece.argclass)
c906108c
SS
2510 {
2511 case string_arg:
c2792f5a 2512 printf_c_string (stream, current_substring, val_args[i]);
c906108c 2513 break;
6c7a06a3 2514 case wide_string_arg:
c2792f5a 2515 printf_wide_c_string (stream, current_substring, val_args[i]);
6c7a06a3
TT
2516 break;
2517 case wide_char_arg:
2518 {
50810684
UW
2519 struct gdbarch *gdbarch
2520 = get_type_arch (value_type (val_args[i]));
2521 struct type *wctype = lookup_typename (current_language, gdbarch,
e6c014f2 2522 "wchar_t", NULL, 0);
6c7a06a3 2523 struct type *valtype;
6c7a06a3
TT
2524 const gdb_byte *bytes;
2525
2526 valtype = value_type (val_args[i]);
2527 if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2528 || TYPE_CODE (valtype) != TYPE_CODE_INT)
2529 error (_("expected wchar_t argument for %%lc"));
2530
2531 bytes = value_contents (val_args[i]);
2532
8268c778 2533 auto_obstack output;
6c7a06a3 2534
f870a310 2535 convert_between_encodings (target_wide_charset (gdbarch),
6c7a06a3
TT
2536 host_charset (),
2537 bytes, TYPE_LENGTH (valtype),
2538 TYPE_LENGTH (valtype),
2539 &output, translit_char);
2540 obstack_grow_str0 (&output, "");
2541
af39b1c2
SM
2542 DIAGNOSTIC_PUSH
2543 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
f1421989
HZ
2544 fprintf_filtered (stream, current_substring,
2545 obstack_base (&output));
af39b1c2 2546 DIAGNOSTIC_POP
6c7a06a3
TT
2547 }
2548 break;
c906108c 2549 case long_long_arg:
74a0d9f6 2550#ifdef PRINTF_HAS_LONG_LONG
c906108c
SS
2551 {
2552 long long val = value_as_long (val_args[i]);
ad3bbd48 2553
af39b1c2
SM
2554 DIAGNOSTIC_PUSH
2555 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
f1421989 2556 fprintf_filtered (stream, current_substring, val);
af39b1c2 2557 DIAGNOSTIC_POP
c906108c
SS
2558 break;
2559 }
2560#else
8a3fe4f8 2561 error (_("long long not supported in printf"));
c906108c
SS
2562#endif
2563 case int_arg:
2564 {
46e9880c 2565 int val = value_as_long (val_args[i]);
ad3bbd48 2566
af39b1c2
SM
2567 DIAGNOSTIC_PUSH
2568 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
f1421989 2569 fprintf_filtered (stream, current_substring, val);
af39b1c2 2570 DIAGNOSTIC_POP
46e9880c
DJ
2571 break;
2572 }
2573 case long_arg:
2574 {
c906108c 2575 long val = value_as_long (val_args[i]);
ad3bbd48 2576
af39b1c2
SM
2577 DIAGNOSTIC_PUSH
2578 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
f1421989 2579 fprintf_filtered (stream, current_substring, val);
af39b1c2 2580 DIAGNOSTIC_POP
c906108c
SS
2581 break;
2582 }
16e812b2
UW
2583 /* Handles floating-point values. */
2584 case double_arg:
2585 case long_double_arg:
2586 case dec32float_arg:
2587 case dec64float_arg:
2588 case dec128float_arg:
2589 printf_floating (stream, current_substring, val_args[i],
8e481c3b 2590 piece.argclass);
c2792f5a 2591 break;
2025a643 2592 case ptr_arg:
c2792f5a
DE
2593 printf_pointer (stream, current_substring, val_args[i]);
2594 break;
d3ce09f5
SS
2595 case literal_piece:
2596 /* Print a portion of the format string that has no
2597 directives. Note that this will not include any
2598 ordinary %-specs, but it might include "%%". That is
2599 why we use printf_filtered and not puts_filtered here.
2600 Also, we pass a dummy argument because some platforms
2601 have modified GCC to include -Wformat-security by
2602 default, which will warn here if there is no
2603 argument. */
af39b1c2
SM
2604 DIAGNOSTIC_PUSH
2605 DIAGNOSTIC_IGNORE_FORMAT_NONLITERAL
d3ce09f5 2606 fprintf_filtered (stream, current_substring, 0);
af39b1c2 2607 DIAGNOSTIC_POP
d3ce09f5 2608 break;
675dcf4f
MK
2609 default:
2610 internal_error (__FILE__, __LINE__,
2025a643 2611 _("failed internal consistency check"));
c906108c 2612 }
d3ce09f5 2613 /* Maybe advance to the next argument. */
8e481c3b 2614 if (piece.argclass != literal_piece)
d3ce09f5 2615 ++i;
c906108c 2616 }
c906108c 2617 }
c906108c 2618}
c906108c 2619
f1421989
HZ
2620/* Implement the "printf" command. */
2621
a04b0428 2622static void
0b39b52e 2623printf_command (const char *arg, int from_tty)
f1421989 2624{
a04b0428 2625 ui_printf (arg, gdb_stdout);
ef1dfa36
TT
2626 reset_terminal_style (gdb_stdout);
2627 wrap_here ("");
50b34a18 2628 gdb_flush (gdb_stdout);
f1421989
HZ
2629}
2630
2631/* Implement the "eval" command. */
2632
2633static void
0b39b52e 2634eval_command (const char *arg, int from_tty)
f1421989 2635{
d7e74731 2636 string_file stb;
f1421989 2637
d7e74731 2638 ui_printf (arg, &stb);
f1421989 2639
d7e74731 2640 std::string expanded = insert_user_defined_cmd_args (stb.c_str ());
01770bbd 2641
95a6b0a1 2642 execute_command (expanded.c_str (), from_tty);
f1421989
HZ
2643}
2644
c906108c 2645void
fba45db2 2646_initialize_printcmd (void)
c906108c 2647{
c94fdfd0
EZ
2648 struct cmd_list_element *c;
2649
c906108c
SS
2650 current_display_number = -1;
2651
76727919 2652 gdb::observers::free_objfile.attach (clear_dangling_display_expressions);
a3247a22 2653
11db9430 2654 add_info ("address", info_address_command,
1bedd215 2655 _("Describe where symbol SYM is stored."));
c906108c 2656
11db9430 2657 add_info ("symbol", info_symbol_command, _("\
1bedd215
AC
2658Describe what symbol is at location ADDR.\n\
2659Only for symbols with fixed locations (global or static scope)."));
c906108c 2660
1bedd215
AC
2661 add_com ("x", class_vars, x_command, _("\
2662Examine memory: x/FMT ADDRESS.\n\
c906108c
SS
2663ADDRESS is an expression for the memory address to examine.\n\
2664FMT is a repeat count followed by a format letter and a size letter.\n\
2665Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
6fbe845e
AB
2666 t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2667 and z(hex, zero padded on the left).\n\
1bedd215 2668Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
c906108c 2669The specified number of objects of the specified size are printed\n\
bb556f1f
TK
2670according to the format. If a negative number is specified, memory is\n\
2671examined backward from the address.\n\n\
c906108c
SS
2672Defaults for format and size letters are those previously used.\n\
2673Default count is 1. Default address is following last thing printed\n\
1bedd215 2674with this command or \"print\"."));
c906108c 2675
c906108c
SS
2676#if 0
2677 add_com ("whereis", class_vars, whereis_command,
1bedd215 2678 _("Print line number and file of definition of variable."));
c906108c 2679#endif
c5aa993b 2680
11db9430 2681 add_info ("display", info_display_command, _("\
1bedd215 2682Expressions to display when program stops, with code numbers."));
c906108c 2683
1a966eab
AC
2684 add_cmd ("undisplay", class_vars, undisplay_command, _("\
2685Cancel some expressions to be displayed when program stops.\n\
c906108c
SS
2686Arguments are the code numbers of the expressions to stop displaying.\n\
2687No argument means cancel all automatic-display expressions.\n\
2688\"delete display\" has the same effect as this command.\n\
1a966eab 2689Do \"info display\" to see current list of code numbers."),
c5aa993b 2690 &cmdlist);
c906108c 2691
1bedd215
AC
2692 add_com ("display", class_vars, display_command, _("\
2693Print value of expression EXP each time the program stops.\n\
c906108c
SS
2694/FMT may be used before EXP as in the \"print\" command.\n\
2695/FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2696as in the \"x\" command, and then EXP is used to get the address to examine\n\
2697and examining is done as in the \"x\" command.\n\n\
2698With no argument, display all currently requested auto-display expressions.\n\
1bedd215 2699Use \"undisplay\" to cancel display requests previously made."));
c906108c 2700
c9174737 2701 add_cmd ("display", class_vars, enable_display_command, _("\
1a966eab 2702Enable some expressions to be displayed when program stops.\n\
c906108c
SS
2703Arguments are the code numbers of the expressions to resume displaying.\n\
2704No argument means enable all automatic-display expressions.\n\
1a966eab 2705Do \"info display\" to see current list of code numbers."), &enablelist);
c906108c 2706
1a966eab
AC
2707 add_cmd ("display", class_vars, disable_display_command, _("\
2708Disable some expressions to be displayed when program stops.\n\
c906108c
SS
2709Arguments are the code numbers of the expressions to stop displaying.\n\
2710No argument means disable all automatic-display expressions.\n\
1a966eab 2711Do \"info display\" to see current list of code numbers."), &disablelist);
c906108c 2712
1a966eab
AC
2713 add_cmd ("display", class_vars, undisplay_command, _("\
2714Cancel some expressions to be displayed when program stops.\n\
c906108c
SS
2715Arguments are the code numbers of the expressions to stop displaying.\n\
2716No argument means cancel all automatic-display expressions.\n\
1a966eab 2717Do \"info display\" to see current list of code numbers."), &deletelist);
c906108c 2718
1bedd215 2719 add_com ("printf", class_vars, printf_command, _("\
80ae639d
TT
2720Formatted printing, like the C \"printf\" function.\n\
2721Usage: printf \"format string\", arg1, arg2, arg3, ..., argn\n\
2722This supports most C printf format specifications, like %s, %d, etc."));
c906108c 2723
1bedd215
AC
2724 add_com ("output", class_vars, output_command, _("\
2725Like \"print\" but don't put in value history and don't print newline.\n\
2726This is useful in user-defined commands."));
c906108c 2727
1bedd215
AC
2728 add_prefix_cmd ("set", class_vars, set_command, _("\
2729Evaluate expression EXP and assign result to variable VAR, using assignment\n\
c906108c
SS
2730syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2731example). VAR may be a debugger \"convenience\" variable (names starting\n\
2732with $), a register (a few standard names starting with $), or an actual\n\
1bedd215
AC
2733variable in the program being debugged. EXP is any valid expression.\n\
2734Use \"set variable\" for variables with names identical to set subcommands.\n\
2735\n\
2736With a subcommand, this command modifies parts of the gdb environment.\n\
2737You can see these environment settings with the \"show\" command."),
c5aa993b 2738 &setlist, "set ", 1, &cmdlist);
c906108c 2739 if (dbx_commands)
0b39b52e 2740 add_com ("assign", class_vars, set_command, _("\
1bedd215 2741Evaluate expression EXP and assign result to variable VAR, using assignment\n\
c906108c
SS
2742syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2743example). VAR may be a debugger \"convenience\" variable (names starting\n\
2744with $), a register (a few standard names starting with $), or an actual\n\
1bedd215
AC
2745variable in the program being debugged. EXP is any valid expression.\n\
2746Use \"set variable\" for variables with names identical to set subcommands.\n\
c906108c 2747\nWith a subcommand, this command modifies parts of the gdb environment.\n\
1bedd215 2748You can see these environment settings with the \"show\" command."));
c906108c 2749
0df8b418 2750 /* "call" is the same as "set", but handy for dbx users to call fns. */
1bedd215
AC
2751 c = add_com ("call", class_vars, call_command, _("\
2752Call a function in the program.\n\
c906108c
SS
2753The argument is the function name and arguments, in the notation of the\n\
2754current working language. The result is printed and saved in the value\n\
1bedd215 2755history, if it is not void."));
65d12d83 2756 set_cmd_completer (c, expression_completer);
c906108c 2757
1a966eab
AC
2758 add_cmd ("variable", class_vars, set_command, _("\
2759Evaluate expression EXP and assign result to variable VAR, using assignment\n\
c906108c
SS
2760syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2761example). VAR may be a debugger \"convenience\" variable (names starting\n\
2762with $), a register (a few standard names starting with $), or an actual\n\
2763variable in the program being debugged. EXP is any valid expression.\n\
1a966eab 2764This may usually be abbreviated to simply \"set\"."),
c5aa993b 2765 &setlist);
3fcded8f 2766 add_alias_cmd ("var", "variable", class_vars, 0, &setlist);
c906108c 2767
1bedd215
AC
2768 c = add_com ("print", class_vars, print_command, _("\
2769Print value of expression EXP.\n\
c906108c
SS
2770Variables accessible are those of the lexical environment of the selected\n\
2771stack frame, plus all those whose scope is global or an entire file.\n\
2772\n\
2773$NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2774$$NUM refers to NUM'th value back from the last one.\n\
1bedd215
AC
2775Names starting with $ refer to registers (with the values they would have\n\
2776if the program were to return to the stack frame now selected, restoring\n\
c906108c
SS
2777all registers saved by frames farther in) or else to debugger\n\
2778\"convenience\" variables (any such name not a known register).\n\
1bedd215
AC
2779Use assignment expressions to give values to convenience variables.\n\
2780\n\
c906108c
SS
2781{TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2782@ is a binary operator for treating consecutive data objects\n\
2783anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2784element is FOO, whose second element is stored in the space following\n\
2785where FOO is stored, etc. FOO must be an expression whose value\n\
1bedd215
AC
2786resides in memory.\n\
2787\n\
c906108c 2788EXP may be preceded with /FMT, where FMT is a format letter\n\
1bedd215 2789but no count or size letter (see \"x\" command)."));
65d12d83 2790 set_cmd_completer (c, expression_completer);
c906108c 2791 add_com_alias ("p", "print", class_vars, 1);
e93a8774 2792 add_com_alias ("inspect", "print", class_vars, 1);
c906108c 2793
35096d9d
AC
2794 add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2795 &max_symbolic_offset, _("\
2796Set the largest offset that will be printed in <symbol+1234> form."), _("\
f81d1120
PA
2797Show the largest offset that will be printed in <symbol+1234> form."), _("\
2798Tell GDB to only display the symbolic form of an address if the\n\
2799offset between the closest earlier symbol and the address is less than\n\
2800the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2801to always print the symbolic form of an address if any symbol precedes\n\
2802it. Zero is equivalent to \"unlimited\"."),
35096d9d 2803 NULL,
920d2a44 2804 show_max_symbolic_offset,
35096d9d 2805 &setprintlist, &showprintlist);
5bf193a2
AC
2806 add_setshow_boolean_cmd ("symbol-filename", no_class,
2807 &print_symbol_filename, _("\
2808Set printing of source filename and line number with <symbol>."), _("\
2809Show printing of source filename and line number with <symbol>."), NULL,
2810 NULL,
920d2a44 2811 show_print_symbol_filename,
5bf193a2 2812 &setprintlist, &showprintlist);
f1421989
HZ
2813
2814 add_com ("eval", no_class, eval_command, _("\
2815Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2816a command line, and call it."));
c906108c 2817}
This page took 2.002716 seconds and 4 git commands to generate.