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