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 (const struct value_print_options *opts,
 771                         struct gdbarch *gdbarch, CORE_ADDR addr,
 772                         struct ui_file *stream, int do_demangle)
 773 {
 774   if (opts->addressprint)
 775     {
 776       fputs_filtered (paddress (gdbarch, addr), stream);
 777       print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");
 778     }
 779   else
 780     {
 781       print_address_symbolic (gdbarch, addr, stream, do_demangle, "");
 782     }
 783 }
 784 \f
 785
 786 /* Examine data at address ADDR in format FMT.
 787    Fetch it from memory and print on gdb_stdout.  */
 788
 789 static void
 790 do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)
 791 {
 792   char format = 0;
 793   char size;
 794   int count = 1;
 795   struct type *val_type = NULL;
 796   int i;
 797   int maxelts;
 798   struct value_print_options opts;
 799
 800   format = fmt.format;
 801   size = fmt.size;
 802   count = fmt.count;
 803   next_gdbarch = gdbarch;
 804   next_address = addr;
 805
 806   /* Instruction format implies fetch single bytes
 807      regardless of the specified size.
 808      The case of strings is handled in decode_format, only explicit
 809      size operator are not changed to 'b'.  */
 810   if (format == 'i')
 811     size = 'b';
 812
 813   if (size == 'a')
 814     {
 815       /* Pick the appropriate size for an address.  */
 816       if (gdbarch_ptr_bit (next_gdbarch) == 64)
 817         size = 'g';
 818       else if (gdbarch_ptr_bit (next_gdbarch) == 32)
 819         size = 'w';
 820       else if (gdbarch_ptr_bit (next_gdbarch) == 16)
 821         size = 'h';
 822       else
 823         /* Bad value for gdbarch_ptr_bit.  */
 824         internal_error (__FILE__, __LINE__,
 825                         _("failed internal consistency check"));
 826     }
 827
 828   if (size == 'b')
 829     val_type = builtin_type (next_gdbarch)->builtin_int8;
 830   else if (size == 'h')
 831     val_type = builtin_type (next_gdbarch)->builtin_int16;
 832   else if (size == 'w')
 833     val_type = builtin_type (next_gdbarch)->builtin_int32;
 834   else if (size == 'g')
 835     val_type = builtin_type (next_gdbarch)->builtin_int64;
 836
 837   if (format == 's')
 838     {
 839       struct type *char_type = NULL;
 840
 841       /* Search for "char16_t"  or "char32_t" types or fall back to 8-bit char
 842          if type is not found.  */
 843       if (size == 'h')
 844         char_type = builtin_type (next_gdbarch)->builtin_char16;
 845       else if (size == 'w')
 846         char_type = builtin_type (next_gdbarch)->builtin_char32;
 847       if (char_type)
 848         val_type = char_type;
 849       else
 850         {
 851           if (size != '\0' && size != 'b')
 852             warning (_("Unable to display strings with "
 853                        "size '%c', using 'b' instead."), size);
 854           size = 'b';
 855           val_type = builtin_type (next_gdbarch)->builtin_int8;
 856         }
 857     }
 858
 859   maxelts = 8;
 860   if (size == 'w')
 861     maxelts = 4;
 862   if (size == 'g')
 863     maxelts = 2;
 864   if (format == 's' || format == 'i')
 865     maxelts = 1;
 866
 867   get_formatted_print_options (&opts, format);
 868
 869   /* Print as many objects as specified in COUNT, at most maxelts per line,
 870      with the address of the next one at the start of each line.  */
 871
 872   while (count > 0)
 873     {
 874       QUIT;
 875       if (format == 'i')
 876         fputs_filtered (pc_prefix (next_address), gdb_stdout);
 877       print_address (next_gdbarch, next_address, gdb_stdout);
 878       printf_filtered (":");
 879       for (i = maxelts;
 880            i > 0 && count > 0;
 881            i--, count--)
 882         {
 883           printf_filtered ("\t");
 884           /* Note that print_formatted sets next_address for the next
 885              object.  */
 886           last_examine_address = next_address;
 887
 888           if (last_examine_value)
 889             value_free (last_examine_value);
 890
 891           /* The value to be displayed is not fetched greedily.
 892              Instead, to avoid the possibility of a fetched value not
 893              being used, its retrieval is delayed until the print code
 894              uses it.  When examining an instruction stream, the
 895              disassembler will perform its own memory fetch using just
 896              the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
 897              the disassembler be modified so that LAST_EXAMINE_VALUE
 898              is left with the byte sequence from the last complete
 899              instruction fetched from memory?  */
 900           last_examine_value = value_at_lazy (val_type, next_address);
 901
 902           if (last_examine_value)
 903             release_value (last_examine_value);
 904
 905           print_formatted (last_examine_value, size, &opts, gdb_stdout);
 906
 907           /* Display any branch delay slots following the final insn.  */
 908           if (format == 'i' && count == 1)
 909             count += branch_delay_insns;
 910         }
 911       printf_filtered ("\n");
 912       gdb_flush (gdb_stdout);
 913     }
 914 }
 915 \f
 916 static void
 917 validate_format (struct format_data fmt, char *cmdname)
 918 {
 919   if (fmt.size != 0)
 920     error (_("Size letters are meaningless in \"%s\" command."), cmdname);
 921   if (fmt.count != 1)
 922     error (_("Item count other than 1 is meaningless in \"%s\" command."),
 923            cmdname);
 924   if (fmt.format == 'i')
 925     error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
 926            fmt.format, cmdname);
 927 }
 928
 929 /* Evaluate string EXP as an expression in the current language and
 930    print the resulting value.  EXP may contain a format specifier as the
 931    first argument ("/x myvar" for example, to print myvar in hex).  */
 932
 933 static void
 934 print_command_1 (char *exp, int inspect, int voidprint)
 935 {
 936   struct expression *expr;
 937   struct cleanup *old_chain = 0;
 938   char format = 0;
 939   struct value *val;
 940   struct format_data fmt;
 941   int cleanup = 0;
 942
 943   if (exp && *exp == '/')
 944     {
 945       exp++;
 946       fmt = decode_format (&exp, last_format, 0);
 947       validate_format (fmt, "print");
 948       last_format = format = fmt.format;
 949     }
 950   else
 951     {
 952       fmt.count = 1;
 953       fmt.format = 0;
 954       fmt.size = 0;
 955       fmt.raw = 0;
 956     }
 957
 958   if (exp && *exp)
 959     {
 960       expr = parse_expression (exp);
 961       old_chain = make_cleanup (free_current_contents, &expr);
 962       cleanup = 1;
 963       val = evaluate_expression (expr);
 964     }
 965   else
 966     val = access_value_history (0);
 967
 968   if (voidprint || (val && value_type (val) &&
 969                     TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
 970     {
 971       struct value_print_options opts;
 972       int histindex = record_latest_value (val);
 973
 974       if (histindex >= 0)
 975         annotate_value_history_begin (histindex, value_type (val));
 976       else
 977         annotate_value_begin (value_type (val));
 978
 979       if (inspect)
 980         printf_unfiltered ("\031(gdb-makebuffer \"%s\"  %d '(\"",
 981                            exp, histindex);
 982       else if (histindex >= 0)
 983         printf_filtered ("$%d = ", histindex);
 984
 985       if (histindex >= 0)
 986         annotate_value_history_value ();
 987
 988       get_formatted_print_options (&opts, format);
 989       opts.inspect_it = inspect;
 990       opts.raw = fmt.raw;
 991
 992       print_formatted (val, fmt.size, &opts, gdb_stdout);
 993       printf_filtered ("\n");
 994
 995       if (histindex >= 0)
 996         annotate_value_history_end ();
 997       else
 998         annotate_value_end ();
 999
1000       if (inspect)
1001         printf_unfiltered ("\") )\030");
1002     }
1003
1004   if (cleanup)
1005     do_cleanups (old_chain);
1006 }
1007
1008 static void
1009 print_command (char *exp, int from_tty)
1010 {
1011   print_command_1 (exp, 0, 1);
1012 }
1013
1014 /* Same as print, except in epoch, it gets its own window.  */
1015 static void
1016 inspect_command (char *exp, int from_tty)
1017 {
1018   extern int epoch_interface;
1019
1020   print_command_1 (exp, epoch_interface, 1);
1021 }
1022
1023 /* Same as print, except it doesn't print void results.  */
1024 static void
1025 call_command (char *exp, int from_tty)
1026 {
1027   print_command_1 (exp, 0, 0);
1028 }
1029
1030 void
1031 output_command (char *exp, int from_tty)
1032 {
1033   struct expression *expr;
1034   struct cleanup *old_chain;
1035   char format = 0;
1036   struct value *val;
1037   struct format_data fmt;
1038   struct value_print_options opts;
1039
1040   fmt.size = 0;
1041   fmt.raw = 0;
1042
1043   if (exp && *exp == '/')
1044     {
1045       exp++;
1046       fmt = decode_format (&exp, 0, 0);
1047       validate_format (fmt, "output");
1048       format = fmt.format;
1049     }
1050
1051   expr = parse_expression (exp);
1052   old_chain = make_cleanup (free_current_contents, &expr);
1053
1054   val = evaluate_expression (expr);
1055
1056   annotate_value_begin (value_type (val));
1057
1058   get_formatted_print_options (&opts, format);
1059   opts.raw = fmt.raw;
1060   print_formatted (val, fmt.size, &opts, gdb_stdout);
1061
1062   annotate_value_end ();
1063
1064   wrap_here ("");
1065   gdb_flush (gdb_stdout);
1066
1067   do_cleanups (old_chain);
1068 }
1069
1070 static void
1071 set_command (char *exp, int from_tty)
1072 {
1073   struct expression *expr = parse_expression (exp);
1074   struct cleanup *old_chain =
1075     make_cleanup (free_current_contents, &expr);
1076
1077   if (expr->nelts >= 1)
1078     switch (expr->elts[0].opcode)
1079       {
1080       case UNOP_PREINCREMENT:
1081       case UNOP_POSTINCREMENT:
1082       case UNOP_PREDECREMENT:
1083       case UNOP_POSTDECREMENT:
1084       case BINOP_ASSIGN:
1085       case BINOP_ASSIGN_MODIFY:
1086       case BINOP_COMMA:
1087         break;
1088       default:
1089         warning
1090           (_("Expression is not an assignment (and might have no effect)"));
1091       }
1092
1093   evaluate_expression (expr);
1094   do_cleanups (old_chain);
1095 }
1096
1097 static void
1098 sym_info (char *arg, int from_tty)
1099 {
1100   struct minimal_symbol *msymbol;
1101   struct objfile *objfile;
1102   struct obj_section *osect;
1103   CORE_ADDR addr, sect_addr;
1104   int matches = 0;
1105   unsigned int offset;
1106
1107   if (!arg)
1108     error_no_arg (_("address"));
1109
1110   addr = parse_and_eval_address (arg);
1111   ALL_OBJSECTIONS (objfile, osect)
1112   {
1113     /* Only process each object file once, even if there's a separate
1114        debug file.  */
1115     if (objfile->separate_debug_objfile_backlink)
1116       continue;
1117
1118     sect_addr = overlay_mapped_address (addr, osect);
1119
1120     if (obj_section_addr (osect) <= sect_addr
1121         && sect_addr < obj_section_endaddr (osect)
1122         && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
1123       {
1124         const char *obj_name, *mapped, *sec_name, *msym_name;
1125         char *loc_string;
1126         struct cleanup *old_chain;
1127
1128         matches = 1;
1129         offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
1130         mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
1131         sec_name = osect->the_bfd_section->name;
1132         msym_name = SYMBOL_PRINT_NAME (msymbol);
1133
1134         /* Don't print the offset if it is zero.
1135            We assume there's no need to handle i18n of "sym + offset".  */
1136         if (offset)
1137           loc_string = xstrprintf ("%s + %u", msym_name, offset);
1138         else
1139           loc_string = xstrprintf ("%s", msym_name);
1140
1141         /* Use a cleanup to free loc_string in case the user quits
1142            a pagination request inside printf_filtered.  */
1143         old_chain = make_cleanup (xfree, loc_string);
1144
1145         gdb_assert (osect->objfile && osect->objfile->name);
1146         obj_name = osect->objfile->name;
1147
1148         if (MULTI_OBJFILE_P ())
1149           if (pc_in_unmapped_range (addr, osect))
1150             if (section_is_overlay (osect))
1151               printf_filtered (_("%s in load address range of "
1152                                  "%s overlay section %s of %s\n"),
1153                                loc_string, mapped, sec_name, obj_name);
1154             else
1155               printf_filtered (_("%s in load address range of "
1156                                  "section %s of %s\n"),
1157                                loc_string, sec_name, obj_name);
1158           else
1159             if (section_is_overlay (osect))
1160               printf_filtered (_("%s in %s overlay section %s of %s\n"),
1161                                loc_string, mapped, sec_name, obj_name);
1162             else
1163               printf_filtered (_("%s in section %s of %s\n"),
1164                                loc_string, sec_name, obj_name);
1165         else
1166           if (pc_in_unmapped_range (addr, osect))
1167             if (section_is_overlay (osect))
1168               printf_filtered (_("%s in load address range of %s overlay "
1169                                  "section %s\n"),
1170                                loc_string, mapped, sec_name);
1171             else
1172               printf_filtered (_("%s in load address range of section %s\n"),
1173                                loc_string, sec_name);
1174           else
1175             if (section_is_overlay (osect))
1176               printf_filtered (_("%s in %s overlay section %s\n"),
1177                                loc_string, mapped, sec_name);
1178             else
1179               printf_filtered (_("%s in section %s\n"),
1180                                loc_string, sec_name);
1181
1182         do_cleanups (old_chain);
1183       }
1184   }
1185   if (matches == 0)
1186     printf_filtered (_("No symbol matches %s.\n"), arg);
1187 }
1188
1189 static void
1190 address_info (char *exp, int from_tty)
1191 {
1192   struct gdbarch *gdbarch;
1193   int regno;
1194   struct symbol *sym;
1195   struct minimal_symbol *msymbol;
1196   long val;
1197   struct obj_section *section;
1198   CORE_ADDR load_addr, context_pc = 0;
1199   int is_a_field_of_this;       /* C++: lookup_symbol sets this to nonzero
1200                                    if exp is a field of `this'.  */
1201
1202   if (exp == 0)
1203     error (_("Argument required."));
1204
1205   sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,
1206                        &is_a_field_of_this);
1207   if (sym == NULL)
1208     {
1209       if (is_a_field_of_this)
1210         {
1211           printf_filtered ("Symbol \"");
1212           fprintf_symbol_filtered (gdb_stdout, exp,
1213                                    current_language->la_language, DMGL_ANSI);
1214           printf_filtered ("\" is a field of the local class variable ");
1215           if (current_language->la_language == language_objc)
1216             printf_filtered ("`self'\n");       /* ObjC equivalent of "this" */
1217           else
1218             printf_filtered ("`this'\n");
1219           return;
1220         }
1221
1222       msymbol = lookup_minimal_symbol (exp, NULL, NULL);
1223
1224       if (msymbol != NULL)
1225         {
1226           gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
1227           load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1228
1229           printf_filtered ("Symbol \"");
1230           fprintf_symbol_filtered (gdb_stdout, exp,
1231                                    current_language->la_language, DMGL_ANSI);
1232           printf_filtered ("\" is at ");
1233           fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1234           printf_filtered (" in a file compiled without debugging");
1235           section = SYMBOL_OBJ_SECTION (msymbol);
1236           if (section_is_overlay (section))
1237             {
1238               load_addr = overlay_unmapped_address (load_addr, section);
1239               printf_filtered (",\n -- loaded at ");
1240               fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1241               printf_filtered (" in overlay section %s",
1242                                section->the_bfd_section->name);
1243             }
1244           printf_filtered (".\n");
1245         }
1246       else
1247         error (_("No symbol \"%s\" in current context."), exp);
1248       return;
1249     }
1250
1251   printf_filtered ("Symbol \"");
1252   fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
1253                            current_language->la_language, DMGL_ANSI);
1254   printf_filtered ("\" is ");
1255   val = SYMBOL_VALUE (sym);
1256   section = SYMBOL_OBJ_SECTION (sym);
1257   gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
1258
1259   switch (SYMBOL_CLASS (sym))
1260     {
1261     case LOC_CONST:
1262     case LOC_CONST_BYTES:
1263       printf_filtered ("constant");
1264       break;
1265
1266     case LOC_LABEL:
1267       printf_filtered ("a label at address ");
1268       load_addr = SYMBOL_VALUE_ADDRESS (sym);
1269       fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1270       if (section_is_overlay (section))
1271         {
1272           load_addr = overlay_unmapped_address (load_addr, section);
1273           printf_filtered (",\n -- loaded at ");
1274           fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1275           printf_filtered (" in overlay section %s",
1276                            section->the_bfd_section->name);
1277         }
1278       break;
1279
1280     case LOC_COMPUTED:
1281       /* FIXME: cagney/2004-01-26: It should be possible to
1282          unconditionally call the SYMBOL_COMPUTED_OPS method when available.
1283          Unfortunately DWARF 2 stores the frame-base (instead of the
1284          function) location in a function's symbol.  Oops!  For the
1285          moment enable this when/where applicable.  */
1286       SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
1287                                                     gdb_stdout);
1288       break;
1289
1290     case LOC_REGISTER:
1291       /* GDBARCH is the architecture associated with the objfile the symbol
1292          is defined in; the target architecture may be different, and may
1293          provide additional registers.  However, we do not know the target
1294          architecture at this point.  We assume the objfile architecture
1295          will contain all the standard registers that occur in debug info
1296          in that objfile.  */
1297       regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1298
1299       if (SYMBOL_IS_ARGUMENT (sym))
1300         printf_filtered (_("an argument in register %s"),
1301                          gdbarch_register_name (gdbarch, regno));
1302       else
1303         printf_filtered (_("a variable in register %s"),
1304                          gdbarch_register_name (gdbarch, regno));
1305       break;
1306
1307     case LOC_STATIC:
1308       printf_filtered (_("static storage at address "));
1309       load_addr = SYMBOL_VALUE_ADDRESS (sym);
1310       fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1311       if (section_is_overlay (section))
1312         {
1313           load_addr = overlay_unmapped_address (load_addr, section);
1314           printf_filtered (_(",\n -- loaded at "));
1315           fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1316           printf_filtered (_(" in overlay section %s"),
1317                            section->the_bfd_section->name);
1318         }
1319       break;
1320
1321     case LOC_REGPARM_ADDR:
1322       /* Note comment at LOC_REGISTER.  */
1323       regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1324       printf_filtered (_("address of an argument in register %s"),
1325                        gdbarch_register_name (gdbarch, regno));
1326       break;
1327
1328     case LOC_ARG:
1329       printf_filtered (_("an argument at offset %ld"), val);
1330       break;
1331
1332     case LOC_LOCAL:
1333       printf_filtered (_("a local variable at frame offset %ld"), val);
1334       break;
1335
1336     case LOC_REF_ARG:
1337       printf_filtered (_("a reference argument at offset %ld"), val);
1338       break;
1339
1340     case LOC_TYPEDEF:
1341       printf_filtered (_("a typedef"));
1342       break;
1343
1344     case LOC_BLOCK:
1345       printf_filtered (_("a function at address "));
1346       load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
1347       fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1348       if (section_is_overlay (section))
1349         {
1350           load_addr = overlay_unmapped_address (load_addr, section);
1351           printf_filtered (_(",\n -- loaded at "));
1352           fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1353           printf_filtered (_(" in overlay section %s"),
1354                            section->the_bfd_section->name);
1355         }
1356       break;
1357
1358     case LOC_UNRESOLVED:
1359       {
1360         struct minimal_symbol *msym;
1361
1362         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
1363         if (msym == NULL)
1364           printf_filtered ("unresolved");
1365         else
1366           {
1367             section = SYMBOL_OBJ_SECTION (msym);
1368             load_addr = SYMBOL_VALUE_ADDRESS (msym);
1369
1370             if (section
1371                 && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
1372               printf_filtered (_("a thread-local variable at offset %s "
1373                                  "in the thread-local storage for `%s'"),
1374                                paddress (gdbarch, load_addr),
1375                                section->objfile->name);
1376             else
1377               {
1378                 printf_filtered (_("static storage at address "));
1379                 fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1380                 if (section_is_overlay (section))
1381                   {
1382                     load_addr = overlay_unmapped_address (load_addr, section);
1383                     printf_filtered (_(",\n -- loaded at "));
1384                     fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
1385                     printf_filtered (_(" in overlay section %s"),
1386                                      section->the_bfd_section->name);
1387                   }
1388               }
1389           }
1390       }
1391       break;
1392
1393     case LOC_OPTIMIZED_OUT:
1394       printf_filtered (_("optimized out"));
1395       break;
1396
1397     default:
1398       printf_filtered (_("of unknown (botched) type"));
1399       break;
1400     }
1401   printf_filtered (".\n");
1402 }
1403 \f
1404
1405 static void
1406 x_command (char *exp, int from_tty)
1407 {
1408   struct expression *expr;
1409   struct format_data fmt;
1410   struct cleanup *old_chain;
1411   struct value *val;
1412
1413   fmt.format = last_format ? last_format : 'x';
1414   fmt.size = last_size;
1415   fmt.count = 1;
1416   fmt.raw = 0;
1417
1418   if (exp && *exp == '/')
1419     {
1420       exp++;
1421       fmt = decode_format (&exp, last_format, last_size);
1422     }
1423
1424   /* If we have an expression, evaluate it and use it as the address.  */
1425
1426   if (exp != 0 && *exp != 0)
1427     {
1428       expr = parse_expression (exp);
1429       /* Cause expression not to be there any more if this command is
1430          repeated with Newline.  But don't clobber a user-defined
1431          command's definition.  */
1432       if (from_tty)
1433         *exp = 0;
1434       old_chain = make_cleanup (free_current_contents, &expr);
1435       val = evaluate_expression (expr);
1436       if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
1437         val = coerce_ref (val);
1438       /* In rvalue contexts, such as this, functions are coerced into
1439          pointers to functions.  This makes "x/i main" work.  */
1440       if (/* last_format == 'i'  && */
1441           TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
1442            && VALUE_LVAL (val) == lval_memory)
1443         next_address = value_address (val);
1444       else
1445         next_address = value_as_address (val);
1446
1447       next_gdbarch = expr->gdbarch;
1448       do_cleanups (old_chain);
1449     }
1450
1451   if (!next_gdbarch)
1452     error_no_arg (_("starting display address"));
1453
1454   do_examine (fmt, next_gdbarch, next_address);
1455
1456   /* If the examine succeeds, we remember its size and format for next
1457      time.  Set last_size to 'b' for strings.  */
1458   if (fmt.format == 's')
1459     last_size = 'b';
1460   else
1461     last_size = fmt.size;
1462   last_format = fmt.format;
1463
1464   /* Set a couple of internal variables if appropriate.  */
1465   if (last_examine_value)
1466     {
1467       /* Make last address examined available to the user as $_.  Use
1468          the correct pointer type.  */
1469       struct type *pointer_type
1470         = lookup_pointer_type (value_type (last_examine_value));
1471       set_internalvar (lookup_internalvar ("_"),
1472                        value_from_pointer (pointer_type,
1473                                            last_examine_address));
1474
1475       /* Make contents of last address examined available to the user
1476          as $__.  If the last value has not been fetched from memory
1477          then don't fetch it now; instead mark it by voiding the $__
1478          variable.  */
1479       if (value_lazy (last_examine_value))
1480         clear_internalvar (lookup_internalvar ("__"));
1481       else
1482         set_internalvar (lookup_internalvar ("__"), last_examine_value);
1483     }
1484 }
1485 \f
1486
1487 /* Add an expression to the auto-display chain.
1488    Specify the expression.  */
1489
1490 static void
1491 display_command (char *exp, int from_tty)
1492 {
1493   struct format_data fmt;
1494   struct expression *expr;
1495   struct display *new;
1496   int display_it = 1;
1497
1498 #if defined(TUI)
1499   /* NOTE: cagney/2003-02-13 The `tui_active' was previously
1500      `tui_version'.  */
1501   if (tui_active && exp != NULL && *exp == '$')
1502     display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
1503 #endif
1504
1505   if (display_it)
1506     {
1507       if (exp == 0)
1508         {
1509           do_displays ();
1510           return;
1511         }
1512
1513       if (*exp == '/')
1514         {
1515           exp++;
1516           fmt = decode_format (&exp, 0, 0);
1517           if (fmt.size && fmt.format == 0)
1518             fmt.format = 'x';
1519           if (fmt.format == 'i' || fmt.format == 's')
1520             fmt.size = 'b';
1521         }
1522       else
1523         {
1524           fmt.format = 0;
1525           fmt.size = 0;
1526           fmt.count = 0;
1527           fmt.raw = 0;
1528         }
1529
1530       innermost_block = NULL;
1531       expr = parse_expression (exp);
1532
1533       new = (struct display *) xmalloc (sizeof (struct display));
1534
1535       new->exp_string = xstrdup (exp);
1536       new->exp = expr;
1537       new->block = innermost_block;
1538       new->pspace = current_program_space;
1539       new->next = display_chain;
1540       new->number = ++display_number;
1541       new->format = fmt;
1542       new->enabled_p = 1;
1543       display_chain = new;
1544
1545       if (from_tty && target_has_execution)
1546         do_one_display (new);
1547
1548       dont_repeat ();
1549     }
1550 }
1551
1552 static void
1553 free_display (struct display *d)
1554 {
1555   xfree (d->exp_string);
1556   xfree (d->exp);
1557   xfree (d);
1558 }
1559
1560 /* Clear out the display_chain.  Done when new symtabs are loaded,
1561    since this invalidates the types stored in many expressions.  */
1562
1563 void
1564 clear_displays (void)
1565 {
1566   struct display *d;
1567
1568   while ((d = display_chain) != NULL)
1569     {
1570       display_chain = d->next;
1571       free_display (d);
1572     }
1573 }
1574
1575 /* Delete the auto-display DISPLAY.  */
1576
1577 static void
1578 delete_display (struct display *display)
1579 {
1580   struct display *d;
1581
1582   gdb_assert (display != NULL);
1583
1584   if (display_chain == display)
1585     display_chain = display->next;
1586
1587   ALL_DISPLAYS (d)
1588     if (d->next == display)
1589       {
1590         d->next = display->next;
1591         break;
1592       }
1593
1594   free_display (display);
1595 }
1596
1597 /* Call FUNCTION on each of the displays whose numbers are given in
1598    ARGS.  DATA is passed unmodified to FUNCTION.  */
1599
1600 static void
1601 map_display_numbers (char *args,
1602                      void (*function) (struct display *,
1603                                        void *),
1604                      void *data)
1605 {
1606   struct get_number_or_range_state state;
1607   struct display *b, *tmp;
1608   int num;
1609
1610   if (args == NULL)
1611     error_no_arg (_("one or more display numbers"));
1612
1613   init_number_or_range (&state, args);
1614
1615   while (!state.finished)
1616     {
1617       char *p = state.string;
1618
1619       num = get_number_or_range (&state);
1620       if (num == 0)
1621         warning (_("bad display number at or near '%s'"), p);
1622       else
1623         {
1624           struct display *d, *tmp;
1625
1626           ALL_DISPLAYS_SAFE (d, tmp)
1627             if (d->number == num)
1628               break;
1629           if (d == NULL)
1630             printf_unfiltered (_("No display number %d.\n"), num);
1631           else
1632             function (d, data);
1633         }
1634     }
1635 }
1636
1637 /* Callback for map_display_numbers, that deletes a display.  */
1638
1639 static void
1640 do_delete_display (struct display *d, void *data)
1641 {
1642   delete_display (d);
1643 }
1644
1645 /* "undisplay" command.  */
1646
1647 static void
1648 undisplay_command (char *args, int from_tty)
1649 {
1650   int num;
1651   struct get_number_or_range_state state;
1652
1653   if (args == NULL)
1654     {
1655       if (query (_("Delete all auto-display expressions? ")))
1656         clear_displays ();
1657       dont_repeat ();
1658       return;
1659     }
1660
1661   map_display_numbers (args, do_delete_display, NULL);
1662   dont_repeat ();
1663 }
1664
1665 /* Display a single auto-display.
1666    Do nothing if the display cannot be printed in the current context,
1667    or if the display is disabled.  */
1668
1669 static void
1670 do_one_display (struct display *d)
1671 {
1672   struct cleanup *old_chain;
1673   int within_current_scope;
1674
1675   if (d->enabled_p == 0)
1676     return;
1677
1678   /* The expression carries the architecture that was used at parse time.
1679      This is a problem if the expression depends on architecture features
1680      (e.g. register numbers), and the current architecture is now different.
1681      For example, a display statement like "display/i $pc" is expected to
1682      display the PC register of the current architecture, not the arch at
1683      the time the display command was given.  Therefore, we re-parse the
1684      expression if the current architecture has changed.  */
1685   if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
1686     {
1687       xfree (d->exp);
1688       d->exp = NULL;
1689       d->block = NULL;
1690     }
1691
1692   if (d->exp == NULL)
1693     {
1694       volatile struct gdb_exception ex;
1695
1696       TRY_CATCH (ex, RETURN_MASK_ALL)
1697         {
1698           innermost_block = NULL;
1699           d->exp = parse_expression (d->exp_string);
1700           d->block = innermost_block;
1701         }
1702       if (ex.reason < 0)
1703         {
1704           /* Can't re-parse the expression.  Disable this display item.  */
1705           d->enabled_p = 0;
1706           warning (_("Unable to display \"%s\": %s"),
1707                    d->exp_string, ex.message);
1708           return;
1709         }
1710     }
1711
1712   if (d->block)
1713     {
1714       if (d->pspace == current_program_space)
1715         within_current_scope = contained_in (get_selected_block (0), d->block);
1716       else
1717         within_current_scope = 0;
1718     }
1719   else
1720     within_current_scope = 1;
1721   if (!within_current_scope)
1722     return;
1723
1724   old_chain = make_cleanup_restore_integer (&current_display_number);
1725   current_display_number = d->number;
1726
1727   annotate_display_begin ();
1728   printf_filtered ("%d", d->number);
1729   annotate_display_number_end ();
1730   printf_filtered (": ");
1731   if (d->format.size)
1732     {
1733       volatile struct gdb_exception ex;
1734
1735       annotate_display_format ();
1736
1737       printf_filtered ("x/");
1738       if (d->format.count != 1)
1739         printf_filtered ("%d", d->format.count);
1740       printf_filtered ("%c", d->format.format);
1741       if (d->format.format != 'i' && d->format.format != 's')
1742         printf_filtered ("%c", d->format.size);
1743       printf_filtered (" ");
1744
1745       annotate_display_expression ();
1746
1747       puts_filtered (d->exp_string);
1748       annotate_display_expression_end ();
1749
1750       if (d->format.count != 1 || d->format.format == 'i')
1751         printf_filtered ("\n");
1752       else
1753         printf_filtered ("  ");
1754
1755       annotate_display_value ();
1756
1757       TRY_CATCH (ex, RETURN_MASK_ERROR)
1758         {
1759           struct value *val;
1760           CORE_ADDR addr;
1761
1762           val = evaluate_expression (d->exp);
1763           addr = value_as_address (val);
1764           if (d->format.format == 'i')
1765             addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
1766           do_examine (d->format, d->exp->gdbarch, addr);
1767         }
1768       if (ex.reason < 0)
1769         fprintf_filtered (gdb_stdout, _("<error: %s>\n"), ex.message);
1770     }
1771   else
1772     {
1773       struct value_print_options opts;
1774       volatile struct gdb_exception ex;
1775
1776       annotate_display_format ();
1777
1778       if (d->format.format)
1779         printf_filtered ("/%c ", d->format.format);
1780
1781       annotate_display_expression ();
1782
1783       puts_filtered (d->exp_string);
1784       annotate_display_expression_end ();
1785
1786       printf_filtered (" = ");
1787
1788       annotate_display_expression ();
1789
1790       get_formatted_print_options (&opts, d->format.format);
1791       opts.raw = d->format.raw;
1792
1793       TRY_CATCH (ex, RETURN_MASK_ERROR)
1794         {
1795           struct value *val;
1796
1797           val = evaluate_expression (d->exp);
1798           print_formatted (val, d->format.size, &opts, gdb_stdout);
1799         }
1800       if (ex.reason < 0)
1801         fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1802       printf_filtered ("\n");
1803     }
1804
1805   annotate_display_end ();
1806
1807   gdb_flush (gdb_stdout);
1808   do_cleanups (old_chain);
1809 }
1810
1811 /* Display all of the values on the auto-display chain which can be
1812    evaluated in the current scope.  */
1813
1814 void
1815 do_displays (void)
1816 {
1817   struct display *d;
1818
1819   for (d = display_chain; d; d = d->next)
1820     do_one_display (d);
1821 }
1822
1823 /* Delete the auto-display which we were in the process of displaying.
1824    This is done when there is an error or a signal.  */
1825
1826 void
1827 disable_display (int num)
1828 {
1829   struct display *d;
1830
1831   for (d = display_chain; d; d = d->next)
1832     if (d->number == num)
1833       {
1834         d->enabled_p = 0;
1835         return;
1836       }
1837   printf_unfiltered (_("No display number %d.\n"), num);
1838 }
1839
1840 void
1841 disable_current_display (void)
1842 {
1843   if (current_display_number >= 0)
1844     {
1845       disable_display (current_display_number);
1846       fprintf_unfiltered (gdb_stderr,
1847                           _("Disabling display %d to "
1848                             "avoid infinite recursion.\n"),
1849                           current_display_number);
1850     }
1851   current_display_number = -1;
1852 }
1853
1854 static void
1855 display_info (char *ignore, int from_tty)
1856 {
1857   struct display *d;
1858
1859   if (!display_chain)
1860     printf_unfiltered (_("There are no auto-display expressions now.\n"));
1861   else
1862     printf_filtered (_("Auto-display expressions now in effect:\n\
1863 Num Enb Expression\n"));
1864
1865   for (d = display_chain; d; d = d->next)
1866     {
1867       printf_filtered ("%d:   %c  ", d->number, "ny"[(int) d->enabled_p]);
1868       if (d->format.size)
1869         printf_filtered ("/%d%c%c ", d->format.count, d->format.size,
1870                          d->format.format);
1871       else if (d->format.format)
1872         printf_filtered ("/%c ", d->format.format);
1873       puts_filtered (d->exp_string);
1874       if (d->block && !contained_in (get_selected_block (0), d->block))
1875         printf_filtered (_(" (cannot be evaluated in the current context)"));
1876       printf_filtered ("\n");
1877       gdb_flush (gdb_stdout);
1878     }
1879 }
1880
1881 /* Callback fo map_display_numbers, that enables or disables the
1882    passed in display D.  */
1883
1884 static void
1885 do_enable_disable_display (struct display *d, void *data)
1886 {
1887   d->enabled_p = *(int *) data;
1888 }
1889
1890 /* Implamentation of both the "disable display" and "enable display"
1891    commands.  ENABLE decides what to do.  */
1892
1893 static void
1894 enable_disable_display_command (char *args, int from_tty, int enable)
1895 {
1896   if (args == NULL)
1897     {
1898       struct display *d;
1899
1900       ALL_DISPLAYS (d)
1901         d->enabled_p = enable;
1902       return;
1903     }
1904
1905   map_display_numbers (args, do_enable_disable_display, &enable);
1906 }
1907
1908 /* The "enable display" command.  */
1909
1910 static void
1911 enable_display_command (char *args, int from_tty)
1912 {
1913   enable_disable_display_command (args, from_tty, 1);
1914 }
1915
1916 /* The "disable display" command.  */
1917
1918 static void
1919 disable_display_command (char *args, int from_tty)
1920 {
1921   enable_disable_display_command (args, from_tty, 0);
1922 }
1923
1924 /* display_chain items point to blocks and expressions.  Some expressions in
1925    turn may point to symbols.
1926    Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
1927    obstack_free'd when a shared library is unloaded.
1928    Clear pointers that are about to become dangling.
1929    Both .exp and .block fields will be restored next time we need to display
1930    an item by re-parsing .exp_string field in the new execution context.  */
1931
1932 static void
1933 clear_dangling_display_expressions (struct so_list *solib)
1934 {
1935   struct objfile *objfile = solib->objfile;
1936   struct display *d;
1937
1938   /* With no symbol file we cannot have a block or expression from it.  */
1939   if (objfile == NULL)
1940     return;
1941   if (objfile->separate_debug_objfile_backlink)
1942     objfile = objfile->separate_debug_objfile_backlink;
1943   gdb_assert (objfile->pspace == solib->pspace);
1944
1945   for (d = display_chain; d != NULL; d = d->next)
1946     {
1947       if (d->pspace != solib->pspace)
1948         continue;
1949
1950       if (lookup_objfile_from_block (d->block) == objfile
1951           || (d->exp && exp_uses_objfile (d->exp, objfile)))
1952       {
1953         xfree (d->exp);
1954         d->exp = NULL;
1955         d->block = NULL;
1956       }
1957     }
1958 }
1959 \f
1960
1961 /* Print the value in stack frame FRAME of a variable specified by a
1962    struct symbol.  NAME is the name to print; if NULL then VAR's print
1963    name will be used.  STREAM is the ui_file on which to print the
1964    value.  INDENT specifies the number of indent levels to print
1965    before printing the variable name.  */
1966
1967 void
1968 print_variable_and_value (const char *name, struct symbol *var,
1969                           struct frame_info *frame,
1970                           struct ui_file *stream, int indent)
1971 {
1972   volatile struct gdb_exception except;
1973
1974   if (!name)
1975     name = SYMBOL_PRINT_NAME (var);
1976
1977   fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
1978   TRY_CATCH (except, RETURN_MASK_ERROR)
1979     {
1980       struct value *val;
1981       struct value_print_options opts;
1982
1983       val = read_var_value (var, frame);
1984       get_user_print_options (&opts);
1985       opts.deref_ref = 1;
1986       common_val_print (val, stream, indent, &opts, current_language);
1987     }
1988   if (except.reason < 0)
1989     fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
1990                      except.message);
1991   fprintf_filtered (stream, "\n");
1992 }
1993
1994 /* printf "printf format string" ARG to STREAM.  */
1995
1996 static void
1997 ui_printf (char *arg, struct ui_file *stream)
1998 {
1999   char *f = NULL;
2000   char *s = arg;
2001   char *string = NULL;
2002   struct value **val_args;
2003   char *substrings;
2004   char *current_substring;
2005   int nargs = 0;
2006   int allocated_args = 20;
2007   struct cleanup *old_cleanups;
2008
2009   val_args = xmalloc (allocated_args * sizeof (struct value *));
2010   old_cleanups = make_cleanup (free_current_contents, &val_args);
2011
2012   if (s == 0)
2013     error_no_arg (_("format-control string and values to print"));
2014
2015   s = skip_spaces (s);
2016
2017   /* A format string should follow, enveloped in double quotes.  */
2018   if (*s++ != '"')
2019     error (_("Bad format string, missing '\"'."));
2020
2021   /* Parse the format-control string and copy it into the string STRING,
2022      processing some kinds of escape sequence.  */
2023
2024   f = string = (char *) alloca (strlen (s) + 1);
2025
2026   while (*s != '"')
2027     {
2028       int c = *s++;
2029       switch (c)
2030         {
2031         case '\0':
2032           error (_("Bad format string, non-terminated '\"'."));
2033
2034         case '\\':
2035           switch (c = *s++)
2036             {
2037             case '\\':
2038               *f++ = '\\';
2039               break;
2040             case 'a':
2041               *f++ = '\a';
2042               break;
2043             case 'b':
2044               *f++ = '\b';
2045               break;
2046             case 'f':
2047               *f++ = '\f';
2048               break;
2049             case 'n':
2050               *f++ = '\n';
2051               break;
2052             case 'r':
2053               *f++ = '\r';
2054               break;
2055             case 't':
2056               *f++ = '\t';
2057               break;
2058             case 'v':
2059               *f++ = '\v';
2060               break;
2061             case '"':
2062               *f++ = '"';
2063               break;
2064             default:
2065               /* ??? TODO: handle other escape sequences.  */
2066               error (_("Unrecognized escape character \\%c in format string."),
2067                      c);
2068             }
2069           break;
2070
2071         default:
2072           *f++ = c;
2073         }
2074     }
2075
2076   /* Skip over " and following space and comma.  */
2077   s++;
2078   *f++ = '\0';
2079   s = skip_spaces (s);
2080
2081   if (*s != ',' && *s != 0)
2082     error (_("Invalid argument syntax"));
2083
2084   if (*s == ',')
2085     s++;
2086   s = skip_spaces (s);
2087
2088   /* Need extra space for the '\0's.  Doubling the size is sufficient.  */
2089   substrings = alloca (strlen (string) * 2);
2090   current_substring = substrings;
2091
2092   {
2093     /* Now scan the string for %-specs and see what kinds of args they want.
2094        argclass[I] classifies the %-specs so we can give printf_filtered
2095        something of the right size.  */
2096
2097     enum argclass
2098       {
2099         int_arg, long_arg, long_long_arg, ptr_arg,
2100         string_arg, wide_string_arg, wide_char_arg,
2101         double_arg, long_double_arg, decfloat_arg
2102       };
2103     enum argclass *argclass;
2104     enum argclass this_argclass;
2105     char *last_arg;
2106     int nargs_wanted;
2107     int i;
2108
2109     argclass = (enum argclass *) alloca (strlen (s) * sizeof *argclass);
2110     nargs_wanted = 0;
2111     f = string;
2112     last_arg = string;
2113     while (*f)
2114       if (*f++ == '%')
2115         {
2116           int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
2117           int seen_space = 0, seen_plus = 0;
2118           int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
2119           int seen_big_d = 0, seen_double_big_d = 0;
2120           int bad = 0;
2121
2122           /* Check the validity of the format specifier, and work
2123              out what argument it expects.  We only accept C89
2124              format strings, with the exception of long long (which
2125              we autoconf for).  */
2126
2127           /* Skip over "%%".  */
2128           if (*f == '%')
2129             {
2130               f++;
2131               continue;
2132             }
2133
2134           /* The first part of a format specifier is a set of flag
2135              characters.  */
2136           while (strchr ("0-+ #", *f))
2137             {
2138               if (*f == '#')
2139                 seen_hash = 1;
2140               else if (*f == '0')
2141                 seen_zero = 1;
2142               else if (*f == ' ')
2143                 seen_space = 1;
2144               else if (*f == '+')
2145                 seen_plus = 1;
2146               f++;
2147             }
2148
2149           /* The next part of a format specifier is a width.  */
2150           while (strchr ("0123456789", *f))
2151             f++;
2152
2153           /* The next part of a format specifier is a precision.  */
2154           if (*f == '.')
2155             {
2156               seen_prec = 1;
2157               f++;
2158               while (strchr ("0123456789", *f))
2159                 f++;
2160             }
2161
2162           /* The next part of a format specifier is a length modifier.  */
2163           if (*f == 'h')
2164             {
2165               seen_h = 1;
2166               f++;
2167             }
2168           else if (*f == 'l')
2169             {
2170               f++;
2171               lcount++;
2172               if (*f == 'l')
2173                 {
2174                   f++;
2175                   lcount++;
2176                 }
2177             }
2178           else if (*f == 'L')
2179             {
2180               seen_big_l = 1;
2181               f++;
2182             }
2183           /* Decimal32 modifier.  */
2184           else if (*f == 'H')
2185             {
2186               seen_big_h = 1;
2187               f++;
2188             }
2189           /* Decimal64 and Decimal128 modifiers.  */
2190           else if (*f == 'D')
2191             {
2192               f++;
2193
2194               /* Check for a Decimal128.  */
2195               if (*f == 'D')
2196                 {
2197                   f++;
2198                   seen_double_big_d = 1;
2199                 }
2200               else
2201                 seen_big_d = 1;
2202             }
2203
2204           switch (*f)
2205             {
2206             case 'u':
2207               if (seen_hash)
2208                 bad = 1;
2209               /* FALLTHROUGH */
2210
2211             case 'o':
2212             case 'x':
2213             case 'X':
2214               if (seen_space || seen_plus)
2215                 bad = 1;
2216               /* FALLTHROUGH */
2217
2218             case 'd':
2219             case 'i':
2220               if (lcount == 0)
2221                 this_argclass = int_arg;
2222               else if (lcount == 1)
2223                 this_argclass = long_arg;
2224               else
2225                 this_argclass = long_long_arg;
2226
2227               if (seen_big_l)
2228                 bad = 1;
2229               break;
2230
2231             case 'c':
2232               this_argclass = lcount == 0 ? int_arg : wide_char_arg;
2233               if (lcount > 1 || seen_h || seen_big_l)
2234                 bad = 1;
2235               if (seen_prec || seen_zero || seen_space || seen_plus)
2236                 bad = 1;
2237               break;
2238
2239             case 'p':
2240               this_argclass = ptr_arg;
2241               if (lcount || seen_h || seen_big_l)
2242                 bad = 1;
2243               if (seen_prec || seen_zero || seen_space || seen_plus)
2244                 bad = 1;
2245               break;
2246
2247             case 's':
2248               this_argclass = lcount == 0 ? string_arg : wide_string_arg;
2249               if (lcount > 1 || seen_h || seen_big_l)
2250                 bad = 1;
2251               if (seen_zero || seen_space || seen_plus)
2252                 bad = 1;
2253               break;
2254
2255             case 'e':
2256             case 'f':
2257             case 'g':
2258             case 'E':
2259             case 'G':
2260               if (seen_big_h || seen_big_d || seen_double_big_d)
2261                 this_argclass = decfloat_arg;
2262               else if (seen_big_l)
2263                 this_argclass = long_double_arg;
2264               else
2265                 this_argclass = double_arg;
2266
2267               if (lcount || seen_h)
2268                 bad = 1;
2269               break;
2270
2271             case '*':
2272               error (_("`*' not supported for precision or width in printf"));
2273
2274             case 'n':
2275               error (_("Format specifier `n' not supported in printf"));
2276
2277             case '\0':
2278               error (_("Incomplete format specifier at end of format string"));
2279
2280             default:
2281               error (_("Unrecognized format specifier '%c' in printf"), *f);
2282             }
2283
2284           if (bad)
2285             error (_("Inappropriate modifiers to "
2286                      "format specifier '%c' in printf"),
2287                    *f);
2288
2289           f++;
2290
2291           if (lcount > 1 && USE_PRINTF_I64)
2292             {
2293               /* Windows' printf does support long long, but not the usual way.
2294                  Convert %lld to %I64d.  */
2295               int length_before_ll = f - last_arg - 1 - lcount;
2296
2297               strncpy (current_substring, last_arg, length_before_ll);
2298               strcpy (current_substring + length_before_ll, "I64");
2299               current_substring[length_before_ll + 3] =
2300                 last_arg[length_before_ll + lcount];
2301               current_substring += length_before_ll + 4;
2302             }
2303           else if (this_argclass == wide_string_arg
2304                    || this_argclass == wide_char_arg)
2305             {
2306               /* Convert %ls or %lc to %s.  */
2307               int length_before_ls = f - last_arg - 2;
2308
2309               strncpy (current_substring, last_arg, length_before_ls);
2310               strcpy (current_substring + length_before_ls, "s");
2311               current_substring += length_before_ls + 2;
2312             }
2313           else
2314             {
2315               strncpy (current_substring, last_arg, f - last_arg);
2316               current_substring += f - last_arg;
2317             }
2318           *current_substring++ = '\0';
2319           last_arg = f;
2320           argclass[nargs_wanted++] = this_argclass;
2321         }
2322
2323     /* Now, parse all arguments and evaluate them.
2324        Store the VALUEs in VAL_ARGS.  */
2325
2326     while (*s != '\0')
2327       {
2328         char *s1;
2329
2330         if (nargs == allocated_args)
2331           val_args = (struct value **) xrealloc ((char *) val_args,
2332                                                  (allocated_args *= 2)
2333                                                  * sizeof (struct value *));
2334         s1 = s;
2335         val_args[nargs] = parse_to_comma_and_eval (&s1);
2336
2337         nargs++;
2338         s = s1;
2339         if (*s == ',')
2340           s++;
2341       }
2342
2343     if (nargs != nargs_wanted)
2344       error (_("Wrong number of arguments for specified format-string"));
2345
2346     /* Now actually print them.  */
2347     current_substring = substrings;
2348     for (i = 0; i < nargs; i++)
2349       {
2350         switch (argclass[i])
2351           {
2352           case string_arg:
2353             {
2354               gdb_byte *str;
2355               CORE_ADDR tem;
2356               int j;
2357
2358               tem = value_as_address (val_args[i]);
2359
2360               /* This is a %s argument.  Find the length of the string.  */
2361               for (j = 0;; j++)
2362                 {
2363                   gdb_byte c;
2364
2365                   QUIT;
2366                   read_memory (tem + j, &c, 1);
2367                   if (c == 0)
2368                     break;
2369                 }
2370
2371               /* Copy the string contents into a string inside GDB.  */
2372               str = (gdb_byte *) alloca (j + 1);
2373               if (j != 0)
2374                 read_memory (tem, str, j);
2375               str[j] = 0;
2376
2377               fprintf_filtered (stream, current_substring, (char *) str);
2378             }
2379             break;
2380           case wide_string_arg:
2381             {
2382               gdb_byte *str;
2383               CORE_ADDR tem;
2384               int j;
2385               struct gdbarch *gdbarch
2386                 = get_type_arch (value_type (val_args[i]));
2387               enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2388               struct type *wctype = lookup_typename (current_language, gdbarch,
2389                                                      "wchar_t", NULL, 0);
2390               int wcwidth = TYPE_LENGTH (wctype);
2391               gdb_byte *buf = alloca (wcwidth);
2392               struct obstack output;
2393               struct cleanup *inner_cleanup;
2394
2395               tem = value_as_address (val_args[i]);
2396
2397               /* This is a %s argument.  Find the length of the string.  */
2398               for (j = 0;; j += wcwidth)
2399                 {
2400                   QUIT;
2401                   read_memory (tem + j, buf, wcwidth);
2402                   if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
2403                     break;
2404                 }
2405
2406               /* Copy the string contents into a string inside GDB.  */
2407               str = (gdb_byte *) alloca (j + wcwidth);
2408               if (j != 0)
2409                 read_memory (tem, str, j);
2410               memset (&str[j], 0, wcwidth);
2411
2412               obstack_init (&output);
2413               inner_cleanup = make_cleanup_obstack_free (&output);
2414
2415               convert_between_encodings (target_wide_charset (gdbarch),
2416                                          host_charset (),
2417                                          str, j, wcwidth,
2418                                          &output, translit_char);
2419               obstack_grow_str0 (&output, "");
2420
2421               fprintf_filtered (stream, current_substring,
2422                                 obstack_base (&output));
2423               do_cleanups (inner_cleanup);
2424             }
2425             break;
2426           case wide_char_arg:
2427             {
2428               struct gdbarch *gdbarch
2429                 = get_type_arch (value_type (val_args[i]));
2430               struct type *wctype = lookup_typename (current_language, gdbarch,
2431                                                      "wchar_t", NULL, 0);
2432               struct type *valtype;
2433               struct obstack output;
2434               struct cleanup *inner_cleanup;
2435               const gdb_byte *bytes;
2436
2437               valtype = value_type (val_args[i]);
2438               if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
2439                   || TYPE_CODE (valtype) != TYPE_CODE_INT)
2440                 error (_("expected wchar_t argument for %%lc"));
2441
2442               bytes = value_contents (val_args[i]);
2443
2444               obstack_init (&output);
2445               inner_cleanup = make_cleanup_obstack_free (&output);
2446
2447               convert_between_encodings (target_wide_charset (gdbarch),
2448                                          host_charset (),
2449                                          bytes, TYPE_LENGTH (valtype),
2450                                          TYPE_LENGTH (valtype),
2451                                          &output, translit_char);
2452               obstack_grow_str0 (&output, "");
2453
2454               fprintf_filtered (stream, current_substring,
2455                                 obstack_base (&output));
2456               do_cleanups (inner_cleanup);
2457             }
2458             break;
2459           case double_arg:
2460             {
2461               struct type *type = value_type (val_args[i]);
2462               DOUBLEST val;
2463               int inv;
2464
2465               /* If format string wants a float, unchecked-convert the value
2466                  to floating point of the same size.  */
2467               type = float_type_from_length (type);
2468               val = unpack_double (type, value_contents (val_args[i]), &inv);
2469               if (inv)
2470                 error (_("Invalid floating value found in program."));
2471
2472               fprintf_filtered (stream, current_substring, (double) val);
2473               break;
2474             }
2475           case long_double_arg:
2476 #ifdef HAVE_LONG_DOUBLE
2477             {
2478               struct type *type = value_type (val_args[i]);
2479               DOUBLEST val;
2480               int inv;
2481
2482               /* If format string wants a float, unchecked-convert the value
2483                  to floating point of the same size.  */
2484               type = float_type_from_length (type);
2485               val = unpack_double (type, value_contents (val_args[i]), &inv);
2486               if (inv)
2487                 error (_("Invalid floating value found in program."));
2488
2489               fprintf_filtered (stream, current_substring,
2490                                 (long double) val);
2491               break;
2492             }
2493 #else
2494             error (_("long double not supported in printf"));
2495 #endif
2496           case long_long_arg:
2497 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2498             {
2499               long long val = value_as_long (val_args[i]);
2500
2501               fprintf_filtered (stream, current_substring, val);
2502               break;
2503             }
2504 #else
2505             error (_("long long not supported in printf"));
2506 #endif
2507           case int_arg:
2508             {
2509               int val = value_as_long (val_args[i]);
2510
2511               fprintf_filtered (stream, current_substring, val);
2512               break;
2513             }
2514           case long_arg:
2515             {
2516               long val = value_as_long (val_args[i]);
2517
2518               fprintf_filtered (stream, current_substring, val);
2519               break;
2520             }
2521
2522           /* Handles decimal floating values.  */
2523         case decfloat_arg:
2524             {
2525               const gdb_byte *param_ptr = value_contents (val_args[i]);
2526
2527 #if defined (PRINTF_HAS_DECFLOAT)
2528               /* If we have native support for Decimal floating
2529                  printing, handle it here.  */
2530               fprintf_filtered (stream, current_substring, param_ptr);
2531 #else
2532
2533               /* As a workaround until vasprintf has native support for DFP
2534                we convert the DFP values to string and print them using
2535                the %s format specifier.  */
2536
2537               char *eos, *sos;
2538               int nnull_chars = 0;
2539
2540               /* Parameter data.  */
2541               struct type *param_type = value_type (val_args[i]);
2542               unsigned int param_len = TYPE_LENGTH (param_type);
2543               struct gdbarch *gdbarch = get_type_arch (param_type);
2544               enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2545
2546               /* DFP output data.  */
2547               struct value *dfp_value = NULL;
2548               gdb_byte *dfp_ptr;
2549               int dfp_len = 16;
2550               gdb_byte dec[16];
2551               struct type *dfp_type = NULL;
2552               char decstr[MAX_DECIMAL_STRING];
2553
2554               /* Points to the end of the string so that we can go back
2555                  and check for DFP length modifiers.  */
2556               eos = current_substring + strlen (current_substring);
2557
2558               /* Look for the float/double format specifier.  */
2559               while (*eos != 'f' && *eos != 'e' && *eos != 'E'
2560                      && *eos != 'g' && *eos != 'G')
2561                   eos--;
2562
2563               sos = eos;
2564
2565               /* Search for the '%' char and extract the size and type of
2566                  the output decimal value based on its modifiers
2567                  (%Hf, %Df, %DDf).  */
2568               while (*--sos != '%')
2569                 {
2570                   if (*sos == 'H')
2571                     {
2572                       dfp_len = 4;
2573                       dfp_type = builtin_type (gdbarch)->builtin_decfloat;
2574                     }
2575                   else if (*sos == 'D' && *(sos - 1) == 'D')
2576                     {
2577                       dfp_len = 16;
2578                       dfp_type = builtin_type (gdbarch)->builtin_declong;
2579                       sos--;
2580                     }
2581                   else
2582                     {
2583                       dfp_len = 8;
2584                       dfp_type = builtin_type (gdbarch)->builtin_decdouble;
2585                     }
2586                 }
2587
2588               /* Replace %Hf, %Df and %DDf with %s's.  */
2589               *++sos = 's';
2590
2591               /* Go through the whole format string and pull the correct
2592                  number of chars back to compensate for the change in the
2593                  format specifier.  */
2594               while (nnull_chars < nargs - i)
2595                 {
2596                   if (*eos == '\0')
2597                     nnull_chars++;
2598
2599                   *++sos = *++eos;
2600                 }
2601
2602               /* Conversion between different DFP types.  */
2603               if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
2604                 decimal_convert (param_ptr, param_len, byte_order,
2605                                  dec, dfp_len, byte_order);
2606               else
2607                 /* If this is a non-trivial conversion, just output 0.
2608                    A correct converted value can be displayed by explicitly
2609                    casting to a DFP type.  */
2610                 decimal_from_string (dec, dfp_len, byte_order, "0");
2611
2612               dfp_value = value_from_decfloat (dfp_type, dec);
2613
2614               dfp_ptr = (gdb_byte *) value_contents (dfp_value);
2615
2616               decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);
2617
2618               /* Print the DFP value.  */
2619               fprintf_filtered (stream, current_substring, decstr);
2620
2621               break;
2622 #endif
2623             }
2624
2625           case ptr_arg:
2626             {
2627               /* We avoid the host's %p because pointers are too
2628                  likely to be the wrong size.  The only interesting
2629                  modifier for %p is a width; extract that, and then
2630                  handle %p as glibc would: %#x or a literal "(nil)".  */
2631
2632               char *p, *fmt, *fmt_p;
2633 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2634               long long val = value_as_long (val_args[i]);
2635 #else
2636               long val = value_as_long (val_args[i]);
2637 #endif
2638
2639               fmt = alloca (strlen (current_substring) + 5);
2640
2641               /* Copy up to the leading %.  */
2642               p = current_substring;
2643               fmt_p = fmt;
2644               while (*p)
2645                 {
2646                   int is_percent = (*p == '%');
2647
2648                   *fmt_p++ = *p++;
2649                   if (is_percent)
2650                     {
2651                       if (*p == '%')
2652                         *fmt_p++ = *p++;
2653                       else
2654                         break;
2655                     }
2656                 }
2657
2658               if (val != 0)
2659                 *fmt_p++ = '#';
2660
2661               /* Copy any width.  */
2662               while (*p >= '0' && *p < '9')
2663                 *fmt_p++ = *p++;
2664
2665               gdb_assert (*p == 'p' && *(p + 1) == '\0');
2666               if (val != 0)
2667                 {
2668 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
2669                   *fmt_p++ = 'l';
2670 #endif
2671                   *fmt_p++ = 'l';
2672                   *fmt_p++ = 'x';
2673                   *fmt_p++ = '\0';
2674                   fprintf_filtered (stream, fmt, val);
2675                 }
2676               else
2677                 {
2678                   *fmt_p++ = 's';
2679                   *fmt_p++ = '\0';
2680                   fprintf_filtered (stream, fmt, "(nil)");
2681                 }
2682
2683               break;
2684             }
2685           default:
2686             internal_error (__FILE__, __LINE__,
2687                             _("failed internal consistency check"));
2688           }
2689         /* Skip to the next substring.  */
2690         current_substring += strlen (current_substring) + 1;
2691       }
2692     /* Print the portion of the format string after the last argument.
2693        Note that this will not include any ordinary %-specs, but it
2694        might include "%%".  That is why we use printf_filtered and not
2695        puts_filtered here.  Also, we pass a dummy argument because
2696        some platforms have modified GCC to include -Wformat-security
2697        by default, which will warn here if there is no argument.  */
2698     fprintf_filtered (stream, last_arg, 0);
2699   }
2700   do_cleanups (old_cleanups);
2701 }
2702
2703 /* Implement the "printf" command.  */
2704
2705 static void
2706 printf_command (char *arg, int from_tty)
2707 {
2708   ui_printf (arg, gdb_stdout);
2709 }
2710
2711 /* Implement the "eval" command.  */
2712
2713 static void
2714 eval_command (char *arg, int from_tty)
2715 {
2716   struct ui_file *ui_out = mem_fileopen ();
2717   struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
2718   char *expanded;
2719
2720   ui_printf (arg, ui_out);
2721
2722   expanded = ui_file_xstrdup (ui_out, NULL);
2723   make_cleanup (xfree, expanded);
2724
2725   execute_command (expanded, from_tty);
2726
2727   do_cleanups (cleanups);
2728 }
2729
2730 void
2731 _initialize_printcmd (void)
2732 {
2733   struct cmd_list_element *c;
2734
2735   current_display_number = -1;
2736
2737   observer_attach_solib_unloaded (clear_dangling_display_expressions);
2738
2739   add_info ("address", address_info,
2740             _("Describe where symbol SYM is stored."));
2741
2742   add_info ("symbol", sym_info, _("\
2743 Describe what symbol is at location ADDR.\n\
2744 Only for symbols with fixed locations (global or static scope)."));
2745
2746   add_com ("x", class_vars, x_command, _("\
2747 Examine memory: x/FMT ADDRESS.\n\
2748 ADDRESS is an expression for the memory address to examine.\n\
2749 FMT is a repeat count followed by a format letter and a size letter.\n\
2750 Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal),\n\
2751   t(binary), f(float), a(address), i(instruction), c(char) and s(string).\n\
2752 Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes).\n\
2753 The specified number of objects of the specified size are printed\n\
2754 according to the format.\n\n\
2755 Defaults for format and size letters are those previously used.\n\
2756 Default count is 1.  Default address is following last thing printed\n\
2757 with this command or \"print\"."));
2758
2759 #if 0
2760   add_com ("whereis", class_vars, whereis_command,
2761            _("Print line number and file of definition of variable."));
2762 #endif
2763
2764   add_info ("display", display_info, _("\
2765 Expressions to display when program stops, with code numbers."));
2766
2767   add_cmd ("undisplay", class_vars, undisplay_command, _("\
2768 Cancel some expressions to be displayed when program stops.\n\
2769 Arguments are the code numbers of the expressions to stop displaying.\n\
2770 No argument means cancel all automatic-display expressions.\n\
2771 \"delete display\" has the same effect as this command.\n\
2772 Do \"info display\" to see current list of code numbers."),
2773            &cmdlist);
2774
2775   add_com ("display", class_vars, display_command, _("\
2776 Print value of expression EXP each time the program stops.\n\
2777 /FMT may be used before EXP as in the \"print\" command.\n\
2778 /FMT \"i\" or \"s\" or including a size-letter is allowed,\n\
2779 as in the \"x\" command, and then EXP is used to get the address to examine\n\
2780 and examining is done as in the \"x\" command.\n\n\
2781 With no argument, display all currently requested auto-display expressions.\n\
2782 Use \"undisplay\" to cancel display requests previously made."));
2783
2784   add_cmd ("display", class_vars, enable_display_command, _("\
2785 Enable some expressions to be displayed when program stops.\n\
2786 Arguments are the code numbers of the expressions to resume displaying.\n\
2787 No argument means enable all automatic-display expressions.\n\
2788 Do \"info display\" to see current list of code numbers."), &enablelist);
2789
2790   add_cmd ("display", class_vars, disable_display_command, _("\
2791 Disable some expressions to be displayed when program stops.\n\
2792 Arguments are the code numbers of the expressions to stop displaying.\n\
2793 No argument means disable all automatic-display expressions.\n\
2794 Do \"info display\" to see current list of code numbers."), &disablelist);
2795
2796   add_cmd ("display", class_vars, undisplay_command, _("\
2797 Cancel 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 cancel all automatic-display expressions.\n\
2800 Do \"info display\" to see current list of code numbers."), &deletelist);
2801
2802   add_com ("printf", class_vars, printf_command, _("\
2803 printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
2804 This is useful for formatted output in user-defined commands."));
2805
2806   add_com ("output", class_vars, output_command, _("\
2807 Like \"print\" but don't put in value history and don't print newline.\n\
2808 This is useful in user-defined commands."));
2809
2810   add_prefix_cmd ("set", class_vars, set_command, _("\
2811 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2812 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2813 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2814 with $), a register (a few standard names starting with $), or an actual\n\
2815 variable in the program being debugged.  EXP is any valid expression.\n\
2816 Use \"set variable\" for variables with names identical to set subcommands.\n\
2817 \n\
2818 With a subcommand, this command modifies parts of the gdb environment.\n\
2819 You can see these environment settings with the \"show\" command."),
2820                   &setlist, "set ", 1, &cmdlist);
2821   if (dbx_commands)
2822     add_com ("assign", class_vars, set_command, _("\
2823 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2824 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2825 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2826 with $), a register (a few standard names starting with $), or an actual\n\
2827 variable in the program being debugged.  EXP is any valid expression.\n\
2828 Use \"set variable\" for variables with names identical to set subcommands.\n\
2829 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
2830 You can see these environment settings with the \"show\" command."));
2831
2832   /* "call" is the same as "set", but handy for dbx users to call fns.  */
2833   c = add_com ("call", class_vars, call_command, _("\
2834 Call a function in the program.\n\
2835 The argument is the function name and arguments, in the notation of the\n\
2836 current working language.  The result is printed and saved in the value\n\
2837 history, if it is not void."));
2838   set_cmd_completer (c, expression_completer);
2839
2840   add_cmd ("variable", class_vars, set_command, _("\
2841 Evaluate expression EXP and assign result to variable VAR, using assignment\n\
2842 syntax appropriate for the current language (VAR = EXP or VAR := EXP for\n\
2843 example).  VAR may be a debugger \"convenience\" variable (names starting\n\
2844 with $), a register (a few standard names starting with $), or an actual\n\
2845 variable in the program being debugged.  EXP is any valid expression.\n\
2846 This may usually be abbreviated to simply \"set\"."),
2847            &setlist);
2848
2849   c = add_com ("print", class_vars, print_command, _("\
2850 Print value of expression EXP.\n\
2851 Variables accessible are those of the lexical environment of the selected\n\
2852 stack frame, plus all those whose scope is global or an entire file.\n\
2853 \n\
2854 $NUM gets previous value number NUM.  $ and $$ are the last two values.\n\
2855 $$NUM refers to NUM'th value back from the last one.\n\
2856 Names starting with $ refer to registers (with the values they would have\n\
2857 if the program were to return to the stack frame now selected, restoring\n\
2858 all registers saved by frames farther in) or else to debugger\n\
2859 \"convenience\" variables (any such name not a known register).\n\
2860 Use assignment expressions to give values to convenience variables.\n\
2861 \n\
2862 {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP.\n\
2863 @ is a binary operator for treating consecutive data objects\n\
2864 anywhere in memory as an array.  FOO@NUM gives an array whose first\n\
2865 element is FOO, whose second element is stored in the space following\n\
2866 where FOO is stored, etc.  FOO must be an expression whose value\n\
2867 resides in memory.\n\
2868 \n\
2869 EXP may be preceded with /FMT, where FMT is a format letter\n\
2870 but no count or size letter (see \"x\" command)."));
2871   set_cmd_completer (c, expression_completer);
2872   add_com_alias ("p", "print", class_vars, 1);
2873
2874   c = add_com ("inspect", class_vars, inspect_command, _("\
2875 Same as \"print\" command, except that if you are running in the epoch\n\
2876 environment, the value is printed in its own window."));
2877   set_cmd_completer (c, expression_completer);
2878
2879   add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
2880                             &max_symbolic_offset, _("\
2881 Set the largest offset that will be printed in <symbol+1234> form."), _("\
2882 Show the largest offset that will be printed in <symbol+1234> form."), NULL,
2883                             NULL,
2884                             show_max_symbolic_offset,
2885                             &setprintlist, &showprintlist);
2886   add_setshow_boolean_cmd ("symbol-filename", no_class,
2887                            &print_symbol_filename, _("\
2888 Set printing of source filename and line number with <symbol>."), _("\
2889 Show printing of source filename and line number with <symbol>."), NULL,
2890                            NULL,
2891                            show_print_symbol_filename,
2892                            &setprintlist, &showprintlist);
2893
2894   add_com ("eval", no_class, eval_command, _("\
2895 Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
2896 a command line, and call it."));
2897 }