GDB (xrefs)
/tmp/gdb-7.10/gdb/printcmd.c
Go to the documentation of this file.
1 /* Print values for GNU debugger GDB.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
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.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
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"
32 #include "gdb-demangle.h"
33 #include "valprint.h"
34 #include "annotate.h"
35 #include "symfile.h" /* for overlay functions */
36 #include "objfiles.h" /* ditto */
37 #include "completer.h" /* for completion functions */
38 #include "ui-out.h"
39 #include "block.h"
40 #include "disasm.h"
41 #include "dfp.h"
42 #include "observer.h"
43 #include "solist.h"
44 #include "parser-defs.h"
45 #include "charset.h"
46 #include "arch-utils.h"
47 #include "cli/cli-utils.h"
48 #include "format.h"
49 #include "source.h"
50 
51 #ifdef TUI
52 #include "tui/tui.h" /* For tui_active et al. */
53 #endif
54 
55 /* Last specified output format. */
56 
57 static char last_format = 0;
58 
59 /* Last specified examination size. 'b', 'h', 'w' or `q'. */
60 
61 static char last_size = 'w';
62 
63 /* Default address to examine next, and associated architecture. */
64 
65 static struct gdbarch *next_gdbarch;
67 
68 /* Number of delay instructions following current disassembled insn. */
69 
70 static int branch_delay_insns;
71 
72 /* Last address examined. */
73 
75 
76 /* Contents of last address examined.
77  This is not valid past the end of the `x' command! */
78 
79 static struct value *last_examine_value;
80 
81 /* Largest offset between a symbolic value and an address, that will be
82  printed as `0x1234 <symbol+offset>'. */
83 
84 static unsigned int max_symbolic_offset = UINT_MAX;
85 static void
86 show_max_symbolic_offset (struct ui_file *file, int from_tty,
87  struct cmd_list_element *c, const char *value)
88 {
89  fprintf_filtered (file,
90  _("The largest offset that will be "
91  "printed in <symbol+1234> form is %s.\n"),
92  value);
93 }
94 
95 /* Append the source filename and linenumber of the symbol when
96  printing a symbolic value as `<symbol at filename:linenum>' if set. */
97 static int print_symbol_filename = 0;
98 static void
99 show_print_symbol_filename (struct ui_file *file, int from_tty,
100  struct cmd_list_element *c, const char *value)
101 {
102  fprintf_filtered (file, _("Printing of source filename and "
103  "line number with <symbol> is %s.\n"),
104  value);
105 }
106 
107 /* Number of auto-display expression currently being displayed.
108  So that we can disable it if we get a signal within it.
109  -1 when not doing one. */
110 
112 
113 struct display
114  {
115  /* Chain link to next auto-display item. */
116  struct display *next;
117 
118  /* The expression as the user typed it. */
119  char *exp_string;
120 
121  /* Expression to be evaluated and displayed. */
122  struct expression *exp;
123 
124  /* Item number of this auto-display item. */
125  int number;
126 
127  /* Display format specified. */
129 
130  /* Program space associated with `block'. */
132 
133  /* Innermost block required by this expression when evaluated. */
134  const struct block *block;
135 
136  /* Status of this display (enabled or disabled). */
138  };
139 
140 /* Chain of expressions whose values should be displayed
141  automatically each time the program stops. */
142 
143 static struct display *display_chain;
144 
145 static int display_number;
146 
147 /* Walk the following statement or block through all displays.
148  ALL_DISPLAYS_SAFE does so even if the statement deletes the current
149  display. */
150 
151 #define ALL_DISPLAYS(B) \
152  for (B = display_chain; B; B = B->next)
153 
154 #define ALL_DISPLAYS_SAFE(B,TMP) \
155  for (B = display_chain; \
156  B ? (TMP = B->next, 1): 0; \
157  B = TMP)
158 
159 /* Prototypes for exported functions. */
160 
161 void _initialize_printcmd (void);
162 
163 /* Prototypes for local functions. */
164 
165 static void do_one_display (struct display *);
166 
167 
168 /* Decode a format specification. *STRING_PTR should point to it.
169  OFORMAT and OSIZE are used as defaults for the format and size
170  if none are given in the format specification.
171  If OSIZE is zero, then the size field of the returned value
172  should be set only if a size is explicitly specified by the
173  user.
174  The structure returned describes all the data
175  found in the specification. In addition, *STRING_PTR is advanced
176  past the specification and past all whitespace following it. */
177 
178 static struct format_data
179 decode_format (const char **string_ptr, int oformat, int osize)
180 {
181  struct format_data val;
182  const char *p = *string_ptr;
183 
184  val.format = '?';
185  val.size = '?';
186  val.count = 1;
187  val.raw = 0;
188 
189  if (*p >= '0' && *p <= '9')
190  val.count = atoi (p);
191  while (*p >= '0' && *p <= '9')
192  p++;
193 
194  /* Now process size or format letters that follow. */
195 
196  while (1)
197  {
198  if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
199  val.size = *p++;
200  else if (*p == 'r')
201  {
202  val.raw = 1;
203  p++;
204  }
205  else if (*p >= 'a' && *p <= 'z')
206  val.format = *p++;
207  else
208  break;
209  }
210 
211  while (*p == ' ' || *p == '\t')
212  p++;
213  *string_ptr = p;
214 
215  /* Set defaults for format and size if not specified. */
216  if (val.format == '?')
217  {
218  if (val.size == '?')
219  {
220  /* Neither has been specified. */
221  val.format = oformat;
222  val.size = osize;
223  }
224  else
225  /* If a size is specified, any format makes a reasonable
226  default except 'i'. */
227  val.format = oformat == 'i' ? 'x' : oformat;
228  }
229  else if (val.size == '?')
230  switch (val.format)
231  {
232  case 'a':
233  /* Pick the appropriate size for an address. This is deferred
234  until do_examine when we know the actual architecture to use.
235  A special size value of 'a' is used to indicate this case. */
236  val.size = osize ? 'a' : osize;
237  break;
238  case 'f':
239  /* Floating point has to be word or giantword. */
240  if (osize == 'w' || osize == 'g')
241  val.size = osize;
242  else
243  /* Default it to giantword if the last used size is not
244  appropriate. */
245  val.size = osize ? 'g' : osize;
246  break;
247  case 'c':
248  /* Characters default to one byte. */
249  val.size = osize ? 'b' : osize;
250  break;
251  case 's':
252  /* Display strings with byte size chars unless explicitly
253  specified. */
254  val.size = '\0';
255  break;
256 
257  default:
258  /* The default is the size most recently specified. */
259  val.size = osize;
260  }
261 
262  return val;
263 }
264 
265 /* Print value VAL on stream according to OPTIONS.
266  Do not end with a newline.
267  SIZE is the letter for the size of datum being printed.
268  This is used to pad hex numbers so they line up. SIZE is 0
269  for print / output and set for examine. */
270 
271 static void
272 print_formatted (struct value *val, int size,
273  const struct value_print_options *options,
274  struct ui_file *stream)
275 {
276  struct type *type = check_typedef (value_type (val));
277  int len = TYPE_LENGTH (type);
278 
279  if (VALUE_LVAL (val) == lval_memory)
280  next_address = value_address (val) + len;
281 
282  if (size)
283  {
284  switch (options->format)
285  {
286  case 's':
287  {
288  struct type *elttype = value_type (val);
289 
290  next_address = (value_address (val)
291  + val_print_string (elttype, NULL,
292  value_address (val), -1,
293  stream, options) * len);
294  }
295  return;
296 
297  case 'i':
298  /* We often wrap here if there are long symbolic names. */
299  wrap_here (" ");
300  next_address = (value_address (val)
301  + gdb_print_insn (get_type_arch (type),
302  value_address (val), stream,
303  &branch_delay_insns));
304  return;
305  }
306  }
307 
308  if (options->format == 0 || options->format == 's'
309  || TYPE_CODE (type) == TYPE_CODE_REF
310  || TYPE_CODE (type) == TYPE_CODE_ARRAY
311  || TYPE_CODE (type) == TYPE_CODE_STRING
312  || TYPE_CODE (type) == TYPE_CODE_STRUCT
313  || TYPE_CODE (type) == TYPE_CODE_UNION
314  || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
315  value_print (val, stream, options);
316  else
317  /* User specified format, so don't look to the type to tell us
318  what to do. */
321  value_embedded_offset (val),
322  val,
323  options, size, stream);
324 }
325 
326 /* Return builtin floating point type of same length as TYPE.
327  If no such type is found, return TYPE itself. */
328 static struct type *
330 {
331  struct gdbarch *gdbarch = get_type_arch (type);
332  const struct builtin_type *builtin = builtin_type (gdbarch);
333 
334  if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_float))
335  type = builtin->builtin_float;
336  else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_double))
337  type = builtin->builtin_double;
338  else if (TYPE_LENGTH (type) == TYPE_LENGTH (builtin->builtin_long_double))
339  type = builtin->builtin_long_double;
340 
341  return type;
342 }
343 
344 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
345  according to OPTIONS and SIZE on STREAM. Formats s and i are not
346  supported at this level. */
347 
348 void
349 print_scalar_formatted (const void *valaddr, struct type *type,
350  const struct value_print_options *options,
351  int size, struct ui_file *stream)
352 {
353  struct gdbarch *gdbarch = get_type_arch (type);
354  LONGEST val_long = 0;
355  unsigned int len = TYPE_LENGTH (type);
356  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
357 
358  /* String printing should go through val_print_scalar_formatted. */
359  gdb_assert (options->format != 's');
360 
361  if (len > sizeof(LONGEST) &&
362  (TYPE_CODE (type) == TYPE_CODE_INT
363  || TYPE_CODE (type) == TYPE_CODE_ENUM))
364  {
365  switch (options->format)
366  {
367  case 'o':
368  print_octal_chars (stream, valaddr, len, byte_order);
369  return;
370  case 'u':
371  case 'd':
372  print_decimal_chars (stream, valaddr, len, byte_order);
373  return;
374  case 't':
375  print_binary_chars (stream, valaddr, len, byte_order);
376  return;
377  case 'x':
378  print_hex_chars (stream, valaddr, len, byte_order);
379  return;
380  case 'c':
381  print_char_chars (stream, type, valaddr, len, byte_order);
382  return;
383  default:
384  break;
385  };
386  }
387 
388  if (options->format != 'f')
389  val_long = unpack_long (type, valaddr);
390 
391  /* If the value is a pointer, and pointers and addresses are not the
392  same, then at this point, the value's length (in target bytes) is
393  gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
394  if (TYPE_CODE (type) == TYPE_CODE_PTR)
395  len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;
396 
397  /* If we are printing it as unsigned, truncate it in case it is actually
398  a negative signed value (e.g. "print/u (short)-1" should print 65535
399  (if shorts are 16 bits) instead of 4294967295). */
400  if (options->format != 'd' || TYPE_UNSIGNED (type))
401  {
402  if (len < sizeof (LONGEST))
403  val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
404  }
405 
406  switch (options->format)
407  {
408  case 'x':
409  if (!size)
410  {
411  /* No size specified, like in print. Print varying # of digits. */
412  print_longest (stream, 'x', 1, val_long);
413  }
414  else
415  switch (size)
416  {
417  case 'b':
418  case 'h':
419  case 'w':
420  case 'g':
421  print_longest (stream, size, 1, val_long);
422  break;
423  default:
424  error (_("Undefined output size \"%c\"."), size);
425  }
426  break;
427 
428  case 'd':
429  print_longest (stream, 'd', 1, val_long);
430  break;
431 
432  case 'u':
433  print_longest (stream, 'u', 0, val_long);
434  break;
435 
436  case 'o':
437  if (val_long)
438  print_longest (stream, 'o', 1, val_long);
439  else
440  fprintf_filtered (stream, "0");
441  break;
442 
443  case 'a':
444  {
445  CORE_ADDR addr = unpack_pointer (type, valaddr);
446 
447  print_address (gdbarch, addr, stream);
448  }
449  break;
450 
451  case 'c':
452  {
453  struct value_print_options opts = *options;
454 
455  opts.format = 0;
456  if (TYPE_UNSIGNED (type))
457  type = builtin_type (gdbarch)->builtin_true_unsigned_char;
458  else
459  type = builtin_type (gdbarch)->builtin_true_char;
460 
461  value_print (value_from_longest (type, val_long), stream, &opts);
462  }
463  break;
464 
465  case 'f':
466  type = float_type_from_length (type);
467  print_floating (valaddr, type, stream);
468  break;
469 
470  case 0:
471  internal_error (__FILE__, __LINE__,
472  _("failed internal consistency check"));
473 
474  case 't':
475  /* Binary; 't' stands for "two". */
476  {
477  char bits[8 * (sizeof val_long) + 1];
478  char buf[8 * (sizeof val_long) + 32];
479  char *cp = bits;
480  int width;
481 
482  if (!size)
483  width = 8 * (sizeof val_long);
484  else
485  switch (size)
486  {
487  case 'b':
488  width = 8;
489  break;
490  case 'h':
491  width = 16;
492  break;
493  case 'w':
494  width = 32;
495  break;
496  case 'g':
497  width = 64;
498  break;
499  default:
500  error (_("Undefined output size \"%c\"."), size);
501  }
502 
503  bits[width] = '\0';
504  while (width-- > 0)
505  {
506  bits[width] = (val_long & 1) ? '1' : '0';
507  val_long >>= 1;
508  }
509  if (!size)
510  {
511  while (*cp && *cp == '0')
512  cp++;
513  if (*cp == '\0')
514  cp--;
515  }
516  strncpy (buf, cp, sizeof (bits));
517  fputs_filtered (buf, stream);
518  }
519  break;
520 
521  case 'z':
522  print_hex_chars (stream, valaddr, len, byte_order);
523  break;
524 
525  default:
526  error (_("Undefined output format \"%c\"."), options->format);
527  }
528 }
529 
530 /* Specify default address for `x' command.
531  The `info lines' command uses this. */
532 
533 void
535 {
536  struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
537 
538  next_gdbarch = gdbarch;
539  next_address = addr;
540 
541  /* Make address available to the user as $_. */
543  value_from_pointer (ptr_type, addr));
544 }
545 
546 /* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
547  after LEADIN. Print nothing if no symbolic name is found nearby.
548  Optionally also print source file and line number, if available.
549  DO_DEMANGLE controls whether to print a symbol in its native "raw" form,
550  or to interpret it as a possible C++ name and convert it back to source
551  form. However note that DO_DEMANGLE can be overridden by the specific
552  settings of the demangle and asm_demangle variables. Returns
553  non-zero if anything was printed; zero otherwise. */
554 
555 int
557  struct ui_file *stream,
558  int do_demangle, char *leadin)
559 {
560  char *name = NULL;
561  char *filename = NULL;
562  int unmapped = 0;
563  int offset = 0;
564  int line = 0;
565 
566  /* Throw away both name and filename. */
568  make_cleanup (free_current_contents, &filename);
569 
570  if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
571  &filename, &line, &unmapped))
572  {
573  do_cleanups (cleanup_chain);
574  return 0;
575  }
576 
577  fputs_filtered (leadin, stream);
578  if (unmapped)
579  fputs_filtered ("<*", stream);
580  else
581  fputs_filtered ("<", stream);
582  fputs_filtered (name, stream);
583  if (offset != 0)
584  fprintf_filtered (stream, "+%u", (unsigned int) offset);
585 
586  /* Append source filename and line number if desired. Give specific
587  line # of this addr, if we have it; else line # of the nearest symbol. */
588  if (print_symbol_filename && filename != NULL)
589  {
590  if (line != -1)
591  fprintf_filtered (stream, " at %s:%d", filename, line);
592  else
593  fprintf_filtered (stream, " in %s", filename);
594  }
595  if (unmapped)
596  fputs_filtered ("*>", stream);
597  else
598  fputs_filtered (">", stream);
599 
600  do_cleanups (cleanup_chain);
601  return 1;
602 }
603 
604 /* Given an address ADDR return all the elements needed to print the
605  address in a symbolic form. NAME can be mangled or not depending
606  on DO_DEMANGLE (and also on the asm_demangle global variable,
607  manipulated via ''set print asm-demangle''). Return 0 in case of
608  success, when all the info in the OUT paramters is valid. Return 1
609  otherwise. */
610 int
612  CORE_ADDR addr, /* IN */
613  int do_demangle, /* IN */
614  char **name, /* OUT */
615  int *offset, /* OUT */
616  char **filename, /* OUT */
617  int *line, /* OUT */
618  int *unmapped) /* OUT */
619 {
620  struct bound_minimal_symbol msymbol;
621  struct symbol *symbol;
622  CORE_ADDR name_location = 0;
623  struct obj_section *section = NULL;
624  const char *name_temp = "";
625 
626  /* Let's say it is mapped (not unmapped). */
627  *unmapped = 0;
628 
629  /* Determine if the address is in an overlay, and whether it is
630  mapped. */
631  if (overlay_debugging)
632  {
633  section = find_pc_overlay (addr);
634  if (pc_in_unmapped_range (addr, section))
635  {
636  *unmapped = 1;
637  addr = overlay_mapped_address (addr, section);
638  }
639  }
640 
641  /* First try to find the address in the symbol table, then
642  in the minsyms. Take the closest one. */
643 
644  /* This is defective in the sense that it only finds text symbols. So
645  really this is kind of pointless--we should make sure that the
646  minimal symbols have everything we need (by changing that we could
647  save some memory, but for many debug format--ELF/DWARF or
648  anything/stabs--it would be inconvenient to eliminate those minimal
649  symbols anyway). */
650  msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
651  symbol = find_pc_sect_function (addr, section);
652 
653  if (symbol)
654  {
655  /* If this is a function (i.e. a code address), strip out any
656  non-address bits. For instance, display a pointer to the
657  first instruction of a Thumb function as <function>; the
658  second instruction will be <function+2>, even though the
659  pointer is <function+3>. This matches the ISA behavior. */
660  addr = gdbarch_addr_bits_remove (gdbarch, addr);
661 
662  name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
663  if (do_demangle || asm_demangle)
664  name_temp = SYMBOL_PRINT_NAME (symbol);
665  else
666  name_temp = SYMBOL_LINKAGE_NAME (symbol);
667  }
668 
669  if (msymbol.minsym != NULL
670  && MSYMBOL_HAS_SIZE (msymbol.minsym)
671  && MSYMBOL_SIZE (msymbol.minsym) == 0
672  && MSYMBOL_TYPE (msymbol.minsym) != mst_text
673  && MSYMBOL_TYPE (msymbol.minsym) != mst_text_gnu_ifunc
674  && MSYMBOL_TYPE (msymbol.minsym) != mst_file_text)
675  msymbol.minsym = NULL;
676 
677  if (msymbol.minsym != NULL)
678  {
679  if (BMSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
680  {
681  /* If this is a function (i.e. a code address), strip out any
682  non-address bits. For instance, display a pointer to the
683  first instruction of a Thumb function as <function>; the
684  second instruction will be <function+2>, even though the
685  pointer is <function+3>. This matches the ISA behavior. */
686  if (MSYMBOL_TYPE (msymbol.minsym) == mst_text
687  || MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc
688  || MSYMBOL_TYPE (msymbol.minsym) == mst_file_text
689  || MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
690  addr = gdbarch_addr_bits_remove (gdbarch, addr);
691 
692  /* The msymbol is closer to the address than the symbol;
693  use the msymbol instead. */
694  symbol = 0;
695  name_location = BMSYMBOL_VALUE_ADDRESS (msymbol);
696  if (do_demangle || asm_demangle)
697  name_temp = MSYMBOL_PRINT_NAME (msymbol.minsym);
698  else
699  name_temp = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
700  }
701  }
702  if (symbol == NULL && msymbol.minsym == NULL)
703  return 1;
704 
705  /* If the nearest symbol is too far away, don't print anything symbolic. */
706 
707  /* For when CORE_ADDR is larger than unsigned int, we do math in
708  CORE_ADDR. But when we detect unsigned wraparound in the
709  CORE_ADDR math, we ignore this test and print the offset,
710  because addr+max_symbolic_offset has wrapped through the end
711  of the address space back to the beginning, giving bogus comparison. */
712  if (addr > name_location + max_symbolic_offset
713  && name_location + max_symbolic_offset > name_location)
714  return 1;
715 
716  *offset = addr - name_location;
717 
718  *name = xstrdup (name_temp);
719 
720  if (print_symbol_filename)
721  {
722  struct symtab_and_line sal;
723 
724  sal = find_pc_sect_line (addr, section, 0);
725 
726  if (sal.symtab)
727  {
728  *filename = xstrdup (symtab_to_filename_for_display (sal.symtab));
729  *line = sal.line;
730  }
731  }
732  return 0;
733 }
734 
735 
736 /* Print address ADDR symbolically on STREAM.
737  First print it as a number. Then perhaps print
738  <SYMBOL + OFFSET> after the number. */
739 
740 void
742  CORE_ADDR addr, struct ui_file *stream)
743 {
744  fputs_filtered (paddress (gdbarch, addr), stream);
745  print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
746 }
747 
748 /* Return a prefix for instruction address:
749  "=> " for current instruction, else " ". */
750 
751 const char *
753 {
754  if (has_stack_frames ())
755  {
756  struct frame_info *frame;
757  CORE_ADDR pc;
758 
759  frame = get_selected_frame (NULL);
760  if (get_frame_pc_if_available (frame, &pc) && pc == addr)
761  return "=> ";
762  }
763  return " ";
764 }
765 
766 /* Print address ADDR symbolically on STREAM. Parameter DEMANGLE
767  controls whether to print the symbolic name "raw" or demangled.
768  Return non-zero if anything was printed; zero otherwise. */
769 
770 int
772  struct gdbarch *gdbarch, CORE_ADDR addr,
773  struct ui_file *stream, int do_demangle)
774 {
775  if (opts->addressprint)
776  {
777  fputs_filtered (paddress (gdbarch, addr), stream);
778  print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
779  }
780  else
781  {
782  return print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
783  }
784  return 1;
785 }
786 
787 
788 /* Examine data at address ADDR in format FMT.
789  Fetch it from memory and print on gdb_stdout. */
790 
791 static void
793 {
794  char format = 0;
795  char size;
796  int count = 1;
797  struct type *val_type = NULL;
798  int i;
799  int maxelts;
800  struct value_print_options opts;
801 
802  format = fmt.format;
803  size = fmt.size;
804  count = fmt.count;
805  next_gdbarch = gdbarch;
806  next_address = addr;
807 
808  /* Instruction format implies fetch single bytes
809  regardless of the specified size.
810  The case of strings is handled in decode_format, only explicit
811  size operator are not changed to 'b'. */
812  if (format == 'i')
813  size = 'b';
814 
815  if (size == 'a')
816  {
817  /* Pick the appropriate size for an address. */
818  if (gdbarch_ptr_bit (next_gdbarch) == 64)
819  size = 'g';
820  else if (gdbarch_ptr_bit (next_gdbarch) == 32)
821  size = 'w';
822  else if (gdbarch_ptr_bit (next_gdbarch) == 16)
823  size = 'h';
824  else
825  /* Bad value for gdbarch_ptr_bit. */
826  internal_error (__FILE__, __LINE__,
827  _("failed internal consistency check"));
828  }
829 
830  if (size == 'b')
831  val_type = builtin_type (next_gdbarch)->builtin_int8;
832  else if (size == 'h')
833  val_type = builtin_type (next_gdbarch)->builtin_int16;
834  else if (size == 'w')
835  val_type = builtin_type (next_gdbarch)->builtin_int32;
836  else if (size == 'g')
837  val_type = builtin_type (next_gdbarch)->builtin_int64;
838 
839  if (format == 's')
840  {
841  struct type *char_type = NULL;
842 
843  /* Search for "char16_t" or "char32_t" types or fall back to 8-bit char
844  if type is not found. */
845  if (size == 'h')
846  char_type = builtin_type (next_gdbarch)->builtin_char16;
847  else if (size == 'w')
848  char_type = builtin_type (next_gdbarch)->builtin_char32;
849  if (char_type)
850  val_type = char_type;
851  else
852  {
853  if (size != '\0' && size != 'b')
854  warning (_("Unable to display strings with "
855  "size '%c', using 'b' instead."), size);
856  size = 'b';
857  val_type = builtin_type (next_gdbarch)->builtin_int8;
858  }
859  }
860 
861  maxelts = 8;
862  if (size == 'w')
863  maxelts = 4;
864  if (size == 'g')
865  maxelts = 2;
866  if (format == 's' || format == 'i')
867  maxelts = 1;
868 
869  get_formatted_print_options (&opts, format);
870 
871  /* Print as many objects as specified in COUNT, at most maxelts per line,
872  with the address of the next one at the start of each line. */
873 
874  while (count > 0)
875  {
876  QUIT;
877  if (format == 'i')
878  fputs_filtered (pc_prefix (next_address), gdb_stdout);
879  print_address (next_gdbarch, next_address, gdb_stdout);
880  printf_filtered (":");
881  for (i = maxelts;
882  i > 0 && count > 0;
883  i--, count--)
884  {
885  printf_filtered ("\t");
886  /* Note that print_formatted sets next_address for the next
887  object. */
888  last_examine_address = next_address;
889 
890  if (last_examine_value)
891  value_free (last_examine_value);
892 
893  /* The value to be displayed is not fetched greedily.
894  Instead, to avoid the possibility of a fetched value not
895  being used, its retrieval is delayed until the print code
896  uses it. When examining an instruction stream, the
897  disassembler will perform its own memory fetch using just
898  the address stored in LAST_EXAMINE_VALUE. FIXME: Should
899  the disassembler be modified so that LAST_EXAMINE_VALUE
900  is left with the byte sequence from the last complete
901  instruction fetched from memory? */
902  last_examine_value = value_at_lazy (val_type, next_address);
903 
904  if (last_examine_value)
905  release_value (last_examine_value);
906 
907  print_formatted (last_examine_value, size, &opts, gdb_stdout);
908 
909  /* Display any branch delay slots following the final insn. */
910  if (format == 'i' && count == 1)
911  count += branch_delay_insns;
912  }
913  printf_filtered ("\n");
915  }
916 }
917 
918 static void
919 validate_format (struct format_data fmt, const char *cmdname)
920 {
921  if (fmt.size != 0)
922  error (_("Size letters are meaningless in \"%s\" command."), cmdname);
923  if (fmt.count != 1)
924  error (_("Item count other than 1 is meaningless in \"%s\" command."),
925  cmdname);
926  if (fmt.format == 'i')
927  error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
928  fmt.format, cmdname);
929 }
930 
931 /* Parse print command format string into *FMTP and update *EXPP.
932  CMDNAME should name the current command. */
933 
934 void
935 print_command_parse_format (const char **expp, const char *cmdname,
936  struct format_data *fmtp)
937 {
938  const char *exp = *expp;
939 
940  if (exp && *exp == '/')
941  {
942  exp++;
943  *fmtp = decode_format (&exp, last_format, 0);
944  validate_format (*fmtp, cmdname);
945  last_format = fmtp->format;
946  }
947  else
948  {
949  fmtp->count = 1;
950  fmtp->format = 0;
951  fmtp->size = 0;
952  fmtp->raw = 0;
953  }
954 
955  *expp = exp;
956 }
957 
958 /* Print VAL to console according to *FMTP, including recording it to
959  the history. */
960 
961 void
962 print_value (struct value *val, const struct format_data *fmtp)
963 {
964  struct value_print_options opts;
965  int histindex = record_latest_value (val);
966 
967  annotate_value_history_begin (histindex, value_type (val));
968 
969  printf_filtered ("$%d = ", histindex);
970 
972 
973  get_formatted_print_options (&opts, fmtp->format);
974  opts.raw = fmtp->raw;
975 
976  print_formatted (val, fmtp->size, &opts, gdb_stdout);
977  printf_filtered ("\n");
978 
980 }
981 
982 /* Evaluate string EXP as an expression in the current language and
983  print the resulting value. EXP may contain a format specifier as the
984  first argument ("/x myvar" for example, to print myvar in hex). */
985 
986 static void
987 print_command_1 (const char *exp, int voidprint)
988 {
989  struct expression *expr;
990  struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
991  struct value *val;
992  struct format_data fmt;
993 
994  print_command_parse_format (&exp, "print", &fmt);
995 
996  if (exp && *exp)
997  {
998  expr = parse_expression (exp);
1000  val = evaluate_expression (expr);
1001  }
1002  else
1003  val = access_value_history (0);
1004 
1005  if (voidprint || (val && value_type (val) &&
1006  TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
1007  print_value (val, &fmt);
1008 
1009  do_cleanups (old_chain);
1010 }
1011 
1012 static void
1013 print_command (char *exp, int from_tty)
1014 {
1015  print_command_1 (exp, 1);
1016 }
1017 
1018 /* Same as print, except it doesn't print void results. */
1019 static void
1020 call_command (char *exp, int from_tty)
1021 {
1022  print_command_1 (exp, 0);
1023 }
1024 
1025 /* Implementation of the "output" command. */
1026 
1027 static void
1028 output_command (char *exp, int from_tty)
1029 {
1030  output_command_const (exp, from_tty);
1031 }
1032 
1033 /* Like output_command, but takes a const string as argument. */
1034 
1035 void
1036 output_command_const (const char *exp, int from_tty)
1037 {
1038  struct expression *expr;
1039  struct cleanup *old_chain;
1040  char format = 0;
1041  struct value *val;
1042  struct format_data fmt;
1043  struct value_print_options opts;
1044 
1045  fmt.size = 0;
1046  fmt.raw = 0;
1047 
1048  if (exp && *exp == '/')
1049  {
1050  exp++;
1051  fmt = decode_format (&exp, 0, 0);
1052  validate_format (fmt, "output");
1053  format = fmt.format;
1054  }
1055 
1056  expr = parse_expression (exp);
1057  old_chain = make_cleanup (free_current_contents, &expr);
1058 
1059  val = evaluate_expression (expr);
1060 
1062 
1063  get_formatted_print_options (&opts, format);
1064  opts.raw = fmt.raw;
1065  print_formatted (val, fmt.size, &opts, gdb_stdout);
1066 
1067  annotate_value_end ();
1068 
1069  wrap_here ("");
1071 
1072  do_cleanups (old_chain);
1073 }
1074 
1075 static void
1076 set_command (char *exp, int from_tty)
1077 {
1078  struct expression *expr = parse_expression (exp);
1079  struct cleanup *old_chain =
1081 
1082  if (expr->nelts >= 1)
1083  switch (expr->elts[0].opcode)
1084  {
1085  case UNOP_PREINCREMENT:
1086  case UNOP_POSTINCREMENT:
1087  case UNOP_PREDECREMENT:
1088  case UNOP_POSTDECREMENT:
1089  case BINOP_ASSIGN:
1090  case BINOP_ASSIGN_MODIFY:
1091  case BINOP_COMMA:
1092  break;
1093  default:
1094  warning
1095  (_("Expression is not an assignment (and might have no effect)"));
1096  }
1097 
1098  evaluate_expression (expr);
1099  do_cleanups (old_chain);
1100 }
1101 
1102 static void
1103 sym_info (char *arg, int from_tty)
1104 {
1105  struct minimal_symbol *msymbol;
1106  struct objfile *objfile;
1107  struct obj_section *osect;
1108  CORE_ADDR addr, sect_addr;
1109  int matches = 0;
1110  unsigned int offset;
1111 
1112  if (!arg)
1113  error_no_arg (_("address"));
1114 
1115  addr = parse_and_eval_address (arg);
1116  ALL_OBJSECTIONS (objfile, osect)
1117  {
1118  /* Only process each object file once, even if there's a separate
1119  debug file. */
1120  if (objfile->separate_debug_objfile_backlink)
1121  continue;
1122 
1123  sect_addr = overlay_mapped_address (addr, osect);
1124 
1125  if (obj_section_addr (osect) <= sect_addr
1126  && sect_addr < obj_section_endaddr (osect)
1127  && (msymbol
1128  = lookup_minimal_symbol_by_pc_section (sect_addr, osect).minsym))
1129  {
1130  const char *obj_name, *mapped, *sec_name, *msym_name;
1131  char *loc_string;
1132  struct cleanup *old_chain;
1133 
1134  matches = 1;
1135  offset = sect_addr - MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
1136  mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
1137  sec_name = osect->the_bfd_section->name;
1138  msym_name = MSYMBOL_PRINT_NAME (msymbol);
1139 
1140  /* Don't print the offset if it is zero.
1141  We assume there's no need to handle i18n of "sym + offset". */
1142  if (offset)
1143  loc_string = xstrprintf ("%s + %u", msym_name, offset);
1144  else
1145  loc_string = xstrprintf ("%s", msym_name);
1146 
1147  /* Use a cleanup to free loc_string in case the user quits
1148  a pagination request inside printf_filtered. */
1149  old_chain = make_cleanup (xfree, loc_string);
1150 
1151  gdb_assert (osect->objfile && objfile_name (osect->objfile));
1152  obj_name = objfile_name (osect->objfile);
1153 
1154  if (MULTI_OBJFILE_P ())
1155  if (pc_in_unmapped_range (addr, osect))
1156  if (section_is_overlay (osect))
1157  printf_filtered (_("%s in load address range of "
1158  "%s overlay section %s of %s\n"),
1159  loc_string, mapped, sec_name, obj_name);
1160  else
1161  printf_filtered (_("%s in load address range of "
1162  "section %s of %s\n"),
1163  loc_string, sec_name, obj_name);
1164  else
1165  if (section_is_overlay (osect))
1166  printf_filtered (_("%s in %s overlay section %s of %s\n"),
1167  loc_string, mapped, sec_name, obj_name);
1168  else
1169  printf_filtered (_("%s in section %s of %s\n"),
1170  loc_string, sec_name, obj_name);
1171  else
1172  if (pc_in_unmapped_range (addr, osect))
1173  if (section_is_overlay (osect))
1174  printf_filtered (_("%s in load address range of %s overlay "
1175  "section %s\n"),
1176  loc_string, mapped, sec_name);
1177  else
1178  printf_filtered (_("%s in load address range of section %s\n"),
1179  loc_string, sec_name);
1180  else
1181  if (section_is_overlay (osect))
1182  printf_filtered (_("%s in %s overlay section %s\n"),
1183  loc_string, mapped, sec_name);
1184  else
1185  printf_filtered (_("%s in section %s\n"),
1186  loc_string, sec_name);
1187 
1188  do_cleanups (old_chain);
1189  }
1190  }
1191  if (matches == 0)
1192  printf_filtered (_("No symbol matches %s.\n"), arg);
1193 }
1194 
1195 static void
1196 address_info (char *exp, int from_tty)
1197 {
1198  struct gdbarch *gdbarch;
1199  int regno;
1200  struct symbol *sym;
1201  struct bound_minimal_symbol msymbol;
1202  long val;
1203  struct obj_section *section;
1204  CORE_ADDR load_addr, context_pc = 0;
1205  struct field_of_this_result is_a_field_of_this;
1206 
1207  if (exp == 0)
1208  error (_("Argument required."));
1209 
1210  sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
1211  &is_a_field_of_this);
1212  if (sym == NULL)
1213  {
1214  if (is_a_field_of_this.type != NULL)
1215  {
1216  printf_filtered ("Symbol \"");
1218  current_language->la_language, DMGL_ANSI);
1219  printf_filtered ("\" is a field of the local class variable ");
1221  printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
1222  else
1223  printf_filtered ("`this'\n");
1224  return;
1225  }
1226 
1227  msymbol = lookup_bound_minimal_symbol (exp);
1228 
1229  if (msymbol.minsym != NULL)
1230  {
1231  struct objfile *objfile = msymbol.objfile;
1232 
1233  gdbarch = get_objfile_arch (objfile);
1234  load_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
1235 
1236  printf_filtered ("Symbol \"");
1238  current_language->la_language, DMGL_ANSI);
1239  printf_filtered ("\" is at ");
1240  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1241  printf_filtered (" in a file compiled without debugging");
1242  section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
1243  if (section_is_overlay (section))
1244  {
1245  load_addr = overlay_unmapped_address (load_addr, section);
1246  printf_filtered (",\n -- loaded at ");
1247  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1248  printf_filtered (" in overlay section %s",
1249  section->the_bfd_section->name);
1250  }
1251  printf_filtered (".\n");
1252  }
1253  else
1254  error (_("No symbol \"%s\" in current context."), exp);
1255  return;
1256  }
1257 
1258  printf_filtered ("Symbol \"");
1260  current_language->la_language, DMGL_ANSI);
1261  printf_filtered ("\" is ");
1262  val = SYMBOL_VALUE (sym);
1263  if (SYMBOL_OBJFILE_OWNED (sym))
1264  section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
1265  else
1266  section = NULL;
1267  gdbarch = symbol_arch (sym);
1268 
1269  if (SYMBOL_COMPUTED_OPS (sym) != NULL)
1270  {
1271  SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
1272  gdb_stdout);
1273  printf_filtered (".\n");
1274  return;
1275  }
1276 
1277  switch (SYMBOL_CLASS (sym))
1278  {
1279  case LOC_CONST:
1280  case LOC_CONST_BYTES:
1281  printf_filtered ("constant");
1282  break;
1283 
1284  case LOC_LABEL:
1285  printf_filtered ("a label at address ");
1286  load_addr = SYMBOL_VALUE_ADDRESS (sym);
1287  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1288  if (section_is_overlay (section))
1289  {
1290  load_addr = overlay_unmapped_address (load_addr, section);
1291  printf_filtered (",\n -- loaded at ");
1292  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1293  printf_filtered (" in overlay section %s",
1294  section->the_bfd_section->name);
1295  }
1296  break;
1297 
1298  case LOC_COMPUTED:
1299  gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
1300 
1301  case LOC_REGISTER:
1302  /* GDBARCH is the architecture associated with the objfile the symbol
1303  is defined in; the target architecture may be different, and may
1304  provide additional registers. However, we do not know the target
1305  architecture at this point. We assume the objfile architecture
1306  will contain all the standard registers that occur in debug info
1307  in that objfile. */
1308  regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1309 
1310  if (SYMBOL_IS_ARGUMENT (sym))
1311  printf_filtered (_("an argument in register %s"),
1312  gdbarch_register_name (gdbarch, regno));
1313  else
1314  printf_filtered (_("a variable in register %s"),
1315  gdbarch_register_name (gdbarch, regno));
1316  break;
1317 
1318  case LOC_STATIC:
1319  printf_filtered (_("static storage at address "));
1320  load_addr = SYMBOL_VALUE_ADDRESS (sym);
1321  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1322  if (section_is_overlay (section))
1323  {
1324  load_addr = overlay_unmapped_address (load_addr, section);
1325  printf_filtered (_(",\n -- loaded at "));
1326  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1327  printf_filtered (_(" in overlay section %s"),
1328  section->the_bfd_section->name);
1329  }
1330  break;
1331 
1332  case LOC_REGPARM_ADDR:
1333  /* Note comment at LOC_REGISTER. */
1334  regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1335  printf_filtered (_("address of an argument in register %s"),
1336  gdbarch_register_name (gdbarch, regno));
1337  break;
1338 
1339  case LOC_ARG:
1340  printf_filtered (_("an argument at offset %ld"), val);
1341  break;
1342 
1343  case LOC_LOCAL:
1344  printf_filtered (_("a local variable at frame offset %ld"), val);
1345  break;
1346 
1347  case LOC_REF_ARG:
1348  printf_filtered (_("a reference argument at offset %ld"), val);
1349  break;
1350 
1351  case LOC_TYPEDEF:
1352  printf_filtered (_("a typedef"));
1353  break;
1354 
1355  case LOC_BLOCK:
1356  printf_filtered (_("a function at address "));
1357  load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1358  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1359  if (section_is_overlay (section))
1360  {
1361  load_addr = overlay_unmapped_address (load_addr, section);
1362  printf_filtered (_(",\n -- loaded at "));
1363  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1364  printf_filtered (_(" in overlay section %s"),
1365  section->the_bfd_section->name);
1366  }
1367  break;
1368 
1369  case LOC_UNRESOLVED:
1370  {
1371  struct bound_minimal_symbol msym;
1372 
1374  if (msym.minsym == NULL)
1375  printf_filtered ("unresolved");
1376  else
1377  {
1378  section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
1379  load_addr = BMSYMBOL_VALUE_ADDRESS (msym);
1380 
1381  if (section
1382  && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1383  printf_filtered (_("a thread-local variable at offset %s "
1384  "in the thread-local storage for `%s'"),
1385  paddress (gdbarch, load_addr),
1386  objfile_name (section->objfile));
1387  else
1388  {
1389  printf_filtered (_("static storage at address "));
1390  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1391  if (section_is_overlay (section))
1392  {
1393  load_addr = overlay_unmapped_address (load_addr, section);
1394  printf_filtered (_(",\n -- loaded at "));
1395  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1396  printf_filtered (_(" in overlay section %s"),
1397  section->the_bfd_section->name);
1398  }
1399  }
1400  }
1401  }
1402  break;
1403 
1404  case LOC_OPTIMIZED_OUT:
1405  printf_filtered (_("optimized out"));
1406  break;
1407 
1408  default:
1409  printf_filtered (_("of unknown (botched) type"));
1410  break;
1411  }
1412  printf_filtered (".\n");
1413 }
1414 
1415 
1416 static void
1417 x_command (char *exp, int from_tty)
1418 {
1419  struct expression *expr;
1420  struct format_data fmt;
1421  struct cleanup *old_chain;
1422  struct value *val;
1423 
1424  fmt.format = last_format ? last_format : 'x';
1425  fmt.size = last_size;
1426  fmt.count = 1;
1427  fmt.raw = 0;
1428 
1429  if (exp && *exp == '/')
1430  {
1431  const char *tmp = exp + 1;
1432 
1433  fmt = decode_format (&tmp, last_format, last_size);
1434  exp = (char *) tmp;
1435  }
1436 
1437  /* If we have an expression, evaluate it and use it as the address. */
1438 
1439  if (exp != 0 && *exp != 0)
1440  {
1441  expr = parse_expression (exp);
1442  /* Cause expression not to be there any more if this command is
1443  repeated with Newline. But don't clobber a user-defined
1444  command's definition. */
1445  if (from_tty)
1446  *exp = 0;
1447  old_chain = make_cleanup (free_current_contents, &expr);
1448  val = evaluate_expression (expr);
1449  if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1450  val = coerce_ref (val);
1451  /* In rvalue contexts, such as this, functions are coerced into
1452  pointers to functions. This makes "x/i main" work. */
1453  if (/* last_format == 'i' && */
1455  && VALUE_LVAL (val) == lval_memory)
1456  next_address = value_address (val);
1457  else
1458  next_address = value_as_address (val);
1459 
1460  next_gdbarch = expr->gdbarch;
1461  do_cleanups (old_chain);
1462  }
1463 
1464  if (!next_gdbarch)
1465  error_no_arg (_("starting display address"));
1466 
1467  do_examine (fmt, next_gdbarch, next_address);
1468 
1469  /* If the examine succeeds, we remember its size and format for next
1470  time. Set last_size to 'b' for strings. */
1471  if (fmt.format == 's')
1472  last_size = 'b';
1473  else
1474  last_size = fmt.size;
1475  last_format = fmt.format;
1476 
1477  /* Set a couple of internal variables if appropriate. */
1478  if (last_examine_value)
1479  {
1480  /* Make last address examined available to the user as $_. Use
1481  the correct pointer type. */
1482  struct type *pointer_type
1483  = lookup_pointer_type (value_type (last_examine_value));
1485  value_from_pointer (pointer_type,
1486  last_examine_address));
1487 
1488  /* Make contents of last address examined available to the user
1489  as $__. If the last value has not been fetched from memory
1490  then don't fetch it now; instead mark it by voiding the $__
1491  variable. */
1492  if (value_lazy (last_examine_value))
1494  else
1495  set_internalvar (lookup_internalvar ("__"), last_examine_value);
1496  }
1497 }
1498 
1499 
1500 /* Add an expression to the auto-display chain.
1501  Specify the expression. */
1502 
1503 static void
1504 display_command (char *arg, int from_tty)
1505 {
1506  struct format_data fmt;
1507  struct expression *expr;
1508  struct display *newobj;
1509  const char *exp = arg;
1510 
1511  if (exp == 0)
1512  {
1513  do_displays ();
1514  return;
1515  }
1516 
1517  if (*exp == '/')
1518  {
1519  exp++;
1520  fmt = decode_format (&exp, 0, 0);
1521  if (fmt.size && fmt.format == 0)
1522  fmt.format = 'x';
1523  if (fmt.format == 'i' || fmt.format == 's')
1524  fmt.size = 'b';
1525  }
1526  else
1527  {
1528  fmt.format = 0;
1529  fmt.size = 0;
1530  fmt.count = 0;
1531  fmt.raw = 0;
1532  }
1533 
1534  innermost_block = NULL;
1535  expr = parse_expression (exp);
1536 
1537  newobj = (struct display *) xmalloc (sizeof (struct display));
1538 
1539  newobj->exp_string = xstrdup (exp);
1540  newobj->exp = expr;
1541  newobj->block = innermost_block;
1542  newobj->pspace = current_program_space;
1543  newobj->next = display_chain;
1544  newobj->number = ++display_number;
1545  newobj->format = fmt;
1546  newobj->enabled_p = 1;
1547  display_chain = newobj;
1548 
1549  if (from_tty)
1550  do_one_display (newobj);
1551 
1552  dont_repeat ();
1553 }
1554 
1555 static void
1557 {
1558  xfree (d->exp_string);
1559  xfree (d->exp);
1560  xfree (d);
1561 }
1562 
1563 /* Clear out the display_chain. Done when new symtabs are loaded,
1564  since this invalidates the types stored in many expressions. */
1565 
1566 void
1568 {
1569  struct display *d;
1570 
1571  while ((d = display_chain) != NULL)
1572  {
1573  display_chain = d->next;
1574  free_display (d);
1575  }
1576 }
1577 
1578 /* Delete the auto-display DISPLAY. */
1579 
1580 static void
1582 {
1583  struct display *d;
1584 
1585  gdb_assert (display != NULL);
1586 
1587  if (display_chain == display)
1588  display_chain = display->next;
1589 
1590  ALL_DISPLAYS (d)
1591  if (d->next == display)
1592  {
1593  d->next = display->next;
1594  break;
1595  }
1596 
1597  free_display (display);
1598 }
1599 
1600 /* Call FUNCTION on each of the displays whose numbers are given in
1601  ARGS. DATA is passed unmodified to FUNCTION. */
1602 
1603 static void
1605  void (*function) (struct display *,
1606  void *),
1607  void *data)
1608 {
1609  struct get_number_or_range_state state;
1610  int num;
1611 
1612  if (args == NULL)
1613  error_no_arg (_("one or more display numbers"));
1614 
1615  init_number_or_range (&state, args);
1616 
1617  while (!state.finished)
1618  {
1619  const char *p = state.string;
1620 
1621  num = get_number_or_range (&state);
1622  if (num == 0)
1623  warning (_("bad display number at or near '%s'"), p);
1624  else
1625  {
1626  struct display *d, *tmp;
1627 
1628  ALL_DISPLAYS_SAFE (d, tmp)
1629  if (d->number == num)
1630  break;
1631  if (d == NULL)
1632  printf_unfiltered (_("No display number %d.\n"), num);
1633  else
1634  function (d, data);
1635  }
1636  }
1637 }
1638 
1639 /* Callback for map_display_numbers, that deletes a display. */
1640 
1641 static void
1642 do_delete_display (struct display *d, void *data)
1643 {
1644  delete_display (d);
1645 }
1646 
1647 /* "undisplay" command. */
1648 
1649 static void
1650 undisplay_command (char *args, int from_tty)
1651 {
1652  if (args == NULL)
1653  {
1654  if (query (_("Delete all auto-display expressions? ")))
1655  clear_displays ();
1656  dont_repeat ();
1657  return;
1658  }
1659 
1660  map_display_numbers (args, do_delete_display, NULL);
1661  dont_repeat ();
1662 }
1663 
1664 /* Display a single auto-display.
1665  Do nothing if the display cannot be printed in the current context,
1666  or if the display is disabled. */
1667 
1668 static void
1670 {
1671  struct cleanup *old_chain;
1672  int within_current_scope;
1673 
1674  if (d->enabled_p == 0)
1675  return;
1676 
1677  /* The expression carries the architecture that was used at parse time.
1678  This is a problem if the expression depends on architecture features
1679  (e.g. register numbers), and the current architecture is now different.
1680  For example, a display statement like "display/i $pc" is expected to
1681  display the PC register of the current architecture, not the arch at
1682  the time the display command was given. Therefore, we re-parse the
1683  expression if the current architecture has changed. */
1684  if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1685  {
1686  xfree (d->exp);
1687  d->exp = NULL;
1688  d->block = NULL;
1689  }
1690 
1691  if (d->exp == NULL)
1692  {
1693 
1694  TRY
1695  {
1696  innermost_block = NULL;
1697  d->exp = parse_expression (d->exp_string);
1698  d->block = innermost_block;
1699  }
1700  CATCH (ex, RETURN_MASK_ALL)
1701  {
1702  /* Can't re-parse the expression. Disable this display item. */
1703  d->enabled_p = 0;
1704  warning (_("Unable to display \"%s\": %s"),
1705  d->exp_string, ex.message);
1706  return;
1707  }
1708  END_CATCH
1709  }
1710 
1711  if (d->block)
1712  {
1713  if (d->pspace == current_program_space)
1714  within_current_scope = contained_in (get_selected_block (0), d->block);
1715  else
1716  within_current_scope = 0;
1717  }
1718  else
1719  within_current_scope = 1;
1720  if (!within_current_scope)
1721  return;
1722 
1723  old_chain = make_cleanup_restore_integer (&current_display_number);
1724  current_display_number = d->number;
1725 
1727  printf_filtered ("%d", d->number);
1729  printf_filtered (": ");
1730  if (d->format.size)
1731  {
1732 
1734 
1735  printf_filtered ("x/");
1736  if (d->format.count != 1)
1737  printf_filtered ("%d", d->format.count);
1738  printf_filtered ("%c", d->format.format);
1739  if (d->format.format != 'i' && d->format.format != 's')
1740  printf_filtered ("%c", d->format.size);
1741  printf_filtered (" ");
1742 
1744 
1747 
1748  if (d->format.count != 1 || d->format.format == 'i')
1749  printf_filtered ("\n");
1750  else
1751  printf_filtered (" ");
1752 
1754 
1755  TRY
1756  {
1757  struct value *val;
1758  CORE_ADDR addr;
1759 
1760  val = evaluate_expression (d->exp);
1761  addr = value_as_address (val);
1762  if (d->format.format == 'i')
1763  addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1764  do_examine (d->format, d->exp->gdbarch, addr);
1765  }
1766  CATCH (ex, RETURN_MASK_ERROR)
1767  {
1768  fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
1769  }
1770  END_CATCH
1771  }
1772  else
1773  {
1774  struct value_print_options opts;
1775 
1777 
1778  if (d->format.format)
1779  printf_filtered ("/%c ", d->format.format);
1780 
1782 
1785 
1786  printf_filtered (" = ");
1787 
1789 
1791  opts.raw = d->format.raw;
1792 
1793  TRY
1794  {
1795  struct value *val;
1796 
1797  val = evaluate_expression (d->exp);
1798  print_formatted (val, d->format.size, &opts, gdb_stdout);
1799  }
1800  CATCH (ex, RETURN_MASK_ERROR)
1801  {
1802  fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1803  }
1804  END_CATCH
1805 
1806  printf_filtered ("\n");
1807  }
1808 
1810 
1812  do_cleanups (old_chain);
1813 }
1814 
1815 /* Display all of the values on the auto-display chain which can be
1816  evaluated in the current scope. */
1817 
1818 void
1820 {
1821  struct display *d;
1822 
1823  for (d = display_chain; d; d = d->next)
1824  do_one_display (d);
1825 }
1826 
1827 /* Delete the auto-display which we were in the process of displaying.
1828  This is done when there is an error or a signal. */
1829 
1830 void
1832 {
1833  struct display *d;
1834 
1835  for (d = display_chain; d; d = d->next)
1836  if (d->number == num)
1837  {
1838  d->enabled_p = 0;
1839  return;
1840  }
1841  printf_unfiltered (_("No display number %d.\n"), num);
1842 }
1843 
1844 void
1846 {
1847  if (current_display_number >= 0)
1848  {
1849  disable_display (current_display_number);
1851  _("Disabling display %d to "
1852  "avoid infinite recursion.\n"),
1853  current_display_number);
1854  }
1855  current_display_number = -1;
1856 }
1857 
1858 static void
1859 display_info (char *ignore, int from_tty)
1860 {
1861  struct display *d;
1862 
1863  if (!display_chain)
1864  printf_unfiltered (_("There are no auto-display expressions now.\n"));
1865  else
1866  printf_filtered (_("Auto-display expressions now in effect:\n\
1867 Num Enb Expression\n"));
1868 
1869  for (d = display_chain; d; d = d->next)
1870  {
1871  printf_filtered ("%d: %c ", d->number, "ny"[(int) d->enabled_p]);
1872  if (d->format.size)
1873  printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1874  d->format.format);
1875  else if (d->format.format)
1876  printf_filtered ("/%c ", d->format.format);
1878  if (d->block && !contained_in (get_selected_block (0), d->block))
1879  printf_filtered (_(" (cannot be evaluated in the current context)"));
1880  printf_filtered ("\n");
1882  }
1883 }
1884 
1885 /* Callback fo map_display_numbers, that enables or disables the
1886  passed in display D. */
1887 
1888 static void
1889 do_enable_disable_display (struct display *d, void *data)
1890 {
1891  d->enabled_p = *(int *) data;
1892 }
1893 
1894 /* Implamentation of both the "disable display" and "enable display"
1895  commands. ENABLE decides what to do. */
1896 
1897 static void
1898 enable_disable_display_command (char *args, int from_tty, int enable)
1899 {
1900  if (args == NULL)
1901  {
1902  struct display *d;
1903 
1904  ALL_DISPLAYS (d)
1905  d->enabled_p = enable;
1906  return;
1907  }
1908 
1910 }
1911 
1912 /* The "enable display" command. */
1913 
1914 static void
1915 enable_display_command (char *args, int from_tty)
1916 {
1917  enable_disable_display_command (args, from_tty, 1);
1918 }
1919 
1920 /* The "disable display" command. */
1921 
1922 static void
1923 disable_display_command (char *args, int from_tty)
1924 {
1925  enable_disable_display_command (args, from_tty, 0);
1926 }
1927 
1928 /* display_chain items point to blocks and expressions. Some expressions in
1929  turn may point to symbols.
1930  Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1931  obstack_free'd when a shared library is unloaded.
1932  Clear pointers that are about to become dangling.
1933  Both .exp and .block fields will be restored next time we need to display
1934  an item by re-parsing .exp_string field in the new execution context. */
1935 
1936 static void
1938 {
1939  struct display *d;
1940  struct program_space *pspace;
1941 
1942  /* With no symbol file we cannot have a block or expression from it. */
1943  if (objfile == NULL)
1944  return;
1945  pspace = objfile->pspace;
1946  if (objfile->separate_debug_objfile_backlink)
1947  {
1948  objfile = objfile->separate_debug_objfile_backlink;
1949  gdb_assert (objfile->pspace == pspace);
1950  }
1951 
1952  for (d = display_chain; d != NULL; d = d->next)
1953  {
1954  if (d->pspace != pspace)
1955  continue;
1956 
1957  if (lookup_objfile_from_block (d->block) == objfile
1958  || (d->exp && exp_uses_objfile (d->exp, objfile)))
1959  {
1960  xfree (d->exp);
1961  d->exp = NULL;
1962  d->block = NULL;
1963  }
1964  }
1965 }
1966 
1967 
1968 /* Print the value in stack frame FRAME of a variable specified by a
1969  struct symbol. NAME is the name to print; if NULL then VAR's print
1970  name will be used. STREAM is the ui_file on which to print the
1971  value. INDENT specifies the number of indent levels to print
1972  before printing the variable name.
1973 
1974  This function invalidates FRAME. */
1975 
1976 void
1977 print_variable_and_value (const char *name, struct symbol *var,
1978  struct frame_info *frame,
1979  struct ui_file *stream, int indent)
1980 {
1981 
1982  if (!name)
1983  name = SYMBOL_PRINT_NAME (var);
1984 
1985  fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
1986  TRY
1987  {
1988  struct value *val;
1989  struct value_print_options opts;
1990 
1991  val = read_var_value (var, frame);
1992  get_user_print_options (&opts);
1993  opts.deref_ref = 1;
1994  common_val_print (val, stream, indent, &opts, current_language);
1995 
1996  /* common_val_print invalidates FRAME when a pretty printer calls inferior
1997  function. */
1998  frame = NULL;
1999  }
2000  CATCH (except, RETURN_MASK_ERROR)
2001  {
2002  fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
2003  except.message);
2004  }
2005  END_CATCH
2006 
2007  fprintf_filtered (stream, "\n");
2008 }
2009 
2010 /* Subroutine of ui_printf to simplify it.
2011  Print VALUE to STREAM using FORMAT.
2012  VALUE is a C-style string on the target. */
2013 
2014 static void
2015 printf_c_string (struct ui_file *stream, const char *format,
2016  struct value *value)
2017 {
2018  gdb_byte *str;
2019  CORE_ADDR tem;
2020  int j;
2021 
2022  tem = value_as_address (value);
2023 
2024  /* This is a %s argument. Find the length of the string. */
2025  for (j = 0;; j++)
2026  {
2027  gdb_byte c;
2028 
2029  QUIT;
2030  read_memory (tem + j, &c, 1);
2031  if (c == 0)
2032  break;
2033  }
2034 
2035  /* Copy the string contents into a string inside GDB. */
2036  str = (gdb_byte *) alloca (j + 1);
2037  if (j != 0)
2038  read_memory (tem, str, j);
2039  str[j] = 0;
2040 
2041  fprintf_filtered (stream, format, (char *) str);
2042 }
2043 
2044 /* Subroutine of ui_printf to simplify it.
2045  Print VALUE to STREAM using FORMAT.
2046  VALUE is a wide C-style string on the target. */
2047 
2048 static void
2049 printf_wide_c_string (struct ui_file *stream, const char *format,
2050  struct value *value)
2051 {
2052  gdb_byte *str;
2053  CORE_ADDR tem;
2054  int j;
2055  struct gdbarch *gdbarch = get_type_arch (value_type (value));
2056  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2057  struct type *wctype = lookup_typename (current_language, gdbarch,
2058  "wchar_t", NULL, 0);
2059  int wcwidth = TYPE_LENGTH (wctype);
2060  gdb_byte *buf = alloca (wcwidth);
2061  struct obstack output;
2062  struct cleanup *inner_cleanup;
2063 
2064  tem = value_as_address (value);
2065 
2066  /* This is a %s argument. Find the length of the string. */
2067  for (j = 0;; j += wcwidth)
2068  {
2069  QUIT;
2070  read_memory (tem + j, buf, wcwidth);
2071  if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2072  break;
2073  }
2074 
2075  /* Copy the string contents into a string inside GDB. */
2076  str = (gdb_byte *) alloca (j + wcwidth);
2077  if (j != 0)
2078  read_memory (tem, str, j);
2079  memset (&str[j], 0, wcwidth);
2080 
2081  obstack_init (&output);
2082  inner_cleanup = make_cleanup_obstack_free (&output);
2083 
2085  host_charset (),
2086  str, j, wcwidth,
2087  &output, translit_char);
2088  obstack_grow_str0 (&output, "");
2089 
2090  fprintf_filtered (stream, format, obstack_base (&output));
2091  do_cleanups (inner_cleanup);
2092 }
2093 
2094 /* Subroutine of ui_printf to simplify it.
2095  Print VALUE, a decimal floating point value, to STREAM using FORMAT. */
2096 
2097 static void
2098 printf_decfloat (struct ui_file *stream, const char *format,
2099  struct value *value)
2100 {
2101  const gdb_byte *param_ptr = value_contents (value);
2102 
2103 #if defined (PRINTF_HAS_DECFLOAT)
2104  /* If we have native support for Decimal floating
2105  printing, handle it here. */
2106  fprintf_filtered (stream, format, param_ptr);
2107 #else
2108  /* As a workaround until vasprintf has native support for DFP
2109  we convert the DFP values to string and print them using
2110  the %s format specifier. */
2111  const char *p;
2112 
2113  /* Parameter data. */
2114  struct type *param_type = value_type (value);
2115  struct gdbarch *gdbarch = get_type_arch (param_type);
2116  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2117 
2118  /* DFP output data. */
2119  struct value *dfp_value = NULL;
2120  gdb_byte *dfp_ptr;
2121  int dfp_len = 16;
2122  gdb_byte dec[16];
2123  struct type *dfp_type = NULL;
2124  char decstr[MAX_DECIMAL_STRING];
2125 
2126  /* Points to the end of the string so that we can go back
2127  and check for DFP length modifiers. */
2128  p = format + strlen (format);
2129 
2130  /* Look for the float/double format specifier. */
2131  while (*p != 'f' && *p != 'e' && *p != 'E'
2132  && *p != 'g' && *p != 'G')
2133  p--;
2134 
2135  /* Search for the '%' char and extract the size and type of
2136  the output decimal value based on its modifiers
2137  (%Hf, %Df, %DDf). */
2138  while (*--p != '%')
2139  {
2140  if (*p == 'H')
2141  {
2142  dfp_len = 4;
2143  dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2144  }
2145  else if (*p == 'D' && *(p - 1) == 'D')
2146  {
2147  dfp_len = 16;
2148  dfp_type = builtin_type (gdbarch)->builtin_declong;
2149  p--;
2150  }
2151  else
2152  {
2153  dfp_len = 8;
2154  dfp_type = builtin_type (gdbarch)->builtin_decdouble;
2155  }
2156  }
2157 
2158  /* Conversion between different DFP types. */
2159  if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2160  decimal_convert (param_ptr, TYPE_LENGTH (param_type),
2161  byte_order, dec, dfp_len, byte_order);
2162  else
2163  /* If this is a non-trivial conversion, just output 0.
2164  A correct converted value can be displayed by explicitly
2165  casting to a DFP type. */
2166  decimal_from_string (dec, dfp_len, byte_order, "0");
2167 
2168  dfp_value = value_from_decfloat (dfp_type, dec);
2169 
2170  dfp_ptr = (gdb_byte *) value_contents (dfp_value);
2171 
2172  decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
2173 
2174  /* Print the DFP value. */
2175  fprintf_filtered (stream, "%s", decstr);
2176 #endif
2177 }
2178 
2179 /* Subroutine of ui_printf to simplify it.
2180  Print VALUE, a target pointer, to STREAM using FORMAT. */
2181 
2182 static void
2183 printf_pointer (struct ui_file *stream, const char *format,
2184  struct value *value)
2185 {
2186  /* We avoid the host's %p because pointers are too
2187  likely to be the wrong size. The only interesting
2188  modifier for %p is a width; extract that, and then
2189  handle %p as glibc would: %#x or a literal "(nil)". */
2190 
2191  const char *p;
2192  char *fmt, *fmt_p;
2193 #ifdef PRINTF_HAS_LONG_LONG
2194  long long val = value_as_long (value);
2195 #else
2196  long val = value_as_long (value);
2197 #endif
2198 
2199  fmt = alloca (strlen (format) + 5);
2200 
2201  /* Copy up to the leading %. */
2202  p = format;
2203  fmt_p = fmt;
2204  while (*p)
2205  {
2206  int is_percent = (*p == '%');
2207 
2208  *fmt_p++ = *p++;
2209  if (is_percent)
2210  {
2211  if (*p == '%')
2212  *fmt_p++ = *p++;
2213  else
2214  break;
2215  }
2216  }
2217 
2218  if (val != 0)
2219  *fmt_p++ = '#';
2220 
2221  /* Copy any width. */
2222  while (*p >= '0' && *p < '9')
2223  *fmt_p++ = *p++;
2224 
2225  gdb_assert (*p == 'p' && *(p + 1) == '\0');
2226  if (val != 0)
2227  {
2228 #ifdef PRINTF_HAS_LONG_LONG
2229  *fmt_p++ = 'l';
2230 #endif
2231  *fmt_p++ = 'l';
2232  *fmt_p++ = 'x';
2233  *fmt_p++ = '\0';
2234  fprintf_filtered (stream, fmt, val);
2235  }
2236  else
2237  {
2238  *fmt_p++ = 's';
2239  *fmt_p++ = '\0';
2240  fprintf_filtered (stream, fmt, "(nil)");
2241  }
2242 }
2243 
2244 /* printf "printf format string" ARG to STREAM. */
2245 
2246 static void
2247 ui_printf (const char *arg, struct ui_file *stream)
2248 {
2249  struct format_piece *fpieces;
2250  const char *s = arg;
2251  struct value **val_args;
2252  int allocated_args = 20;
2253  struct cleanup *old_cleanups;
2254 
2255  val_args = xmalloc (allocated_args * sizeof (struct value *));
2256  old_cleanups = make_cleanup (free_current_contents, &val_args);
2257 
2258  if (s == 0)
2259  error_no_arg (_("format-control string and values to print"));
2260 
2261  s = skip_spaces_const (s);
2262 
2263  /* A format string should follow, enveloped in double quotes. */
2264  if (*s++ != '"')
2265  error (_("Bad format string, missing '\"'."));
2266 
2267  fpieces = parse_format_string (&s);
2268 
2270 
2271  if (*s++ != '"')
2272  error (_("Bad format string, non-terminated '\"'."));
2273 
2274  s = skip_spaces_const (s);
2275 
2276  if (*s != ',' && *s != 0)
2277  error (_("Invalid argument syntax"));
2278 
2279  if (*s == ',')
2280  s++;
2281  s = skip_spaces_const (s);
2282 
2283  {
2284  int nargs = 0;
2285  int nargs_wanted;
2286  int i, fr;
2287  char *current_substring;
2288 
2289  nargs_wanted = 0;
2290  for (fr = 0; fpieces[fr].string != NULL; fr++)
2291  if (fpieces[fr].argclass != literal_piece)
2292  ++nargs_wanted;
2293 
2294  /* Now, parse all arguments and evaluate them.
2295  Store the VALUEs in VAL_ARGS. */
2296 
2297  while (*s != '\0')
2298  {
2299  const char *s1;
2300 
2301  if (nargs == allocated_args)
2302  val_args = (struct value **) xrealloc ((char *) val_args,
2303  (allocated_args *= 2)
2304  * sizeof (struct value *));
2305  s1 = s;
2306  val_args[nargs] = parse_to_comma_and_eval (&s1);
2307 
2308  nargs++;
2309  s = s1;
2310  if (*s == ',')
2311  s++;
2312  }
2313 
2314  if (nargs != nargs_wanted)
2315  error (_("Wrong number of arguments for specified format-string"));
2316 
2317  /* Now actually print them. */
2318  i = 0;
2319  for (fr = 0; fpieces[fr].string != NULL; fr++)
2320  {
2321  current_substring = fpieces[fr].string;
2322  switch (fpieces[fr].argclass)
2323  {
2324  case string_arg:
2325  printf_c_string (stream, current_substring, val_args[i]);
2326  break;
2327  case wide_string_arg:
2328  printf_wide_c_string (stream, current_substring, val_args[i]);
2329  break;
2330  case wide_char_arg:
2331  {
2332  struct gdbarch *gdbarch
2333  = get_type_arch (value_type (val_args[i]));
2334  struct type *wctype = lookup_typename (current_language, gdbarch,
2335  "wchar_t", NULL, 0);
2336  struct type *valtype;
2337  struct obstack output;
2338  struct cleanup *inner_cleanup;
2339  const gdb_byte *bytes;
2340 
2341  valtype = value_type (val_args[i]);
2342  if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2343  || TYPE_CODE (valtype) != TYPE_CODE_INT)
2344  error (_("expected wchar_t argument for %%lc"));
2345 
2346  bytes = value_contents (val_args[i]);
2347 
2348  obstack_init (&output);
2349  inner_cleanup = make_cleanup_obstack_free (&output);
2350 
2352  host_charset (),
2353  bytes, TYPE_LENGTH (valtype),
2354  TYPE_LENGTH (valtype),
2355  &output, translit_char);
2356  obstack_grow_str0 (&output, "");
2357 
2358  fprintf_filtered (stream, current_substring,
2359  obstack_base (&output));
2360  do_cleanups (inner_cleanup);
2361  }
2362  break;
2363  case double_arg:
2364  {
2365  struct type *type = value_type (val_args[i]);
2366  DOUBLEST val;
2367  int inv;
2368 
2369  /* If format string wants a float, unchecked-convert the value
2370  to floating point of the same size. */
2371  type = float_type_from_length (type);
2372  val = unpack_double (type, value_contents (val_args[i]), &inv);
2373  if (inv)
2374  error (_("Invalid floating value found in program."));
2375 
2376  fprintf_filtered (stream, current_substring, (double) val);
2377  break;
2378  }
2379  case long_double_arg:
2380 #ifdef HAVE_LONG_DOUBLE
2381  {
2382  struct type *type = value_type (val_args[i]);
2383  DOUBLEST val;
2384  int inv;
2385 
2386  /* If format string wants a float, unchecked-convert the value
2387  to floating point of the same size. */
2388  type = float_type_from_length (type);
2389  val = unpack_double (type, value_contents (val_args[i]), &inv);
2390  if (inv)
2391  error (_("Invalid floating value found in program."));
2392 
2393  fprintf_filtered (stream, current_substring,
2394  (long double) val);
2395  break;
2396  }
2397 #else
2398  error (_("long double not supported in printf"));
2399 #endif
2400  case long_long_arg:
2401 #ifdef PRINTF_HAS_LONG_LONG
2402  {
2403  long long val = value_as_long (val_args[i]);
2404 
2405  fprintf_filtered (stream, current_substring, val);
2406  break;
2407  }
2408 #else
2409  error (_("long long not supported in printf"));
2410 #endif
2411  case int_arg:
2412  {
2413  int val = value_as_long (val_args[i]);
2414 
2415  fprintf_filtered (stream, current_substring, val);
2416  break;
2417  }
2418  case long_arg:
2419  {
2420  long val = value_as_long (val_args[i]);
2421 
2422  fprintf_filtered (stream, current_substring, val);
2423  break;
2424  }
2425  /* Handles decimal floating values. */
2426  case decfloat_arg:
2427  printf_decfloat (stream, current_substring, val_args[i]);
2428  break;
2429  case ptr_arg:
2430  printf_pointer (stream, current_substring, val_args[i]);
2431  break;
2432  case literal_piece:
2433  /* Print a portion of the format string that has no
2434  directives. Note that this will not include any
2435  ordinary %-specs, but it might include "%%". That is
2436  why we use printf_filtered and not puts_filtered here.
2437  Also, we pass a dummy argument because some platforms
2438  have modified GCC to include -Wformat-security by
2439  default, which will warn here if there is no
2440  argument. */
2441  fprintf_filtered (stream, current_substring, 0);
2442  break;
2443  default:
2444  internal_error (__FILE__, __LINE__,
2445  _("failed internal consistency check"));
2446  }
2447  /* Maybe advance to the next argument. */
2448  if (fpieces[fr].argclass != literal_piece)
2449  ++i;
2450  }
2451  }
2452  do_cleanups (old_cleanups);
2453 }
2454 
2455 /* Implement the "printf" command. */
2456 
2457 static void
2458 printf_command (char *arg, int from_tty)
2459 {
2460  ui_printf (arg, gdb_stdout);
2462 }
2463 
2464 /* Implement the "eval" command. */
2465 
2466 static void
2467 eval_command (char *arg, int from_tty)
2468 {
2469  struct ui_file *ui_out = mem_fileopen ();
2470  struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
2471  char *expanded;
2472 
2473  ui_printf (arg, ui_out);
2474 
2475  expanded = ui_file_xstrdup (ui_out, NULL);
2476  make_cleanup (xfree, expanded);
2477 
2478  execute_command (expanded, from_tty);
2479 
2480  do_cleanups (cleanups);
2481 }
2482 
2483 void
2485 {
2486  struct cmd_list_element *c;
2487 
2488  current_display_number = -1;
2489 
2491 
2492  add_info ("address", address_info,
2493  _("Describe where symbol SYM is stored."));
2494 
2495  add_info ("symbol", sym_info, _("\
2496 Describe what symbol is at location ADDR.\n\
2497 Only for symbols with fixed locations (global or static scope)."));
2498 
2499  add_com ("x", class_vars, x_command, _("\
2500 Examine memory: x/FMT ADDRESS.\n\
2501 ADDRESS is an expression for the memory address to examine.\n\
2502 FMT is a repeat count followed by a format letter and a size letter.\n\
2503 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2504  t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2505  and z(hex, zero padded on the left).\n\
2506 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2507 The specified number of objects of the specified size are printed\n\
2508 according to the format.\n\n\
2509 Defaults for format and size letters are those previously used.\n\
2510 Default count is 1. Default address is following last thing printed\n\
2511 with this command or \"print\"."));
2512 
2513 #if 0
2514  add_com ("whereis", class_vars, whereis_command,
2515  _("Print line number and file of definition of variable."));
2516 #endif
2517 
2518  add_info ("display", display_info, _("\
2519 Expressions to display when program stops, with code numbers."));
2520 
2521  add_cmd ("undisplay", class_vars, undisplay_command, _("\
2522 Cancel some expressions to be displayed when program stops.\n\
2523 Arguments are the code numbers of the expressions to stop displaying.\n\
2524 No argument means cancel all automatic-display expressions.\n\
2525 \"delete display\" has the same effect as this command.\n\
2526 Do \"info display\" to see current list of code numbers."),
2527  &cmdlist);
2528 
2529  add_com ("display", class_vars, display_command, _("\
2530 Print value of expression EXP each time the program stops.\n\
2531 /FMT may be used before EXP as in the \"print\" command.\n\
2532 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2533 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2534 and examining is done as in the \"x\" command.\n\n\
2535 With no argument, display all currently requested auto-display expressions.\n\
2536 Use \"undisplay\" to cancel display requests previously made."));
2537 
2538  add_cmd ("display", class_vars, enable_display_command, _("\
2539 Enable some expressions to be displayed when program stops.\n\
2540 Arguments are the code numbers of the expressions to resume displaying.\n\
2541 No argument means enable all automatic-display expressions.\n\
2542 Do \"info display\" to see current list of code numbers."), &enablelist);
2543 
2544  add_cmd ("display", class_vars, disable_display_command, _("\
2545 Disable some expressions to be displayed when program stops.\n\
2546 Arguments are the code numbers of the expressions to stop displaying.\n\
2547 No argument means disable all automatic-display expressions.\n\
2548 Do \"info display\" to see current list of code numbers."), &disablelist);
2549 
2550  add_cmd ("display", class_vars, undisplay_command, _("\
2551 Cancel some expressions to be displayed when program stops.\n\
2552 Arguments are the code numbers of the expressions to stop displaying.\n\
2553 No argument means cancel all automatic-display expressions.\n\
2554 Do \"info display\" to see current list of code numbers."), &deletelist);
2555 
2556  add_com ("printf", class_vars, printf_command, _("\
2557 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2558 This is useful for formatted output in user-defined commands."));
2559 
2560  add_com ("output", class_vars, output_command, _("\
2561 Like \"print\" but don't put in value history and don't print newline.\n\
2562 This is useful in user-defined commands."));
2563 
2564  add_prefix_cmd ("set", class_vars, set_command, _("\
2565 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2566 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2567 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2568 with $), a register (a few standard names starting with $), or an actual\n\
2569 variable in the program being debugged. EXP is any valid expression.\n\
2570 Use \"set variable\" for variables with names identical to set subcommands.\n\
2571 \n\
2572 With a subcommand, this command modifies parts of the gdb environment.\n\
2573 You can see these environment settings with the \"show\" command."),
2574  &setlist, "set ", 1, &cmdlist);
2575  if (dbx_commands)
2576  add_com ("assign", class_vars, set_command, _("\
2577 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2578 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2579 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2580 with $), a register (a few standard names starting with $), or an actual\n\
2581 variable in the program being debugged. EXP is any valid expression.\n\
2582 Use \"set variable\" for variables with names identical to set subcommands.\n\
2583 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2584 You can see these environment settings with the \"show\" command."));
2585 
2586  /* "call" is the same as "set", but handy for dbx users to call fns. */
2587  c = add_com ("call", class_vars, call_command, _("\
2588 Call a function in the program.\n\
2589 The argument is the function name and arguments, in the notation of the\n\
2590 current working language. The result is printed and saved in the value\n\
2591 history, if it is not void."));
2592  set_cmd_completer (c, expression_completer);
2593 
2594  add_cmd ("variable", class_vars, set_command, _("\
2595 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2596 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2597 example). VAR may be a debugger \"convenience\" variable (names starting\n\
2598 with $), a register (a few standard names starting with $), or an actual\n\
2599 variable in the program being debugged. EXP is any valid expression.\n\
2600 This may usually be abbreviated to simply \"set\"."),
2601  &setlist);
2602 
2603  c = add_com ("print", class_vars, print_command, _("\
2604 Print value of expression EXP.\n\
2605 Variables accessible are those of the lexical environment of the selected\n\
2606 stack frame, plus all those whose scope is global or an entire file.\n\
2607 \n\
2608 $NUM gets previous value number NUM. $ and $$ are the last two values.\n\
2609 $$NUM refers to NUM'th value back from the last one.\n\
2610 Names starting with $ refer to registers (with the values they would have\n\
2611 if the program were to return to the stack frame now selected, restoring\n\
2612 all registers saved by frames farther in) or else to debugger\n\
2613 \"convenience\" variables (any such name not a known register).\n\
2614 Use assignment expressions to give values to convenience variables.\n\
2615 \n\
2616 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2617 @ is a binary operator for treating consecutive data objects\n\
2618 anywhere in memory as an array. FOO@NUM gives an array whose first\n\
2619 element is FOO, whose second element is stored in the space following\n\
2620 where FOO is stored, etc. FOO must be an expression whose value\n\
2621 resides in memory.\n\
2622 \n\
2623 EXP may be preceded with /FMT, where FMT is a format letter\n\
2624 but no count or size letter (see \"x\" command)."));
2625  set_cmd_completer (c, expression_completer);
2626  add_com_alias ("p", "print", class_vars, 1);
2627  add_com_alias ("inspect", "print", class_vars, 1);
2628 
2629  add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2630  &max_symbolic_offset, _("\
2631 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2632 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2633 Tell GDB to only display the symbolic form of an address if the\n\
2634 offset between the closest earlier symbol and the address is less than\n\
2635 the specified maximum offset. The default is \"unlimited\", which tells GDB\n\
2636 to always print the symbolic form of an address if any symbol precedes\n\
2637 it. Zero is equivalent to \"unlimited\"."),
2638  NULL,
2641  add_setshow_boolean_cmd ("symbol-filename", no_class,
2642  &print_symbol_filename, _("\
2643 Set printing of source filename and line number with <symbol>."), _("\
2644 Show printing of source filename and line number with <symbol>."), NULL,
2645  NULL,
2648 
2649  add_com ("eval", no_class, eval_command, _("\
2650 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2651 a command line, and call it."));
2652 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
void do_displays(void)
Definition: printcmd.c:1819
void val_print_scalar_formatted(struct type *type, const gdb_byte *valaddr, int embedded_offset, const struct value *val, const struct value_print_options *options, int size, struct ui_file *stream)
Definition: valprint.c:960
union exp_element elts[1]
Definition: expression.h:85
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1171
unsigned char raw
Definition: valprint.h:228
struct type * builtin_declong
Definition: gdbtypes.h:1501
static void output_command(char *exp, int from_tty)
Definition: printcmd.c:1028
struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section(CORE_ADDR pc, struct obj_section *section)
Definition: minsyms.c:779
int decimal_from_string(gdb_byte *decbytes, int len, enum bfd_endian byte_order, const char *string)
Definition: dfp.c:174
void fprintf_symbol_filtered(struct ui_file *stream, const char *name, enum language lang, int arg_mode)
Definition: utils.c:2477
int dbx_commands
Definition: main.c:54
int exp_uses_objfile(struct expression *exp, struct objfile *objfile)
Definition: parse.c:1912
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
char * exp_string
Definition: printcmd.c:119
struct observer * observer_attach_free_objfile(observer_free_objfile_ftype *f)
struct type * builtin_long_double
Definition: gdbtypes.h:1492
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:870
struct type * builtin_true_unsigned_char
Definition: gdbtypes.h:1508
enum exp_opcode opcode
Definition: expression.h:65
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
static void printf_pointer(struct ui_file *stream, const char *format, struct value *value)
Definition: printcmd.c:2183
void _initialize_printcmd(void)
Definition: printcmd.c:2484
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct display * next
Definition: printcmd.c:116
void disable_display(int num)
Definition: printcmd.c:1831
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
static struct cleanup * cleanup_chain
Definition: cleanups.c:63
struct cmd_list_element * enablelist
Definition: cli-cmds.c:111
int pointer_type(struct type *type)
Definition: language.c:392
static void set_command(char *exp, int from_tty)
Definition: printcmd.c:1076
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:3089
CORE_ADDR unpack_pointer(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2914
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void warning(const char *fmt,...)
Definition: errors.c:26
static void call_command(char *exp, int from_tty)
Definition: printcmd.c:1020
struct type ** const(pascal_builtin_types[])
int query(const char *ctlstr,...)
Definition: utils.c:1364
static int branch_delay_insns
Definition: printcmd.c:70
struct program_space * pspace
Definition: objfiles.h:286
void decimal_convert(const gdb_byte *from, int len_from, enum bfd_endian byte_order_from, gdb_byte *to, int len_to, enum bfd_endian byte_order_to)
Definition: dfp.c:371
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
struct symbol * find_pc_sect_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:136
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
argclass
Definition: format.h:33
static void printf_wide_c_string(struct ui_file *stream, const char *format, struct value *value)
Definition: printcmd.c:2049
static void x_command(char *exp, int from_tty)
Definition: printcmd.c:1417
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:146
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:846
void disable_current_display(void)
Definition: printcmd.c:1845
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define obj_section_endaddr(s)
Definition: objfiles.h:141
static void printf_c_string(struct ui_file *stream, const char *format, struct value *value)
Definition: printcmd.c:2015
int get_frame_pc_if_available(struct frame_info *frame, CORE_ADDR *pc)
Definition: frame.c:2224
struct cmd_list_element * deletelist
Definition: cli-cmds.c:123
void print_floating(const gdb_byte *valaddr, struct type *type, struct ui_file *stream)
Definition: valprint.c:1074
char * string
Definition: format.h:47
void annotate_value_history_value(void)
Definition: annotate.c:331
#define MAX_DECIMAL_STRING
Definition: dfp.h:30
struct value * coerce_ref(struct value *arg)
Definition: value.c:3688
void value_free(struct value *val)
Definition: value.c:1518
static CORE_ADDR last_examine_address
Definition: printcmd.c:74
#define ALL_OBJSECTIONS(objfile, osect)
Definition: objfiles.h:660
const struct block * block
Definition: printcmd.c:134
void print_scalar_formatted(const void *valaddr, struct type *type, const struct value_print_options *options, int size, struct ui_file *stream)
Definition: printcmd.c:349
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
static int display_number
Definition: printcmd.c:145
struct gdbarch * symbol_arch(const struct symbol *symbol)
Definition: symtab.c:6240
const struct block * innermost_block
Definition: parse.c:69
void decimal_to_string(const gdb_byte *decbytes, int len, enum bfd_endian byte_order, char *s)
Definition: dfp.c:146
struct program_space * pspace
Definition: printcmd.c:131
enum language la_language
Definition: language.h:152
DOUBLEST unpack_double(struct type *type, const gdb_byte *valaddr, int *invp)
Definition: value.c:2847
void clear_displays(void)
Definition: printcmd.c:1567
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:103
void print_decimal_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1371
void print_variable_and_value(const char *name, struct symbol *var, struct frame_info *frame, struct ui_file *stream, int indent)
Definition: printcmd.c:1977
struct internalvar * lookup_internalvar(const char *name)
Definition: value.c:2131
#define _(String)
Definition: gdb_locale.h:40
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1173
static void show_max_symbolic_offset(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: printcmd.c:86
void execute_command(char *, int)
Definition: top.c:388
#define BLOCK_START(bl)
Definition: block.h:116
#define bits(obj, st, fn)
const char * pc_prefix(CORE_ADDR addr)
Definition: printcmd.c:752
void annotate_display_value(void)
Definition: annotate.c:387
#define END_CATCH
static char last_format
Definition: printcmd.c:57
#define VALUE_LVAL(val)
Definition: value.h:411
Definition: ui-out.c:99
int number
Definition: printcmd.c:125
void free_format_pieces_cleanup(void *ptr)
Definition: format.c:383
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:6231
struct type * builtin_int32
Definition: gdbtypes.h:1518
void printf_filtered(const char *format,...)
Definition: utils.c:2388
struct type * builtin_char16
Definition: gdbtypes.h:1526
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static CORE_ADDR next_address
Definition: printcmd.c:66
#define SYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:189
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
#define obj_section_addr(s)
Definition: objfiles.h:135
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:402
static int print_symbol_filename
Definition: printcmd.c:97
void null_cleanup(void *arg)
Definition: cleanups.c:295
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:159
#define TRY
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:410
static void show_print_symbol_filename(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: printcmd.c:99
void annotate_value_end(void)
Definition: annotate.c:345
struct type * lookup_typename(const struct language_defn *language, struct gdbarch *gdbarch, const char *name, const struct block *block, int noerr)
Definition: gdbtypes.c:1404
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
struct format_piece * parse_format_string(const char **arg)
Definition: format.c:24
struct expression * exp
Definition: printcmd.c:122
void print_char_chars(struct ui_file *stream, struct type *type, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1535
struct type * builtin_decdouble
Definition: gdbtypes.h:1500
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
#define CATCH(EXCEPTION, MASK)
void convert_between_encodings(const char *from, const char *to, const gdb_byte *bytes, unsigned int num_bytes, int width, struct obstack *output, enum transliterations translit)
Definition: charset.c:476
int contained_in(const struct block *a, const struct block *b)
Definition: block.c:73
struct cleanup * make_cleanup_restore_integer(int *variable)
Definition: utils.c:292
struct type * builtin_char32
Definition: gdbtypes.h:1527
void print_value(struct value *val, const struct format_data *fmtp)
Definition: printcmd.c:962
static void do_one_display(struct display *)
Definition: printcmd.c:1669
static void address_info(char *exp, int from_tty)
Definition: printcmd.c:1196
static struct value * last_examine_value
Definition: printcmd.c:79
struct value * value_from_decfloat(struct type *type, const gdb_byte *dec)
Definition: value.c:3580
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
int value_lazy(struct value *value)
Definition: value.c:1305
int enabled_p
Definition: printcmd.c:137
#define UINT_MAX
Definition: defs.h:505
int asm_demangle
Definition: demangle.c:62
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
const char * target_wide_charset(struct gdbarch *gdbarch)
Definition: charset.c:415
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
static struct gdbarch * next_gdbarch
Definition: printcmd.c:65
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
void add_setshow_uinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:694
struct bound_minimal_symbol lookup_minimal_symbol_and_objfile(const char *name)
Definition: minsyms.c:881
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static void map_display_numbers(char *args, void(*function)(struct display *, void *), void *data)
Definition: printcmd.c:1604
static void do_delete_display(struct display *d, void *data)
Definition: printcmd.c:1642
int gdb_print_insn(struct gdbarch *gdbarch, CORE_ADDR memaddr, struct ui_file *stream, int *branch_delay_insns)
Definition: disasm.c:444
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:882
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
double DOUBLEST
Definition: doublest.h:24
static void delete_display(struct display *display)
Definition: printcmd.c:1581
void puts_filtered(const char *string)
Definition: utils.c:2428
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
struct type * builtin_int16
Definition: gdbtypes.h:1516
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
void free_current_contents(void *ptr)
Definition: utils.c:476
#define MSYMBOL_SIZE(msymbol)
Definition: symtab.h:374
void set_next_address(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: printcmd.c:534
#define SYMBOL_REGISTER_OPS(symbol)
Definition: symtab.h:803
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:801
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
Definition: format.h:36
void set_internalvar(struct internalvar *var, struct value *val)
Definition: value.c:2295
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
static void do_examine(struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: printcmd.c:792
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
static char last_size
Definition: printcmd.c:61
void annotate_display_end(void)
Definition: annotate.c:394
static void enable_display_command(char *args, int from_tty)
Definition: printcmd.c:1915
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
struct cmd_list_element * add_info(const char *name, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:857
#define enable()
Definition: ser-go32.c:239
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
char * n_spaces(int n)
Definition: utils.c:2442
static int current_display_number
Definition: printcmd.c:111
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
struct type * builtin_decfloat
Definition: gdbtypes.h:1499
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:951
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
#define ALL_DISPLAYS(B)
Definition: printcmd.c:151
void annotate_display_expression_end(void)
Definition: annotate.c:380
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:169
struct format_data format
Definition: printcmd.c:128
void print_binary_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1160
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
void wrap_here(char *indent)
Definition: utils.c:1930
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
int section_is_mapped(struct obj_section *osect)
Definition: symfile.c:3129
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
void * xmalloc(YYSIZE_T)
void print_octal_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1220
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
struct expression * parse_expression(const char *)
Definition: parse.c:1261
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2797
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
void annotate_display_expression(void)
Definition: annotate.c:373
Definition: block.h:60
struct type * type
Definition: symtab.h:1173
Definition: value.c:172
struct value * parse_to_comma_and_eval(const char **expp)
Definition: eval.c:141
struct cmd_list_element * disablelist
Definition: cli-cmds.c:115
#define SYMBOL_OBJFILE_OWNED(symbol)
Definition: symtab.h:794
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
char format
Definition: valprint.h:223
static void enable_disable_display_command(char *args, int from_tty, int enable)
Definition: printcmd.c:1898
char size
Definition: valprint.h:224
bfd_byte gdb_byte
Definition: common-types.h:38
static void undisplay_command(char *args, int from_tty)
Definition: printcmd.c:1650
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
const struct language_defn * current_language
Definition: language.c:85
static unsigned int max_symbolic_offset
Definition: printcmd.c:84
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1016
struct type * builtin_double
Definition: gdbtypes.h:1491
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3219
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
static void printf_command(char *arg, int from_tty)
Definition: printcmd.c:2458
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
static struct format_data decode_format(const char **string_ptr, int oformat, int osize)
Definition: printcmd.c:179
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void print_command_parse_format(const char **expp, const char *cmdname, struct format_data *fmtp)
Definition: printcmd.c:935
struct type * builtin_true_char
Definition: gdbtypes.h:1507
struct ui_file * gdb_stderr
Definition: main.c:72
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
struct minimal_symbol * minsym
Definition: minsyms.h:32
void annotate_display_format(void)
Definition: annotate.c:366
const char * symbol
Definition: signals.c:48
static void ui_printf(const char *arg, struct ui_file *stream)
Definition: printcmd.c:2247
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
void annotate_value_begin(struct type *type)
Definition: annotate.c:320
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
int offset
Definition: agent.c:65
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:335
struct objfile * objfile
Definition: objfiles.h:124
void annotate_value_history_end(void)
Definition: annotate.c:338
int line
Definition: symtab.h:1570
void clear_internalvar(struct internalvar *var)
Definition: value.c:2380
int print_address_demangle(const struct value_print_options *opts, struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream, int do_demangle)
Definition: printcmd.c:771
void annotate_display_begin(void)
Definition: annotate.c:352
static void eval_command(char *arg, int from_tty)
Definition: printcmd.c:2467
static void free_display(struct display *d)
Definition: printcmd.c:1556
#define MSYMBOL_HAS_SIZE(msymbol)
Definition: symtab.h:381
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:171
void annotate_display_number_end(void)
Definition: annotate.c:359
static struct type * float_type_from_length(struct type *type)
Definition: printcmd.c:329
int record_latest_value(struct value *val)
Definition: value.c:1788
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2230
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:3081
struct program_space * current_program_space
Definition: progspace.c:35
void annotate_value_history_begin(int histindex, struct type *type)
Definition: annotate.c:309
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
struct symtab_and_line find_pc_sect_line(CORE_ADDR pc, struct obj_section *section, int notcurrent)
Definition: symtab.c:3075
int value_embedded_offset(struct value *value)
Definition: value.c:1388
void release_value(struct value *val)
Definition: value.c:1603
static void validate_format(struct format_data fmt, const char *cmdname)
Definition: printcmd.c:919
struct gdbarch * gdbarch
Definition: expression.h:83
struct objfile * lookup_objfile_from_block(const struct block *block)
Definition: symtab.c:2228
#define ALL_DISPLAYS_SAFE(B, TMP)
Definition: printcmd.c:154
static void print_command_1(const char *exp, int voidprint)
Definition: printcmd.c:987
#define obstack_grow_str0(OBSTACK, STRING)
Definition: gdb_obstack.h:48
struct type * value_type(const struct value *value)
Definition: value.c:1021
CORE_ADDR addr
Definition: frame.c:119
struct type * builtin_int64
Definition: gdbtypes.h:1520
Definition: symtab.h:703
struct value * access_value_history(int num)
Definition: value.c:1834
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
static void display_info(char *ignore, int from_tty)
Definition: printcmd.c:1859
static void printf_decfloat(struct ui_file *stream, const char *format, struct value *value)
Definition: printcmd.c:2098
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3238
const char * host_charset(void)
Definition: charset.c:399
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int build_address_symbolic(struct gdbarch *gdbarch, CORE_ADDR addr, int do_demangle, char **name, int *offset, char **filename, int *line, int *unmapped)
Definition: printcmd.c:611
struct objfile * objfile
Definition: minsyms.h:37
#define HOST_CHAR_BIT
Definition: host-defs.h:40
void output_command_const(const char *exp, int from_tty)
Definition: printcmd.c:1036
int val_print_string(struct type *elttype, const char *encoding, CORE_ADDR addr, int len, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:2496
void * arg
Definition: cleanups.c:43
void dont_repeat(void)
Definition: top.c:582
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
#define QUIT
Definition: defs.h:160
struct cleanup * make_cleanup_obstack_free(struct obstack *obstack)
Definition: utils.c:225
struct type * builtin_int8
Definition: gdbtypes.h:1514
int get_number_or_range(struct get_number_or_range_state *state)
Definition: cli-utils.c:142
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
static void print_formatted(struct value *val, int size, const struct value_print_options *options, struct ui_file *stream)
Definition: printcmd.c:272
#define MULTI_OBJFILE_P()
Definition: objfiles.h:696
static void do_enable_disable_display(struct display *d, void *data)
Definition: printcmd.c:1889
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3165
enum bfd_endian byte_order
Definition: gdbarch.c:128
int has_stack_frames(void)
Definition: frame.c:1506
void error(const char *fmt,...)
Definition: errors.c:38
static void print_command(char *exp, int from_tty)
Definition: printcmd.c:1013
static void clear_dangling_display_expressions(struct objfile *objfile)
Definition: printcmd.c:1937
size_t size
Definition: go32-nat.c:242
int print_address_symbolic(struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream, int do_demangle, char *leadin)
Definition: printcmd.c:556
static void disable_display_command(char *args, int from_tty)
Definition: printcmd.c:1923
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
static void sym_info(char *arg, int from_tty)
Definition: printcmd.c:1103
static void display_command(char *arg, int from_tty)
Definition: printcmd.c:1504
void print_address(struct gdbarch *gdbarch, CORE_ADDR addr, struct ui_file *stream)
Definition: printcmd.c:741
long long LONGEST
Definition: common-types.h:52
void init_number_or_range(struct get_number_or_range_state *state, const char *string)
Definition: cli-utils.c:132
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
static struct display * display_chain
Definition: printcmd.c:143
Definition: format.h:36
struct type * builtin_float
Definition: gdbtypes.h:1490
void print_hex_chars(struct ui_file *stream, const gdb_byte *valaddr, unsigned len, enum bfd_endian byte_order)
Definition: valprint.c:1502
const ULONGEST const LONGEST len
Definition: target.h:309