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