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