contrib/gdb-7/gdb/printcmd.c

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