gdb/printcmd.c

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