Fix PR/18564 - regression in showing __thread so extern variable
[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
1380             if (section
1381                 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1382               {
1383                 load_addr = MSYMBOL_VALUE_RAW_ADDRESS (msym.minsym);
1384                 printf_filtered (_("a thread-local variable at offset %s "
1385                                    "in the thread-local storage for `%s'"),
1386                                  paddress (gdbarch, load_addr),
1387                                  objfile_name (section->objfile));
1388               }
1389             else
1390               {
1391                 load_addr = BMSYMBOL_VALUE_ADDRESS (msym);
1392                 printf_filtered (_("static storage at address "));
1393                 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1394                 if (section_is_overlay (section))
1395                   {
1396                     load_addr = overlay_unmapped_address (load_addr, section);
1397                     printf_filtered (_(",\n -- loaded at "));
1398                     fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1399                     printf_filtered (_(" in overlay section %s"),
1400                                      section->the_bfd_section->name);
1401                   }
1402               }
1403           }
1404       }
1405       break;
1406
1407     case LOC_OPTIMIZED_OUT:
1408       printf_filtered (_("optimized out"));
1409       break;
1410
1411     default:
1412       printf_filtered (_("of unknown (botched) type"));
1413       break;
1414     }
1415   printf_filtered (".\n");
1416 }
1417 \f
1418
1419 static void
1420 x_command (char *exp, int from_tty)
1421 {
1422   struct expression *expr;
1423   struct format_data fmt;
1424   struct cleanup *old_chain;
1425   struct value *val;
1426
1427   fmt.format = last_format ? last_format : 'x';
1428   fmt.size = last_size;
1429   fmt.count = 1;
1430   fmt.raw = 0;
1431
1432   if (exp && *exp == '/')
1433     {
1434       const char *tmp = exp + 1;
1435
1436       fmt = decode_format (&tmp, last_format, last_size);
1437       exp = (char *) tmp;
1438     }
1439
1440   /* If we have an expression, evaluate it and use it as the address.  */
1441
1442   if (exp != 0 && *exp != 0)
1443     {
1444       expr = parse_expression (exp);
1445       /* Cause expression not to be there any more if this command is
1446          repeated with Newline.  But don't clobber a user-defined
1447          command's definition.  */
1448       if (from_tty)
1449         *exp = 0;
1450       old_chain = make_cleanup (free_current_contents, &expr);
1451       val = evaluate_expression (expr);
1452       if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1453         val = coerce_ref (val);
1454       /* In rvalue contexts, such as this, functions are coerced into
1455          pointers to functions.  This makes "x/i main" work.  */
1456       if (/* last_format == 'i'  && */ 
1457           TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1458            && VALUE_LVAL (val) == lval_memory)
1459         next_address = value_address (val);
1460       else
1461         next_address = value_as_address (val);
1462
1463       next_gdbarch = expr->gdbarch;
1464       do_cleanups (old_chain);
1465     }
1466
1467   if (!next_gdbarch)
1468     error_no_arg (_("starting display address"));
1469
1470   do_examine (fmt, next_gdbarch, next_address);
1471
1472   /* If the examine succeeds, we remember its size and format for next
1473      time.  Set last_size to 'b' for strings.  */
1474   if (fmt.format == 's')
1475     last_size = 'b';
1476   else
1477     last_size = fmt.size;
1478   last_format = fmt.format;
1479
1480   /* Set a couple of internal variables if appropriate.  */
1481   if (last_examine_value)
1482     {
1483       /* Make last address examined available to the user as $_.  Use
1484          the correct pointer type.  */
1485       struct type *pointer_type
1486         = lookup_pointer_type (value_type (last_examine_value));
1487       set_internalvar (lookup_internalvar ("_"),
1488                        value_from_pointer (pointer_type,
1489                                            last_examine_address));
1490
1491       /* Make contents of last address examined available to the user
1492          as $__.  If the last value has not been fetched from memory
1493          then don't fetch it now; instead mark it by voiding the $__
1494          variable.  */
1495       if (value_lazy (last_examine_value))
1496         clear_internalvar (lookup_internalvar ("__"));
1497       else
1498         set_internalvar (lookup_internalvar ("__"), last_examine_value);
1499     }
1500 }
1501 \f
1502
1503 /* Add an expression to the auto-display chain.
1504    Specify the expression.  */
1505
1506 static void
1507 display_command (char *arg, int from_tty)
1508 {
1509   struct format_data fmt;
1510   struct expression *expr;
1511   struct display *newobj;
1512   const char *exp = arg;
1513
1514   if (exp == 0)
1515     {
1516       do_displays ();
1517       return;
1518     }
1519
1520   if (*exp == '/')
1521     {
1522       exp++;
1523       fmt = decode_format (&exp, 0, 0);
1524       if (fmt.size && fmt.format == 0)
1525         fmt.format = 'x';
1526       if (fmt.format == 'i' || fmt.format == 's')
1527         fmt.size = 'b';
1528     }
1529   else
1530     {
1531       fmt.format = 0;
1532       fmt.size = 0;
1533       fmt.count = 0;
1534       fmt.raw = 0;
1535     }
1536
1537   innermost_block = NULL;
1538   expr = parse_expression (exp);
1539
1540   newobj = XNEW (struct display);
1541
1542   newobj->exp_string = xstrdup (exp);
1543   newobj->exp = expr;
1544   newobj->block = innermost_block;
1545   newobj->pspace = current_program_space;
1546   newobj->next = display_chain;
1547   newobj->number = ++display_number;
1548   newobj->format = fmt;
1549   newobj->enabled_p = 1;
1550   display_chain = newobj;
1551
1552   if (from_tty)
1553     do_one_display (newobj);
1554
1555   dont_repeat ();
1556 }
1557
1558 static void
1559 free_display (struct display *d)
1560 {
1561   xfree (d->exp_string);
1562   xfree (d->exp);
1563   xfree (d);
1564 }
1565
1566 /* Clear out the display_chain.  Done when new symtabs are loaded,
1567    since this invalidates the types stored in many expressions.  */
1568
1569 void
1570 clear_displays (void)
1571 {
1572   struct display *d;
1573
1574   while ((d = display_chain) != NULL)
1575     {
1576       display_chain = d->next;
1577       free_display (d);
1578     }
1579 }
1580
1581 /* Delete the auto-display DISPLAY.  */
1582
1583 static void
1584 delete_display (struct display *display)
1585 {
1586   struct display *d;
1587
1588   gdb_assert (display != NULL);
1589
1590   if (display_chain == display)
1591     display_chain = display->next;
1592
1593   ALL_DISPLAYS (d)
1594     if (d->next == display)
1595       {
1596         d->next = display->next;
1597         break;
1598       }
1599
1600   free_display (display);
1601 }
1602
1603 /* Call FUNCTION on each of the displays whose numbers are given in
1604    ARGS.  DATA is passed unmodified to FUNCTION.  */
1605
1606 static void
1607 map_display_numbers (char *args,
1608                      void (*function) (struct display *,
1609                                        void *),
1610                      void *data)
1611 {
1612   struct get_number_or_range_state state;
1613   int num;
1614
1615   if (args == NULL)
1616     error_no_arg (_("one or more display numbers"));
1617
1618   init_number_or_range (&state, args);
1619
1620   while (!state.finished)
1621     {
1622       const char *p = state.string;
1623
1624       num = get_number_or_range (&state);
1625       if (num == 0)
1626         warning (_("bad display number at or near '%s'"), p);
1627       else
1628         {
1629           struct display *d, *tmp;
1630
1631           ALL_DISPLAYS_SAFE (d, tmp)
1632             if (d->number == num)
1633               break;
1634           if (d == NULL)
1635             printf_unfiltered (_("No display number %d.\n"), num);
1636           else
1637             function (d, data);
1638         }
1639     }
1640 }
1641
1642 /* Callback for map_display_numbers, that deletes a display.  */
1643
1644 static void
1645 do_delete_display (struct display *d, void *data)
1646 {
1647   delete_display (d);
1648 }
1649
1650 /* "undisplay" command.  */
1651
1652 static void
1653 undisplay_command (char *args, int from_tty)
1654 {
1655   if (args == NULL)
1656     {
1657       if (query (_("Delete all auto-display expressions? ")))
1658         clear_displays ();
1659       dont_repeat ();
1660       return;
1661     }
1662
1663   map_display_numbers (args, do_delete_display, NULL);
1664   dont_repeat ();
1665 }
1666
1667 /* Display a single auto-display.  
1668    Do nothing if the display cannot be printed in the current context,
1669    or if the display is disabled.  */
1670
1671 static void
1672 do_one_display (struct display *d)
1673 {
1674   struct cleanup *old_chain;
1675   int within_current_scope;
1676
1677   if (d->enabled_p == 0)
1678     return;
1679
1680   /* The expression carries the architecture that was used at parse time.
1681      This is a problem if the expression depends on architecture features
1682      (e.g. register numbers), and the current architecture is now different.
1683      For example, a display statement like "display/i $pc" is expected to
1684      display the PC register of the current architecture, not the arch at
1685      the time the display command was given.  Therefore, we re-parse the
1686      expression if the current architecture has changed.  */
1687   if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1688     {
1689       xfree (d->exp);
1690       d->exp = NULL;
1691       d->block = NULL;
1692     }
1693
1694   if (d->exp == NULL)
1695     {
1696
1697       TRY
1698         {
1699           innermost_block = NULL;
1700           d->exp = parse_expression (d->exp_string);
1701           d->block = innermost_block;
1702         }
1703       CATCH (ex, RETURN_MASK_ALL)
1704         {
1705           /* Can't re-parse the expression.  Disable this display item.  */
1706           d->enabled_p = 0;
1707           warning (_("Unable to display \"%s\": %s"),
1708                    d->exp_string, ex.message);
1709           return;
1710         }
1711       END_CATCH
1712     }
1713
1714   if (d->block)
1715     {
1716       if (d->pspace == current_program_space)
1717         within_current_scope = contained_in (get_selected_block (0), d->block);
1718       else
1719         within_current_scope = 0;
1720     }
1721   else
1722     within_current_scope = 1;
1723   if (!within_current_scope)
1724     return;
1725
1726   old_chain = make_cleanup_restore_integer (&current_display_number);
1727   current_display_number = d->number;
1728
1729   annotate_display_begin ();
1730   printf_filtered ("%d", d->number);
1731   annotate_display_number_end ();
1732   printf_filtered (": ");
1733   if (d->format.size)
1734     {
1735
1736       annotate_display_format ();
1737
1738       printf_filtered ("x/");
1739       if (d->format.count != 1)
1740         printf_filtered ("%d", d->format.count);
1741       printf_filtered ("%c", d->format.format);
1742       if (d->format.format != 'i' && d->format.format != 's')
1743         printf_filtered ("%c", d->format.size);
1744       printf_filtered (" ");
1745
1746       annotate_display_expression ();
1747
1748       puts_filtered (d->exp_string);
1749       annotate_display_expression_end ();
1750
1751       if (d->format.count != 1 || d->format.format == 'i')
1752         printf_filtered ("\n");
1753       else
1754         printf_filtered ("  ");
1755
1756       annotate_display_value ();
1757
1758       TRY
1759         {
1760           struct value *val;
1761           CORE_ADDR addr;
1762
1763           val = evaluate_expression (d->exp);
1764           addr = value_as_address (val);
1765           if (d->format.format == 'i')
1766             addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1767           do_examine (d->format, d->exp->gdbarch, addr);
1768         }
1769       CATCH (ex, RETURN_MASK_ERROR)
1770         {
1771           fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
1772         }
1773       END_CATCH
1774     }
1775   else
1776     {
1777       struct value_print_options opts;
1778
1779       annotate_display_format ();
1780
1781       if (d->format.format)
1782         printf_filtered ("/%c ", d->format.format);
1783
1784       annotate_display_expression ();
1785
1786       puts_filtered (d->exp_string);
1787       annotate_display_expression_end ();
1788
1789       printf_filtered (" = ");
1790
1791       annotate_display_expression ();
1792
1793       get_formatted_print_options (&opts, d->format.format);
1794       opts.raw = d->format.raw;
1795
1796       TRY
1797         {
1798           struct value *val;
1799
1800           val = evaluate_expression (d->exp);
1801           print_formatted (val, d->format.size, &opts, gdb_stdout);
1802         }
1803       CATCH (ex, RETURN_MASK_ERROR)
1804         {
1805           fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1806         }
1807       END_CATCH
1808
1809       printf_filtered ("\n");
1810     }
1811
1812   annotate_display_end ();
1813
1814   gdb_flush (gdb_stdout);
1815   do_cleanups (old_chain);
1816 }
1817
1818 /* Display all of the values on the auto-display chain which can be
1819    evaluated in the current scope.  */
1820
1821 void
1822 do_displays (void)
1823 {
1824   struct display *d;
1825
1826   for (d = display_chain; d; d = d->next)
1827     do_one_display (d);
1828 }
1829
1830 /* Delete the auto-display which we were in the process of displaying.
1831    This is done when there is an error or a signal.  */
1832
1833 void
1834 disable_display (int num)
1835 {
1836   struct display *d;
1837
1838   for (d = display_chain; d; d = d->next)
1839     if (d->number == num)
1840       {
1841         d->enabled_p = 0;
1842         return;
1843       }
1844   printf_unfiltered (_("No display number %d.\n"), num);
1845 }
1846
1847 void
1848 disable_current_display (void)
1849 {
1850   if (current_display_number >= 0)
1851     {
1852       disable_display (current_display_number);
1853       fprintf_unfiltered (gdb_stderr,
1854                           _("Disabling display %d to "
1855                             "avoid infinite recursion.\n"),
1856                           current_display_number);
1857     }
1858   current_display_number = -1;
1859 }
1860
1861 static void
1862 display_info (char *ignore, int from_tty)
1863 {
1864   struct display *d;
1865
1866   if (!display_chain)
1867     printf_unfiltered (_("There are no auto-display expressions now.\n"));
1868   else
1869     printf_filtered (_("Auto-display expressions now in effect:\n\
1870 Num Enb Expression\n"));
1871
1872   for (d = display_chain; d; d = d->next)
1873     {
1874       printf_filtered ("%d:   %c  ", d->number, "ny"[(int) d->enabled_p]);
1875       if (d->format.size)
1876         printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1877                          d->format.format);
1878       else if (d->format.format)
1879         printf_filtered ("/%c ", d->format.format);
1880       puts_filtered (d->exp_string);
1881       if (d->block && !contained_in (get_selected_block (0), d->block))
1882         printf_filtered (_(" (cannot be evaluated in the current context)"));
1883       printf_filtered ("\n");
1884       gdb_flush (gdb_stdout);
1885     }
1886 }
1887
1888 /* Callback fo map_display_numbers, that enables or disables the
1889    passed in display D.  */
1890
1891 static void
1892 do_enable_disable_display (struct display *d, void *data)
1893 {
1894   d->enabled_p = *(int *) data;
1895 }
1896
1897 /* Implamentation of both the "disable display" and "enable display"
1898    commands.  ENABLE decides what to do.  */
1899
1900 static void
1901 enable_disable_display_command (char *args, int from_tty, int enable)
1902 {
1903   if (args == NULL)
1904     {
1905       struct display *d;
1906
1907       ALL_DISPLAYS (d)
1908         d->enabled_p = enable;
1909       return;
1910     }
1911
1912   map_display_numbers (args, do_enable_disable_display, &enable);
1913 }
1914
1915 /* The "enable display" command.  */
1916
1917 static void
1918 enable_display_command (char *args, int from_tty)
1919 {
1920   enable_disable_display_command (args, from_tty, 1);
1921 }
1922
1923 /* The "disable display" command.  */
1924
1925 static void
1926 disable_display_command (char *args, int from_tty)
1927 {
1928   enable_disable_display_command (args, from_tty, 0);
1929 }
1930
1931 /* display_chain items point to blocks and expressions.  Some expressions in
1932    turn may point to symbols.
1933    Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1934    obstack_free'd when a shared library is unloaded.
1935    Clear pointers that are about to become dangling.
1936    Both .exp and .block fields will be restored next time we need to display
1937    an item by re-parsing .exp_string field in the new execution context.  */
1938
1939 static void
1940 clear_dangling_display_expressions (struct objfile *objfile)
1941 {
1942   struct display *d;
1943   struct program_space *pspace;
1944
1945   /* With no symbol file we cannot have a block or expression from it.  */
1946   if (objfile == NULL)
1947     return;
1948   pspace = objfile->pspace;
1949   if (objfile->separate_debug_objfile_backlink)
1950     {
1951       objfile = objfile->separate_debug_objfile_backlink;
1952       gdb_assert (objfile->pspace == pspace);
1953     }
1954
1955   for (d = display_chain; d != NULL; d = d->next)
1956     {
1957       if (d->pspace != pspace)
1958         continue;
1959
1960       if (lookup_objfile_from_block (d->block) == objfile
1961           || (d->exp && exp_uses_objfile (d->exp, objfile)))
1962       {
1963         xfree (d->exp);
1964         d->exp = NULL;
1965         d->block = NULL;
1966       }
1967     }
1968 }
1969 \f
1970
1971 /* Print the value in stack frame FRAME of a variable specified by a
1972    struct symbol.  NAME is the name to print; if NULL then VAR's print
1973    name will be used.  STREAM is the ui_file on which to print the
1974    value.  INDENT specifies the number of indent levels to print
1975    before printing the variable name.
1976
1977    This function invalidates FRAME.  */
1978
1979 void
1980 print_variable_and_value (const char *name, struct symbol *var,
1981                           struct frame_info *frame,
1982                           struct ui_file *stream, int indent)
1983 {
1984
1985   if (!name)
1986     name = SYMBOL_PRINT_NAME (var);
1987
1988   fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
1989   TRY
1990     {
1991       struct value *val;
1992       struct value_print_options opts;
1993
1994       /* READ_VAR_VALUE needs a block in order to deal with non-local
1995          references (i.e. to handle nested functions).  In this context, we
1996          print variables that are local to this frame, so we can avoid passing
1997          a block to it.  */
1998       val = read_var_value (var, NULL, frame);
1999       get_user_print_options (&opts);
2000       opts.deref_ref = 1;
2001       common_val_print (val, stream, indent, &opts, current_language);
2002
2003       /* common_val_print invalidates FRAME when a pretty printer calls inferior
2004          function.  */
2005       frame = NULL;
2006     }
2007   CATCH (except, RETURN_MASK_ERROR)
2008     {
2009       fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
2010                        except.message);
2011     }
2012   END_CATCH
2013
2014   fprintf_filtered (stream, "\n");
2015 }
2016
2017 /* Subroutine of ui_printf to simplify it.
2018    Print VALUE to STREAM using FORMAT.
2019    VALUE is a C-style string on the target.  */
2020
2021 static void
2022 printf_c_string (struct ui_file *stream, const char *format,
2023                  struct value *value)
2024 {
2025   gdb_byte *str;
2026   CORE_ADDR tem;
2027   int j;
2028
2029   tem = value_as_address (value);
2030
2031   /* This is a %s argument.  Find the length of the string.  */
2032   for (j = 0;; j++)
2033     {
2034       gdb_byte c;
2035
2036       QUIT;
2037       read_memory (tem + j, &c, 1);
2038       if (c == 0)
2039         break;
2040     }
2041
2042   /* Copy the string contents into a string inside GDB.  */
2043   str = (gdb_byte *) alloca (j + 1);
2044   if (j != 0)
2045     read_memory (tem, str, j);
2046   str[j] = 0;
2047
2048   fprintf_filtered (stream, format, (char *) str);
2049 }
2050
2051 /* Subroutine of ui_printf to simplify it.
2052    Print VALUE to STREAM using FORMAT.
2053    VALUE is a wide C-style string on the target.  */
2054
2055 static void
2056 printf_wide_c_string (struct ui_file *stream, const char *format,
2057                       struct value *value)
2058 {
2059   gdb_byte *str;
2060   CORE_ADDR tem;
2061   int j;
2062   struct gdbarch *gdbarch = get_type_arch (value_type (value));
2063   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2064   struct type *wctype = lookup_typename (current_language, gdbarch,
2065                                          "wchar_t", NULL, 0);
2066   int wcwidth = TYPE_LENGTH (wctype);
2067   gdb_byte *buf = alloca (wcwidth);
2068   struct obstack output;
2069   struct cleanup *inner_cleanup;
2070
2071   tem = value_as_address (value);
2072
2073   /* This is a %s argument.  Find the length of the string.  */
2074   for (j = 0;; j += wcwidth)
2075     {
2076       QUIT;
2077       read_memory (tem + j, buf, wcwidth);
2078       if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2079         break;
2080     }
2081
2082   /* Copy the string contents into a string inside GDB.  */
2083   str = (gdb_byte *) alloca (j + wcwidth);
2084   if (j != 0)
2085     read_memory (tem, str, j);
2086   memset (&str[j], 0, wcwidth);
2087
2088   obstack_init (&output);
2089   inner_cleanup = make_cleanup_obstack_free (&output);
2090
2091   convert_between_encodings (target_wide_charset (gdbarch),
2092                              host_charset (),
2093                              str, j, wcwidth,
2094                              &output, translit_char);
2095   obstack_grow_str0 (&output, "");
2096
2097   fprintf_filtered (stream, format, obstack_base (&output));
2098   do_cleanups (inner_cleanup);
2099 }
2100
2101 /* Subroutine of ui_printf to simplify it.
2102    Print VALUE, a decimal floating point value, to STREAM using FORMAT.  */
2103
2104 static void
2105 printf_decfloat (struct ui_file *stream, const char *format,
2106                  struct value *value)
2107 {
2108   const gdb_byte *param_ptr = value_contents (value);
2109
2110 #if defined (PRINTF_HAS_DECFLOAT)
2111   /* If we have native support for Decimal floating
2112      printing, handle it here.  */
2113   fprintf_filtered (stream, format, param_ptr);
2114 #else
2115   /* As a workaround until vasprintf has native support for DFP
2116      we convert the DFP values to string and print them using
2117      the %s format specifier.  */
2118   const char *p;
2119
2120   /* Parameter data.  */
2121   struct type *param_type = value_type (value);
2122   struct gdbarch *gdbarch = get_type_arch (param_type);
2123   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2124
2125   /* DFP output data.  */
2126   struct value *dfp_value = NULL;
2127   gdb_byte *dfp_ptr;
2128   int dfp_len = 16;
2129   gdb_byte dec[16];
2130   struct type *dfp_type = NULL;
2131   char decstr[MAX_DECIMAL_STRING];
2132
2133   /* Points to the end of the string so that we can go back
2134      and check for DFP length modifiers.  */
2135   p = format + strlen (format);
2136
2137   /* Look for the float/double format specifier.  */
2138   while (*p != 'f' && *p != 'e' && *p != 'E'
2139          && *p != 'g' && *p != 'G')
2140     p--;
2141
2142   /* Search for the '%' char and extract the size and type of
2143      the output decimal value based on its modifiers
2144      (%Hf, %Df, %DDf).  */
2145   while (*--p != '%')
2146     {
2147       if (*p == 'H')
2148         {
2149           dfp_len = 4;
2150           dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2151         }
2152       else if (*p == 'D' && *(p - 1) == 'D')
2153         {
2154           dfp_len = 16;
2155           dfp_type = builtin_type (gdbarch)->builtin_declong;
2156           p--;
2157         }
2158       else
2159         {
2160           dfp_len = 8;
2161           dfp_type = builtin_type (gdbarch)->builtin_decdouble;
2162         }
2163     }
2164
2165   /* Conversion between different DFP types.  */
2166   if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2167     decimal_convert (param_ptr, TYPE_LENGTH (param_type),
2168                      byte_order, dec, dfp_len, byte_order);
2169   else
2170     /* If this is a non-trivial conversion, just output 0.
2171        A correct converted value can be displayed by explicitly
2172        casting to a DFP type.  */
2173     decimal_from_string (dec, dfp_len, byte_order, "0");
2174
2175   dfp_value = value_from_decfloat (dfp_type, dec);
2176
2177   dfp_ptr = (gdb_byte *) value_contents (dfp_value);
2178
2179   decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
2180
2181   /* Print the DFP value.  */
2182   fprintf_filtered (stream, "%s", decstr);
2183 #endif
2184 }
2185
2186 /* Subroutine of ui_printf to simplify it.
2187    Print VALUE, a target pointer, to STREAM using FORMAT.  */
2188
2189 static void
2190 printf_pointer (struct ui_file *stream, const char *format,
2191                 struct value *value)
2192 {
2193   /* We avoid the host's %p because pointers are too
2194      likely to be the wrong size.  The only interesting
2195      modifier for %p is a width; extract that, and then
2196      handle %p as glibc would: %#x or a literal "(nil)".  */
2197
2198   const char *p;
2199   char *fmt, *fmt_p;
2200 #ifdef PRINTF_HAS_LONG_LONG
2201   long long val = value_as_long (value);
2202 #else
2203   long val = value_as_long (value);
2204 #endif
2205
2206   fmt = alloca (strlen (format) + 5);
2207
2208   /* Copy up to the leading %.  */
2209   p = format;
2210   fmt_p = fmt;
2211   while (*p)
2212     {
2213       int is_percent = (*p == '%');
2214
2215       *fmt_p++ = *p++;
2216       if (is_percent)
2217         {
2218           if (*p == '%')
2219             *fmt_p++ = *p++;
2220           else
2221             break;
2222         }
2223     }
2224
2225   if (val != 0)
2226     *fmt_p++ = '#';
2227
2228   /* Copy any width.  */
2229   while (*p >= '0' && *p < '9')
2230     *fmt_p++ = *p++;
2231
2232   gdb_assert (*p == 'p' && *(p + 1) == '\0');
2233   if (val != 0)
2234     {
2235 #ifdef PRINTF_HAS_LONG_LONG
2236       *fmt_p++ = 'l';
2237 #endif
2238       *fmt_p++ = 'l';
2239       *fmt_p++ = 'x';
2240       *fmt_p++ = '\0';
2241       fprintf_filtered (stream, fmt, val);
2242     }
2243   else
2244     {
2245       *fmt_p++ = 's';
2246       *fmt_p++ = '\0';
2247       fprintf_filtered (stream, fmt, "(nil)");
2248     }
2249 }
2250
2251 /* printf "printf format string" ARG to STREAM.  */
2252
2253 static void
2254 ui_printf (const char *arg, struct ui_file *stream)
2255 {
2256   struct format_piece *fpieces;
2257   const char *s = arg;
2258   struct value **val_args;
2259   int allocated_args = 20;
2260   struct cleanup *old_cleanups;
2261
2262   val_args = XNEWVEC (struct value *, allocated_args);
2263   old_cleanups = make_cleanup (free_current_contents, &val_args);
2264
2265   if (s == 0)
2266     error_no_arg (_("format-control string and values to print"));
2267
2268   s = skip_spaces_const (s);
2269
2270   /* A format string should follow, enveloped in double quotes.  */
2271   if (*s++ != '"')
2272     error (_("Bad format string, missing '\"'."));
2273
2274   fpieces = parse_format_string (&s);
2275
2276   make_cleanup (free_format_pieces_cleanup, &fpieces);
2277
2278   if (*s++ != '"')
2279     error (_("Bad format string, non-terminated '\"'."));
2280   
2281   s = skip_spaces_const (s);
2282
2283   if (*s != ',' && *s != 0)
2284     error (_("Invalid argument syntax"));
2285
2286   if (*s == ',')
2287     s++;
2288   s = skip_spaces_const (s);
2289
2290   {
2291     int nargs = 0;
2292     int nargs_wanted;
2293     int i, fr;
2294     char *current_substring;
2295
2296     nargs_wanted = 0;
2297     for (fr = 0; fpieces[fr].string != NULL; fr++)
2298       if (fpieces[fr].argclass != literal_piece)
2299         ++nargs_wanted;
2300
2301     /* Now, parse all arguments and evaluate them.
2302        Store the VALUEs in VAL_ARGS.  */
2303
2304     while (*s != '\0')
2305       {
2306         const char *s1;
2307
2308         if (nargs == allocated_args)
2309           val_args = (struct value **) xrealloc ((char *) val_args,
2310                                                  (allocated_args *= 2)
2311                                                  * sizeof (struct value *));
2312         s1 = s;
2313         val_args[nargs] = parse_to_comma_and_eval (&s1);
2314
2315         nargs++;
2316         s = s1;
2317         if (*s == ',')
2318           s++;
2319       }
2320
2321     if (nargs != nargs_wanted)
2322       error (_("Wrong number of arguments for specified format-string"));
2323
2324     /* Now actually print them.  */
2325     i = 0;
2326     for (fr = 0; fpieces[fr].string != NULL; fr++)
2327       {
2328         current_substring = fpieces[fr].string;
2329         switch (fpieces[fr].argclass)
2330           {
2331           case string_arg:
2332             printf_c_string (stream, current_substring, val_args[i]);
2333             break;
2334           case wide_string_arg:
2335             printf_wide_c_string (stream, current_substring, val_args[i]);
2336             break;
2337           case wide_char_arg:
2338             {
2339               struct gdbarch *gdbarch
2340                 = get_type_arch (value_type (val_args[i]));
2341               struct type *wctype = lookup_typename (current_language, gdbarch,
2342                                                      "wchar_t", NULL, 0);
2343               struct type *valtype;
2344               struct obstack output;
2345               struct cleanup *inner_cleanup;
2346               const gdb_byte *bytes;
2347
2348               valtype = value_type (val_args[i]);
2349               if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2350                   || TYPE_CODE (valtype) != TYPE_CODE_INT)
2351                 error (_("expected wchar_t argument for %%lc"));
2352
2353               bytes = value_contents (val_args[i]);
2354
2355               obstack_init (&output);
2356               inner_cleanup = make_cleanup_obstack_free (&output);
2357
2358               convert_between_encodings (target_wide_charset (gdbarch),
2359                                          host_charset (),
2360                                          bytes, TYPE_LENGTH (valtype),
2361                                          TYPE_LENGTH (valtype),
2362                                          &output, translit_char);
2363               obstack_grow_str0 (&output, "");
2364
2365               fprintf_filtered (stream, current_substring,
2366                                 obstack_base (&output));
2367               do_cleanups (inner_cleanup);
2368             }
2369             break;
2370           case double_arg:
2371             {
2372               struct type *type = value_type (val_args[i]);
2373               DOUBLEST val;
2374               int inv;
2375
2376               /* If format string wants a float, unchecked-convert the value
2377                  to floating point of the same size.  */
2378               type = float_type_from_length (type);
2379               val = unpack_double (type, value_contents (val_args[i]), &inv);
2380               if (inv)
2381                 error (_("Invalid floating value found in program."));
2382
2383               fprintf_filtered (stream, current_substring, (double) val);
2384               break;
2385             }
2386           case long_double_arg:
2387 #ifdef HAVE_LONG_DOUBLE
2388             {
2389               struct type *type = value_type (val_args[i]);
2390               DOUBLEST val;
2391               int inv;
2392
2393               /* If format string wants a float, unchecked-convert the value
2394                  to floating point of the same size.  */
2395               type = float_type_from_length (type);
2396               val = unpack_double (type, value_contents (val_args[i]), &inv);
2397               if (inv)
2398                 error (_("Invalid floating value found in program."));
2399
2400               fprintf_filtered (stream, current_substring,
2401                                 (long double) val);
2402               break;
2403             }
2404 #else
2405             error (_("long double not supported in printf"));
2406 #endif
2407           case long_long_arg:
2408 #ifdef PRINTF_HAS_LONG_LONG
2409             {
2410               long long val = value_as_long (val_args[i]);
2411
2412               fprintf_filtered (stream, current_substring, val);
2413               break;
2414             }
2415 #else
2416             error (_("long long not supported in printf"));
2417 #endif
2418           case int_arg:
2419             {
2420               int val = value_as_long (val_args[i]);
2421
2422               fprintf_filtered (stream, current_substring, val);
2423               break;
2424             }
2425           case long_arg:
2426             {
2427               long val = value_as_long (val_args[i]);
2428
2429               fprintf_filtered (stream, current_substring, val);
2430               break;
2431             }
2432           /* Handles decimal floating values.  */
2433           case decfloat_arg:
2434             printf_decfloat (stream, current_substring, val_args[i]);
2435             break;
2436           case ptr_arg:
2437             printf_pointer (stream, current_substring, val_args[i]);
2438             break;
2439           case literal_piece:
2440             /* Print a portion of the format string that has no
2441                directives.  Note that this will not include any
2442                ordinary %-specs, but it might include "%%".  That is
2443                why we use printf_filtered and not puts_filtered here.
2444                Also, we pass a dummy argument because some platforms
2445                have modified GCC to include -Wformat-security by
2446                default, which will warn here if there is no
2447                argument.  */
2448             fprintf_filtered (stream, current_substring, 0);
2449             break;
2450           default:
2451             internal_error (__FILE__, __LINE__,
2452                             _("failed internal consistency check"));
2453           }
2454         /* Maybe advance to the next argument.  */
2455         if (fpieces[fr].argclass != literal_piece)
2456           ++i;
2457       }
2458   }
2459   do_cleanups (old_cleanups);
2460 }
2461
2462 /* Implement the "printf" command.  */
2463
2464 static void
2465 printf_command (char *arg, int from_tty)
2466 {
2467   ui_printf (arg, gdb_stdout);
2468   gdb_flush (gdb_stdout);
2469 }
2470
2471 /* Implement the "eval" command.  */
2472
2473 static void
2474 eval_command (char *arg, int from_tty)
2475 {
2476   struct ui_file *ui_out = mem_fileopen ();
2477   struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
2478   char *expanded;
2479
2480   ui_printf (arg, ui_out);
2481
2482   expanded = ui_file_xstrdup (ui_out, NULL);
2483   make_cleanup (xfree, expanded);
2484
2485   execute_command (expanded, from_tty);
2486
2487   do_cleanups (cleanups);
2488 }
2489
2490 void
2491 _initialize_printcmd (void)
2492 {
2493   struct cmd_list_element *c;
2494
2495   current_display_number = -1;
2496
2497   observer_attach_free_objfile (clear_dangling_display_expressions);
2498
2499   add_info ("address", address_info,
2500             _("Describe where symbol SYM is stored."));
2501
2502   add_info ("symbol", sym_info, _("\
2503 Describe what symbol is at location ADDR.\n\
2504 Only for symbols with fixed locations (global or static scope)."));
2505
2506   add_com ("x", class_vars, x_command, _("\
2507 Examine memory: x/FMT ADDRESS.\n\
2508 ADDRESS is an expression for the memory address to examine.\n\
2509 FMT is a repeat count followed by a format letter and a size letter.\n\
2510 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2511   t(binary), f(float), a(address), i(instruction), c(char), s(string)\n\
2512   and z(hex, zero padded on the left).\n\
2513 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2514 The specified number of objects of the specified size are printed\n\
2515 according to the format.\n\n\
2516 Defaults for format and size letters are those previously used.\n\
2517 Default count is 1.  Default address is following last thing printed\n\
2518 with this command or \"print\"."));
2519
2520 #if 0
2521   add_com ("whereis", class_vars, whereis_command,
2522            _("Print line number and file of definition of variable."));
2523 #endif
2524
2525   add_info ("display", display_info, _("\
2526 Expressions to display when program stops, with code numbers."));
2527
2528   add_cmd ("undisplay", class_vars, undisplay_command, _("\
2529 Cancel some expressions to be displayed when program stops.\n\
2530 Arguments are the code numbers of the expressions to stop displaying.\n\
2531 No argument means cancel all automatic-display expressions.\n\
2532 \"delete display\" has the same effect as this command.\n\
2533 Do \"info display\" to see current list of code numbers."),
2534            &cmdlist);
2535
2536   add_com ("display", class_vars, display_command, _("\
2537 Print value of expression EXP each time the program stops.\n\
2538 /FMT may be used before EXP as in the \"print\" command.\n\
2539 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2540 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2541 and examining is done as in the \"x\" command.\n\n\
2542 With no argument, display all currently requested auto-display expressions.\n\
2543 Use \"undisplay\" to cancel display requests previously made."));
2544
2545   add_cmd ("display", class_vars, enable_display_command, _("\
2546 Enable some expressions to be displayed when program stops.\n\
2547 Arguments are the code numbers of the expressions to resume displaying.\n\
2548 No argument means enable all automatic-display expressions.\n\
2549 Do \"info display\" to see current list of code numbers."), &enablelist);
2550
2551   add_cmd ("display", class_vars, disable_display_command, _("\
2552 Disable some expressions to be displayed when program stops.\n\
2553 Arguments are the code numbers of the expressions to stop displaying.\n\
2554 No argument means disable all automatic-display expressions.\n\
2555 Do \"info display\" to see current list of code numbers."), &disablelist);
2556
2557   add_cmd ("display", class_vars, undisplay_command, _("\
2558 Cancel some expressions to be displayed when program stops.\n\
2559 Arguments are the code numbers of the expressions to stop displaying.\n\
2560 No argument means cancel all automatic-display expressions.\n\
2561 Do \"info display\" to see current list of code numbers."), &deletelist);
2562
2563   add_com ("printf", class_vars, printf_command, _("\
2564 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2565 This is useful for formatted output in user-defined commands."));
2566
2567   add_com ("output", class_vars, output_command, _("\
2568 Like \"print\" but don't put in value history and don't print newline.\n\
2569 This is useful in user-defined commands."));
2570
2571   add_prefix_cmd ("set", class_vars, set_command, _("\
2572 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2573 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2574 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2575 with $), a register (a few standard names starting with $), or an actual\n\
2576 variable in the program being debugged.  EXP is any valid expression.\n\
2577 Use \"set variable\" for variables with names identical to set subcommands.\n\
2578 \n\
2579 With a subcommand, this command modifies parts of the gdb environment.\n\
2580 You can see these environment settings with the \"show\" command."),
2581                   &setlist, "set ", 1, &cmdlist);
2582   if (dbx_commands)
2583     add_com ("assign", class_vars, set_command, _("\
2584 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2585 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2586 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2587 with $), a register (a few standard names starting with $), or an actual\n\
2588 variable in the program being debugged.  EXP is any valid expression.\n\
2589 Use \"set variable\" for variables with names identical to set subcommands.\n\
2590 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2591 You can see these environment settings with the \"show\" command."));
2592
2593   /* "call" is the same as "set", but handy for dbx users to call fns.  */
2594   c = add_com ("call", class_vars, call_command, _("\
2595 Call a function in the program.\n\
2596 The argument is the function name and arguments, in the notation of the\n\
2597 current working language.  The result is printed and saved in the value\n\
2598 history, if it is not void."));
2599   set_cmd_completer (c, expression_completer);
2600
2601   add_cmd ("variable", class_vars, set_command, _("\
2602 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2603 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2604 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2605 with $), a register (a few standard names starting with $), or an actual\n\
2606 variable in the program being debugged.  EXP is any valid expression.\n\
2607 This may usually be abbreviated to simply \"set\"."),
2608            &setlist);
2609
2610   c = add_com ("print", class_vars, print_command, _("\
2611 Print value of expression EXP.\n\
2612 Variables accessible are those of the lexical environment of the selected\n\
2613 stack frame, plus all those whose scope is global or an entire file.\n\
2614 \n\
2615 $NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
2616 $$NUM refers to NUM'th value back from the last one.\n\
2617 Names starting with $ refer to registers (with the values they would have\n\
2618 if the program were to return to the stack frame now selected, restoring\n\
2619 all registers saved by frames farther in) or else to debugger\n\
2620 \"convenience\" variables (any such name not a known register).\n\
2621 Use assignment expressions to give values to convenience variables.\n\
2622 \n\
2623 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2624 @ is a binary operator for treating consecutive data objects\n\
2625 anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
2626 element is FOO, whose second element is stored in the space following\n\
2627 where FOO is stored, etc.  FOO must be an expression whose value\n\
2628 resides in memory.\n\
2629 \n\
2630 EXP may be preceded with /FMT, where FMT is a format letter\n\
2631 but no count or size letter (see \"x\" command)."));
2632   set_cmd_completer (c, expression_completer);
2633   add_com_alias ("p", "print", class_vars, 1);
2634   add_com_alias ("inspect", "print", class_vars, 1);
2635
2636   add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2637                             &max_symbolic_offset, _("\
2638 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2639 Show the largest offset that will be printed in <symbol+1234> form."), _("\
2640 Tell GDB to only display the symbolic form of an address if the\n\
2641 offset between the closest earlier symbol and the address is less than\n\
2642 the specified maximum offset.  The default is \"unlimited\", which tells GDB\n\
2643 to always print the symbolic form of an address if any symbol precedes\n\
2644 it.  Zero is equivalent to \"unlimited\"."),
2645                             NULL,
2646                             show_max_symbolic_offset,
2647                             &setprintlist, &showprintlist);
2648   add_setshow_boolean_cmd ("symbol-filename", no_class,
2649                            &print_symbol_filename, _("\
2650 Set printing of source filename and line number with <symbol>."), _("\
2651 Show printing of source filename and line number with <symbol>."), NULL,
2652                            NULL,
2653                            show_print_symbol_filename,
2654                            &setprintlist, &showprintlist);
2655
2656   add_com ("eval", no_class, eval_command, _("\
2657 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2658 a command line, and call it."));
2659 }