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