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