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