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