contrib/gdb-7/gdb/printcmd.c

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