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