add xfail for "print u_var" test in gdb.ada/packed_array.exp

[deliverable/binutils-gdb.git] / gdb / printcmd.c

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 355552db5e0aa8c59b1c98abbfce89e4e7618496..d89004b2a609960c09609ac11154da82f8627fc8 100644 (file)
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -2,7 +2,7 @@
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,

-   2008 Free Software Foundation, Inc.
+   2008, 2009, 2010, 2011 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -43,37 +43,50 @@
 #include "disasm.h"
 #include "dfp.h"
 #include "valprint.h"
 #include "disasm.h"
 #include "dfp.h"
 #include "valprint.h"

+#include "exceptions.h"
+#include "observer.h"
+#include "solist.h"
+#include "parser-defs.h"
+#include "charset.h"
+#include "arch-utils.h"
+#include "printcmd.h"

 
 #ifdef TUI
 
 #ifdef TUI

-#include "tui/tui.h"           /* For tui_active et.al.   */
+#include "tui/tui.h"           /* For tui_active et al.   */

 #endif
 
 #endif
 

-#if defined(__MINGW32__)
+#if defined(__MINGW32__) && !defined(PRINTF_HAS_LONG_LONG)

 # define USE_PRINTF_I64 1
 # define PRINTF_HAS_LONG_LONG
 #else
 # define USE_PRINTF_I64 0
 #endif
 
 # define USE_PRINTF_I64 1
 # define PRINTF_HAS_LONG_LONG
 #else
 # define USE_PRINTF_I64 0
 #endif
 

-extern int asm_demangle;       /* Whether to demangle syms in asm printouts */
+extern int asm_demangle;       /* Whether to demangle syms in asm
+                                  printouts.  */

 
 struct format_data
   {
     int count;
     char format;
     char size;
 
 struct format_data
   {
     int count;
     char format;
     char size;

+
+    /* True if the value should be printed raw -- that is, bypassing
+       python-based formatters.  */
+    unsigned char raw;

   };
 
 /* Last specified output format.  */
 
   };
 
 /* Last specified output format.  */
 

-static char last_format = 'x';
+static char last_format = 0;

 
 /* Last specified examination size.  'b', 'h', 'w' or `q'.  */
 
 static char last_size = 'w';
 
 
 /* Last specified examination size.  'b', 'h', 'w' or `q'.  */
 
 static char last_size = 'w';
 

-/* Default address to examine next.  */
+/* Default address to examine next, and associated architecture.  */

 
 

+static struct gdbarch *next_gdbarch;

 static CORE_ADDR next_address;
 
 /* Number of delay instructions following current disassembled insn.  */
 static CORE_ADDR next_address;
 
 /* Number of delay instructions following current disassembled insn.  */


@@ -97,8 +110,9 @@ static void
 show_max_symbolic_offset (struct ui_file *file, int from_tty,
                          struct cmd_list_element *c, const char *value)
 {
 show_max_symbolic_offset (struct ui_file *file, int from_tty,
                          struct cmd_list_element *c, const char *value)
 {

-  fprintf_filtered (file, _("\
-The largest offset that will be printed in <symbol+1234> form is %s.\n"),
+  fprintf_filtered (file,
+                   _("The largest offset that will be "
+                     "printed in <symbol+1234> form is %s.\n"),

                    value);
 }
 
                    value);
 }
 


@@ -109,8 +123,8 @@ static void
 show_print_symbol_filename (struct ui_file *file, int from_tty,
                            struct cmd_list_element *c, const char *value)
 {
 show_print_symbol_filename (struct ui_file *file, int from_tty,
                            struct cmd_list_element *c, const char *value)
 {

-  fprintf_filtered (file, _("\
-Printing of source filename and line number with <symbol> is %s.\n"),
+  fprintf_filtered (file, _("Printing of source filename and "
+                           "line number with <symbol> is %s.\n"),

                    value);
 }
 
                    value);
 }
 


@@ -124,15 +138,26 @@ struct display
   {
     /* Chain link to next auto-display item.  */
     struct display *next;
   {
     /* Chain link to next auto-display item.  */
     struct display *next;

+
+    /* The expression as the user typed it.  */
+    char *exp_string;
+

     /* Expression to be evaluated and displayed.  */
     struct expression *exp;
     /* Expression to be evaluated and displayed.  */
     struct expression *exp;

+

     /* Item number of this auto-display item.  */
     int number;
     /* Item number of this auto-display item.  */
     int number;

+

     /* Display format specified.  */
     struct format_data format;
     /* Display format specified.  */
     struct format_data format;

-    /* Innermost block required by this expression when evaluated */
+
+    /* Program space associated with `block'.  */
+    struct program_space *pspace;
+
+    /* Innermost block required by this expression when evaluated.  */

     struct block *block;
     struct block *block;

-    /* Status of this display (enabled or disabled) */
+
+    /* Status of this display (enabled or disabled).  */

     int enabled_p;
   };
 
     int enabled_p;
   };
 


@@ -143,13 +168,18 @@ static struct display *display_chain;
 
 static int display_number;
 
 
 static int display_number;
 

-/* Prototypes for exported functions. */
+/* Walk the following statement or block through all displays.  */
+
+#define ALL_DISPLAYS(B)                                \
+  for (B = display_chain; B; B = B->next)
+
+/* Prototypes for exported functions.  */

 
 void output_command (char *, int);
 
 void _initialize_printcmd (void);
 
 
 void output_command (char *, int);
 
 void _initialize_printcmd (void);
 

-/* Prototypes for local functions. */
+/* Prototypes for local functions.  */

 
 static void do_one_display (struct display *);
 \f
 
 static void do_one_display (struct display *);
 \f


@@ -173,6 +203,7 @@ decode_format (char **string_ptr, int oformat, int osize)
   val.format = '?';
   val.size = '?';
   val.count = 1;
   val.format = '?';
   val.size = '?';
   val.count = 1;

+  val.raw = 0;

 
   if (*p >= '0' && *p <= '9')
     val.count = atoi (p);
 
   if (*p >= '0' && *p <= '9')
     val.count = atoi (p);


@@ -185,6 +216,11 @@ decode_format (char **string_ptr, int oformat, int osize)
     {
       if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
        val.size = *p++;
     {
       if (*p == 'b' || *p == 'h' || *p == 'w' || *p == 'g')
        val.size = *p++;

+      else if (*p == 'r')
+       {
+         val.raw = 1;
+         p++;
+       }

       else if (*p >= 'a' && *p <= 'z')
        val.format = *p++;
       else
       else if (*p >= 'a' && *p <= 'z')
        val.format = *p++;
       else


@@ -213,18 +249,10 @@ decode_format (char **string_ptr, int oformat, int osize)
     switch (val.format)
       {
       case 'a':
     switch (val.format)
       {
       case 'a':

-      case 's':
-       /* Pick the appropriate size for an address.  */
-       if (gdbarch_ptr_bit (current_gdbarch) == 64)
-         val.size = osize ? 'g' : osize;
-       else if (gdbarch_ptr_bit (current_gdbarch) == 32)
-         val.size = osize ? 'w' : osize;
-       else if (gdbarch_ptr_bit (current_gdbarch) == 16)
-         val.size = osize ? 'h' : osize;
-       else
-         /* Bad value for gdbarch_ptr_bit.  */
-         internal_error (__FILE__, __LINE__,
-                         _("failed internal consistency check"));
+       /* Pick the appropriate size for an address.  This is deferred
+          until do_examine when we know the actual architecture to use.
+          A special size value of 'a' is used to indicate this case.  */
+       val.size = osize ? 'a' : osize;

        break;
       case 'f':
        /* Floating point has to be word or giantword.  */
        break;
       case 'f':
        /* Floating point has to be word or giantword.  */


@@ -239,6 +267,12 @@ decode_format (char **string_ptr, int oformat, int osize)
        /* Characters default to one byte.  */
        val.size = osize ? 'b' : osize;
        break;
        /* Characters default to one byte.  */
        val.size = osize ? 'b' : osize;
        break;

+      case 's':
+       /* Display strings with byte size chars unless explicitly
+          specified.  */
+       val.size = '\0';
+       break;
+

       default:
        /* The default is the size most recently specified.  */
        val.size = osize;
       default:
        /* The default is the size most recently specified.  */
        val.size = osize;


@@ -262,24 +296,29 @@ print_formatted (struct value *val, int size,
   int len = TYPE_LENGTH (type);
 
   if (VALUE_LVAL (val) == lval_memory)
   int len = TYPE_LENGTH (type);
 
   if (VALUE_LVAL (val) == lval_memory)

-    next_address = VALUE_ADDRESS (val) + len;
+    next_address = value_address (val) + len;

 
   if (size)
     {
       switch (options->format)
        {
        case 's':
 
   if (size)
     {
       switch (options->format)
        {
        case 's':

-         /* FIXME: Need to handle wchar_t's here... */
-         next_address = VALUE_ADDRESS (val)
-           + val_print_string (VALUE_ADDRESS (val), -1, 1, stream,
-                               options);
+         {
+           struct type *elttype = value_type (val);
+
+           next_address = (value_address (val)
+                           + val_print_string (elttype, NULL,
+                                               value_address (val), -1,
+                                               stream, options) * len);
+         }

          return;
 
        case 'i':
          /* We often wrap here if there are long symbolic names.  */
          wrap_here ("    ");
          return;
 
        case 'i':
          /* We often wrap here if there are long symbolic names.  */
          wrap_here ("    ");

-         next_address = (VALUE_ADDRESS (val)
-                         + gdb_print_insn (VALUE_ADDRESS (val), stream,
+         next_address = (value_address (val)
+                         + gdb_print_insn (get_type_arch (type),
+                                           value_address (val), stream,

                                            &branch_delay_insns));
          return;
        }
                                            &branch_delay_insns));
          return;
        }


@@ -296,15 +335,19 @@ print_formatted (struct value *val, int size,
   else
     /* User specified format, so don't look to the the type to
        tell us what to do.  */
   else
     /* User specified format, so don't look to the the type to
        tell us what to do.  */

-    print_scalar_formatted (value_contents (val), type,
-                           options, size, stream);
+    val_print_scalar_formatted (type,
+                               value_contents_for_printing (val),
+                               value_embedded_offset (val),
+                               val,
+                               options, size, stream);

 }
 
 /* Return builtin floating point type of same length as TYPE.
    If no such type is found, return TYPE itself.  */
 static struct type *
 }
 
 /* Return builtin floating point type of same length as TYPE.
    If no such type is found, return TYPE itself.  */
 static struct type *

-float_type_from_length (struct gdbarch *gdbarch, struct type *type)
+float_type_from_length (struct type *type)

 {
 {

+  struct gdbarch *gdbarch = get_type_arch (type);

   const struct builtin_type *builtin = builtin_type (gdbarch);
   unsigned int len = TYPE_LENGTH (type);
 
   const struct builtin_type *builtin = builtin_type (gdbarch);
   unsigned int len = TYPE_LENGTH (type);
 


@@ -319,33 +362,21 @@ float_type_from_length (struct gdbarch *gdbarch, struct type *type)
 }
 
 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
 }
 
 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,

-   according to OPTIONS and SIZE on STREAM.
-   Formats s and i are not supported at this level.
-
-   This is how the elements of an array or structure are printed
-   with a format.  */
+   according to OPTIONS and SIZE on STREAM.  Formats s and i are not
+   supported at this level.  */

 
 void
 print_scalar_formatted (const void *valaddr, struct type *type,
                        const struct value_print_options *options,
                        int size, struct ui_file *stream)
 {
 
 void
 print_scalar_formatted (const void *valaddr, struct type *type,
                        const struct value_print_options *options,
                        int size, struct ui_file *stream)
 {

+  struct gdbarch *gdbarch = get_type_arch (type);

   LONGEST val_long = 0;
   unsigned int len = TYPE_LENGTH (type);
   LONGEST val_long = 0;
   unsigned int len = TYPE_LENGTH (type);

-  enum bfd_endian byte_order = gdbarch_byte_order (current_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

 
 

-  /* If we get here with a string format, try again without it.  Go
-     all the way back to the language printers, which may call us
-     again.  */
-  if (options->format == 's')
-    {
-      struct value_print_options opts = *options;
-      opts.format = 0;
-      opts.deref_ref = 0;
-      val_print (type, valaddr, 0, 0, stream, 0, &opts,
-                current_language);
-      return;
-    }
+  /* String printing should go through val_print_scalar_formatted.  */
+  gdb_assert (options->format != 's');

 
   if (len > sizeof(LONGEST) &&
       (TYPE_CODE (type) == TYPE_CODE_INT
 
   if (len > sizeof(LONGEST) &&
       (TYPE_CODE (type) == TYPE_CODE_INT


@@ -367,7 +398,7 @@ print_scalar_formatted (const void *valaddr, struct type *type,
          print_hex_chars (stream, valaddr, len, byte_order);
          return;
        case 'c':
          print_hex_chars (stream, valaddr, len, byte_order);
          return;
        case 'c':

-         print_char_chars (stream, valaddr, len, byte_order);
+         print_char_chars (stream, type, valaddr, len, byte_order);

          return;
        default:
          break;
          return;
        default:
          break;


@@ -381,12 +412,12 @@ print_scalar_formatted (const void *valaddr, struct type *type,
      same, then at this point, the value's length (in target bytes) is
      gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type).  */
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
      same, then at this point, the value's length (in target bytes) is
      gdbarch_addr_bit/TARGET_CHAR_BIT, not TYPE_LENGTH (type).  */
   if (TYPE_CODE (type) == TYPE_CODE_PTR)

-    len = gdbarch_addr_bit (current_gdbarch) / TARGET_CHAR_BIT;
+    len = gdbarch_addr_bit (gdbarch) / TARGET_CHAR_BIT;

 
   /* If we are printing it as unsigned, truncate it in case it is actually
      a negative signed value (e.g. "print/u (short)-1" should print 65535
      (if shorts are 16 bits) instead of 4294967295).  */
 
   /* If we are printing it as unsigned, truncate it in case it is actually
      a negative signed value (e.g. "print/u (short)-1" should print 65535
      (if shorts are 16 bits) instead of 4294967295).  */

-  if (options->format != 'd')
+  if (options->format != 'd' || TYPE_UNSIGNED (type))

     {
       if (len < sizeof (LONGEST))
        val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
     {
       if (len < sizeof (LONGEST))
        val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;


@@ -432,26 +463,27 @@ print_scalar_formatted (const void *valaddr, struct type *type,
     case 'a':
       {
        CORE_ADDR addr = unpack_pointer (type, valaddr);
     case 'a':
       {
        CORE_ADDR addr = unpack_pointer (type, valaddr);

-       print_address (addr, stream);
+
+       print_address (gdbarch, addr, stream);

       }
       break;
 
     case 'c':
       {
        struct value_print_options opts = *options;
       }
       break;
 
     case 'c':
       {
        struct value_print_options opts = *options;

+

        opts.format = 0;
        if (TYPE_UNSIGNED (type))
        opts.format = 0;
        if (TYPE_UNSIGNED (type))

-         value_print (value_from_longest (builtin_type_true_unsigned_char,
-                                          val_long),
-                      stream, &opts);
-       else
-         value_print (value_from_longest (builtin_type_true_char, val_long),
-                      stream, &opts);
+         type = builtin_type (gdbarch)->builtin_true_unsigned_char;
+       else
+         type = builtin_type (gdbarch)->builtin_true_char;
+
+       value_print (value_from_longest (type, val_long), stream, &opts);

       }
       break;
 
     case 'f':
       }
       break;
 
     case 'f':

-      type = float_type_from_length (current_gdbarch, type);
+      type = float_type_from_length (type);

       print_floating (valaddr, type, stream);
       break;
 
       print_floating (valaddr, type, stream);
       break;
 


@@ -519,6 +551,7 @@ set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 
 {
   struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
 

+  next_gdbarch = gdbarch;

   next_address = addr;
 
   /* Make address available to the user as $_.  */
   next_address = addr;
 
   /* Make address available to the user as $_.  */


@@ -535,7 +568,8 @@ set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
    settings of the demangle and asm_demangle variables.  */
 
 void
    settings of the demangle and asm_demangle variables.  */
 
 void

-print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
+print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
+                       struct ui_file *stream,

                        int do_demangle, char *leadin)
 {
   char *name = NULL;
                        int do_demangle, char *leadin)
 {
   char *name = NULL;


@@ -548,7 +582,7 @@ print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
   make_cleanup (free_current_contents, &filename);
 
   struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
   make_cleanup (free_current_contents, &filename);
 

-  if (build_address_symbolic (addr, do_demangle, &name, &offset,
+  if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,

                              &filename, &line, &unmapped))
     {
       do_cleanups (cleanup_chain);
                              &filename, &line, &unmapped))
     {
       do_cleanups (cleanup_chain);


@@ -582,13 +616,14 @@ print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
 }
 
 /* Given an address ADDR return all the elements needed to print the
 }
 
 /* Given an address ADDR return all the elements needed to print the

-   address in a symbolic form. NAME can be mangled or not depending
+   address in a symbolic form.  NAME can be mangled or not depending

    on DO_DEMANGLE (and also on the asm_demangle global variable,
    on DO_DEMANGLE (and also on the asm_demangle global variable,

-   manipulated via ''set print asm-demangle''). Return 0 in case of
-   success, when all the info in the OUT paramters is valid. Return 1
-   otherwise. */
+   manipulated via ''set print asm-demangle'').  Return 0 in case of
+   success, when all the info in the OUT paramters is valid.  Return 1
+   otherwise.  */

 int
 int

-build_address_symbolic (CORE_ADDR addr,  /* IN */
+build_address_symbolic (struct gdbarch *gdbarch,
+                       CORE_ADDR addr,  /* IN */

                        int do_demangle, /* IN */
                        char **name,     /* OUT */
                        int *offset,     /* OUT */
                        int do_demangle, /* IN */
                        char **name,     /* OUT */
                        int *offset,     /* OUT */


@@ -602,7 +637,7 @@ build_address_symbolic (CORE_ADDR addr,  /* IN */
   struct obj_section *section = NULL;
   char *name_temp = "";
   
   struct obj_section *section = NULL;
   char *name_temp = "";
   

-  /* Let's say it is unmapped.  */
+  /* Let's say it is mapped (not unmapped).  */

   *unmapped = 0;
 
   /* Determine if the address is in an overlay, and whether it is
   *unmapped = 0;
 
   /* Determine if the address is in an overlay, and whether it is


@@ -631,6 +666,13 @@ build_address_symbolic (CORE_ADDR addr,  /* IN */
 
   if (symbol)
     {
 
   if (symbol)
     {

+      /* If this is a function (i.e. a code address), strip out any
+        non-address bits.  For instance, display a pointer to the
+        first instruction of a Thumb function as <function>; the
+        second instruction will be <function+2>, even though the
+        pointer is <function+3>.  This matches the ISA behavior.  */
+      addr = gdbarch_addr_bits_remove (gdbarch, addr);
+

       name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
       if (do_demangle || asm_demangle)
        name_temp = SYMBOL_PRINT_NAME (symbol);
       name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
       if (do_demangle || asm_demangle)
        name_temp = SYMBOL_PRINT_NAME (symbol);


@@ -691,10 +733,31 @@ build_address_symbolic (CORE_ADDR addr,  /* IN */
    <SYMBOL + OFFSET> after the number.  */
 
 void
    <SYMBOL + OFFSET> after the number.  */
 
 void

-print_address (CORE_ADDR addr, struct ui_file *stream)
+print_address (struct gdbarch *gdbarch,
+              CORE_ADDR addr, struct ui_file *stream)

 {
 {

-  fputs_filtered (paddress (addr), stream);
-  print_address_symbolic (addr, stream, asm_demangle, " ");
+  fputs_filtered (paddress (gdbarch, addr), stream);
+  print_address_symbolic (gdbarch, addr, stream, asm_demangle, " ");
+}
+
+/* Return a prefix for instruction address:
+   "=> " for current instruction, else "   ".  */
+
+const char *
+pc_prefix (CORE_ADDR addr)
+{
+  if (has_stack_frames ())
+    {
+      struct frame_info *frame;
+      CORE_ADDR pc;
+
+      frame = get_selected_frame (NULL);
+      pc = get_frame_pc (frame);
+
+      if (pc == addr)
+       return "=> ";
+    }
+  return "   ";

 }
 
 /* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE
 }
 
 /* Print address ADDR symbolically on STREAM.  Parameter DEMANGLE


@@ -703,10 +766,11 @@ print_address (CORE_ADDR addr, struct ui_file *stream)
    or not.  */
 
 void
    or not.  */
 
 void

-print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
-                       int do_demangle)
+print_address_demangle (struct gdbarch *gdbarch, CORE_ADDR addr,
+                       struct ui_file *stream, int do_demangle)

 {
   struct value_print_options opts;
 {
   struct value_print_options opts;

+

   get_user_print_options (&opts);
   if (addr == 0)
     {
   get_user_print_options (&opts);
   if (addr == 0)
     {


@@ -714,31 +778,21 @@ print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
     }
   else if (opts.addressprint)
     {
     }
   else if (opts.addressprint)
     {

-      fputs_filtered (paddress (addr), stream);
-      print_address_symbolic (addr, stream, do_demangle, " ");
+      fputs_filtered (paddress (gdbarch, addr), stream);
+      print_address_symbolic (gdbarch, addr, stream, do_demangle, " ");

     }
   else
     {
     }
   else
     {

-      print_address_symbolic (addr, stream, do_demangle, "");
+      print_address_symbolic (gdbarch, addr, stream, do_demangle, "");

     }
 }
 \f
 
     }
 }
 \f
 

-/* These are the types that $__ will get after an examine command of one
-   of these sizes.  */
-
-static struct type *examine_i_type;
-
-static struct type *examine_b_type;
-static struct type *examine_h_type;
-static struct type *examine_w_type;
-static struct type *examine_g_type;
-

 /* Examine data at address ADDR in format FMT.
    Fetch it from memory and print on gdb_stdout.  */
 
 static void
 /* Examine data at address ADDR in format FMT.
    Fetch it from memory and print on gdb_stdout.  */
 
 static void

-do_examine (struct format_data fmt, CORE_ADDR addr)
+do_examine (struct format_data fmt, struct gdbarch *gdbarch, CORE_ADDR addr)

 {
   char format = 0;
   char size;
 {
   char format = 0;
   char size;


@@ -751,23 +805,61 @@ do_examine (struct format_data fmt, CORE_ADDR addr)
   format = fmt.format;
   size = fmt.size;
   count = fmt.count;
   format = fmt.format;
   size = fmt.size;
   count = fmt.count;

+  next_gdbarch = gdbarch;

   next_address = addr;
 
   next_address = addr;
 

-  /* String or instruction format implies fetch single bytes
-     regardless of the specified size.  */
-  if (format == 's' || format == 'i')
+  /* Instruction format implies fetch single bytes
+     regardless of the specified size.
+     The case of strings is handled in decode_format, only explicit
+     size operator are not changed to 'b'.  */
+  if (format == 'i')

     size = 'b';
 
     size = 'b';
 

-  if (format == 'i')
-    val_type = examine_i_type;
-  else if (size == 'b')
-    val_type = examine_b_type;
+  if (size == 'a')
+    {
+      /* Pick the appropriate size for an address.  */
+      if (gdbarch_ptr_bit (next_gdbarch) == 64)
+       size = 'g';
+      else if (gdbarch_ptr_bit (next_gdbarch) == 32)
+       size = 'w';
+      else if (gdbarch_ptr_bit (next_gdbarch) == 16)
+       size = 'h';
+      else
+       /* Bad value for gdbarch_ptr_bit.  */
+       internal_error (__FILE__, __LINE__,
+                       _("failed internal consistency check"));
+    }
+
+  if (size == 'b')
+    val_type = builtin_type (next_gdbarch)->builtin_int8;

   else if (size == 'h')
   else if (size == 'h')

-    val_type = examine_h_type;
+    val_type = builtin_type (next_gdbarch)->builtin_int16;

   else if (size == 'w')
   else if (size == 'w')

-    val_type = examine_w_type;
+    val_type = builtin_type (next_gdbarch)->builtin_int32;

   else if (size == 'g')
   else if (size == 'g')

-    val_type = examine_g_type;
+    val_type = builtin_type (next_gdbarch)->builtin_int64;
+
+  if (format == 's')
+    {
+      struct type *char_type = NULL;
+
+      /* Search for "char16_t"  or "char32_t" types or fall back to 8-bit char
+        if type is not found.  */
+      if (size == 'h')
+       char_type = builtin_type (next_gdbarch)->builtin_char16;
+      else if (size == 'w')
+       char_type = builtin_type (next_gdbarch)->builtin_char32;
+      if (char_type)
+        val_type = char_type;
+      else
+        {
+         if (size != '\0' && size != 'b')
+           warning (_("Unable to display strings with "
+                      "size '%c', using 'b' instead."), size);
+         size = 'b';
+         val_type = builtin_type (next_gdbarch)->builtin_int8;
+        }
+    }

 
   maxelts = 8;
   if (size == 'w')
 
   maxelts = 8;
   if (size == 'w')


@@ -785,7 +877,9 @@ do_examine (struct format_data fmt, CORE_ADDR addr)
   while (count > 0)
     {
       QUIT;
   while (count > 0)
     {
       QUIT;

-      print_address (next_address, gdb_stdout);
+      if (format == 'i')
+       fputs_filtered (pc_prefix (next_address), gdb_stdout);
+      print_address (next_gdbarch, next_address, gdb_stdout);

       printf_filtered (":");
       for (i = maxelts;
           i > 0 && count > 0;
       printf_filtered (":");
       for (i = maxelts;
           i > 0 && count > 0;


@@ -807,7 +901,7 @@ do_examine (struct format_data fmt, CORE_ADDR addr)
             the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
             the disassembler be modified so that LAST_EXAMINE_VALUE
             is left with the byte sequence from the last complete
             the address stored in LAST_EXAMINE_VALUE.  FIXME: Should
             the disassembler be modified so that LAST_EXAMINE_VALUE
             is left with the byte sequence from the last complete

-            instruction fetched from memory? */
+            instruction fetched from memory?  */

          last_examine_value = value_at_lazy (val_type, next_address);
 
          if (last_examine_value)
          last_examine_value = value_at_lazy (val_type, next_address);
 
          if (last_examine_value)


@@ -863,11 +957,11 @@ print_command_1 (char *exp, int inspect, int voidprint)
       fmt.count = 1;
       fmt.format = 0;
       fmt.size = 0;
       fmt.count = 1;
       fmt.format = 0;
       fmt.size = 0;

+      fmt.raw = 0;

     }
 
   if (exp && *exp)
     {
     }
 
   if (exp && *exp)
     {

-      struct type *type;

       expr = parse_expression (exp);
       old_chain = make_cleanup (free_current_contents, &expr);
       cleanup = 1;
       expr = parse_expression (exp);
       old_chain = make_cleanup (free_current_contents, &expr);
       cleanup = 1;


@@ -898,6 +992,7 @@ print_command_1 (char *exp, int inspect, int voidprint)
 
       get_formatted_print_options (&opts, format);
       opts.inspect_it = inspect;
 
       get_formatted_print_options (&opts, format);
       opts.inspect_it = inspect;

+      opts.raw = fmt.raw;

 
       print_formatted (val, fmt.size, &opts, gdb_stdout);
       printf_filtered ("\n");
 
       print_formatted (val, fmt.size, &opts, gdb_stdout);
       printf_filtered ("\n");


@@ -948,6 +1043,7 @@ output_command (char *exp, int from_tty)
   struct value_print_options opts;
 
   fmt.size = 0;
   struct value_print_options opts;
 
   fmt.size = 0;

+  fmt.raw = 0;

 
   if (exp && *exp == '/')
     {
 
   if (exp && *exp == '/')
     {


@@ -965,6 +1061,7 @@ output_command (char *exp, int from_tty)
   annotate_value_begin (value_type (val));
 
   get_formatted_print_options (&opts, format);
   annotate_value_begin (value_type (val));
 
   get_formatted_print_options (&opts, format);

+  opts.raw = fmt.raw;

   print_formatted (val, fmt.size, &opts, gdb_stdout);
 
   annotate_value_end ();
   print_formatted (val, fmt.size, &opts, gdb_stdout);
 
   annotate_value_end ();


@@ -981,6 +1078,7 @@ set_command (char *exp, int from_tty)
   struct expression *expr = parse_expression (exp);
   struct cleanup *old_chain =
     make_cleanup (free_current_contents, &expr);
   struct expression *expr = parse_expression (exp);
   struct cleanup *old_chain =
     make_cleanup (free_current_contents, &expr);

+

   evaluate_expression (expr);
   do_cleanups (old_chain);
 }
   evaluate_expression (expr);
   do_cleanups (old_chain);
 }


@@ -1012,21 +1110,65 @@ sym_info (char *arg, int from_tty)
        && sect_addr < obj_section_endaddr (osect)
        && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
       {
        && sect_addr < obj_section_endaddr (osect)
        && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
       {

+       const char *obj_name, *mapped, *sec_name, *msym_name;
+       char *loc_string;
+       struct cleanup *old_chain;
+

        matches = 1;
        offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
        matches = 1;
        offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);

+       mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
+       sec_name = osect->the_bfd_section->name;
+       msym_name = SYMBOL_PRINT_NAME (msymbol);
+
+       /* Don't print the offset if it is zero.
+          We assume there's no need to handle i18n of "sym + offset".  */

        if (offset)
        if (offset)

-         printf_filtered ("%s + %u in ",
-                          SYMBOL_PRINT_NAME (msymbol), offset);
+         loc_string = xstrprintf ("%s + %u", msym_name, offset);

        else
        else

-         printf_filtered ("%s in ",
-                          SYMBOL_PRINT_NAME (msymbol));
-       if (pc_in_unmapped_range (addr, osect))
-         printf_filtered (_("load address range of "));
-       if (section_is_overlay (osect))
-         printf_filtered (_("%s overlay "),
-                          section_is_mapped (osect) ? "mapped" : "unmapped");
-       printf_filtered (_("section %s"), osect->the_bfd_section->name);
-       printf_filtered ("\n");
+         loc_string = xstrprintf ("%s", msym_name);
+
+       /* Use a cleanup to free loc_string in case the user quits
+          a pagination request inside printf_filtered.  */
+       old_chain = make_cleanup (xfree, loc_string);
+
+       gdb_assert (osect->objfile && osect->objfile->name);
+       obj_name = osect->objfile->name;
+
+       if (MULTI_OBJFILE_P ())
+         if (pc_in_unmapped_range (addr, osect))
+           if (section_is_overlay (osect))
+             printf_filtered (_("%s in load address range of "
+                                "%s overlay section %s of %s\n"),
+                              loc_string, mapped, sec_name, obj_name);
+           else
+             printf_filtered (_("%s in load address range of "
+                                "section %s of %s\n"),
+                              loc_string, sec_name, obj_name);
+         else
+           if (section_is_overlay (osect))
+             printf_filtered (_("%s in %s overlay section %s of %s\n"),
+                              loc_string, mapped, sec_name, obj_name);
+           else
+             printf_filtered (_("%s in section %s of %s\n"),
+                              loc_string, sec_name, obj_name);
+       else
+         if (pc_in_unmapped_range (addr, osect))
+           if (section_is_overlay (osect))
+             printf_filtered (_("%s in load address range of %s overlay "
+                                "section %s\n"),
+                              loc_string, mapped, sec_name);
+           else
+             printf_filtered (_("%s in load address range of section %s\n"),
+                              loc_string, sec_name);
+         else
+           if (section_is_overlay (osect))
+             printf_filtered (_("%s in %s overlay section %s\n"),
+                              loc_string, mapped, sec_name);
+           else
+             printf_filtered (_("%s in section %s\n"),
+                              loc_string, sec_name);
+
+       do_cleanups (old_chain);

       }
   }
   if (matches == 0)
       }
   }
   if (matches == 0)


@@ -1036,18 +1178,20 @@ sym_info (char *arg, int from_tty)
 static void
 address_info (char *exp, int from_tty)
 {
 static void
 address_info (char *exp, int from_tty)
 {

+  struct gdbarch *gdbarch;
+  int regno;

   struct symbol *sym;
   struct minimal_symbol *msymbol;
   long val;
   struct obj_section *section;
   struct symbol *sym;
   struct minimal_symbol *msymbol;
   long val;
   struct obj_section *section;

-  CORE_ADDR load_addr;
+  CORE_ADDR load_addr, context_pc = 0;

   int is_a_field_of_this;      /* C++: lookup_symbol sets this to nonzero
   int is_a_field_of_this;      /* C++: lookup_symbol sets this to nonzero

-                                  if exp is a field of `this'. */
+                                  if exp is a field of `this'.  */

 
   if (exp == 0)
     error (_("Argument required."));
 
 
   if (exp == 0)
     error (_("Argument required."));
 

-  sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
+  sym = lookup_symbol (exp, get_selected_block (&context_pc), VAR_DOMAIN,

                       &is_a_field_of_this);
   if (sym == NULL)
     {
                       &is_a_field_of_this);
   if (sym == NULL)
     {


@@ -1068,20 +1212,21 @@ address_info (char *exp, int from_tty)
 
       if (msymbol != NULL)
        {
 
       if (msymbol != NULL)
        {

+         gdbarch = get_objfile_arch (msymbol_objfile (msymbol));

          load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
 
          printf_filtered ("Symbol \"");
          fprintf_symbol_filtered (gdb_stdout, exp,
                                   current_language->la_language, DMGL_ANSI);
          printf_filtered ("\" is at ");
          load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
 
          printf_filtered ("Symbol \"");
          fprintf_symbol_filtered (gdb_stdout, exp,
                                   current_language->la_language, DMGL_ANSI);
          printf_filtered ("\" is at ");

-         fputs_filtered (paddress (load_addr), gdb_stdout);
+         fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

          printf_filtered (" in a file compiled without debugging");
          section = SYMBOL_OBJ_SECTION (msymbol);
          if (section_is_overlay (section))
            {
              load_addr = overlay_unmapped_address (load_addr, section);
              printf_filtered (",\n -- loaded at ");
          printf_filtered (" in a file compiled without debugging");
          section = SYMBOL_OBJ_SECTION (msymbol);
          if (section_is_overlay (section))
            {
              load_addr = overlay_unmapped_address (load_addr, section);
              printf_filtered (",\n -- loaded at ");

-             fputs_filtered (paddress (load_addr), gdb_stdout);
+             fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

              printf_filtered (" in overlay section %s",
                               section->the_bfd_section->name);
            }
              printf_filtered (" in overlay section %s",
                               section->the_bfd_section->name);
            }


@@ -1098,6 +1243,7 @@ address_info (char *exp, int from_tty)
   printf_filtered ("\" is ");
   val = SYMBOL_VALUE (sym);
   section = SYMBOL_OBJ_SECTION (sym);
   printf_filtered ("\" is ");
   val = SYMBOL_VALUE (sym);
   section = SYMBOL_OBJ_SECTION (sym);

+  gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);

 
   switch (SYMBOL_CLASS (sym))
     {
 
   switch (SYMBOL_CLASS (sym))
     {


@@ -1108,13 +1254,13 @@ address_info (char *exp, int from_tty)
 
     case LOC_LABEL:
       printf_filtered ("a label at address ");
 
     case LOC_LABEL:
       printf_filtered ("a label at address ");

-      fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
-                     gdb_stdout);
+      load_addr = SYMBOL_VALUE_ADDRESS (sym);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (",\n -- loaded at ");
       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (",\n -- loaded at ");

-         fputs_filtered (paddress (load_addr), gdb_stdout);
+         fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

          printf_filtered (" in overlay section %s",
                           section->the_bfd_section->name);
        }
          printf_filtered (" in overlay section %s",
                           section->the_bfd_section->name);
        }


@@ -1122,39 +1268,50 @@ address_info (char *exp, int from_tty)
 
     case LOC_COMPUTED:
       /* FIXME: cagney/2004-01-26: It should be possible to
 
     case LOC_COMPUTED:
       /* FIXME: cagney/2004-01-26: It should be possible to

-        unconditionally call the SYMBOL_OPS method when available.
+        unconditionally call the SYMBOL_COMPUTED_OPS method when available.

         Unfortunately DWARF 2 stores the frame-base (instead of the
         function) location in a function's symbol.  Oops!  For the
         moment enable this when/where applicable.  */
         Unfortunately DWARF 2 stores the frame-base (instead of the
         function) location in a function's symbol.  Oops!  For the
         moment enable this when/where applicable.  */

-      SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
+      SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
+                                                   gdb_stdout);

       break;
 
     case LOC_REGISTER:
       break;
 
     case LOC_REGISTER:

+      /* GDBARCH is the architecture associated with the objfile the symbol
+        is defined in; the target architecture may be different, and may
+        provide additional registers.  However, we do not know the target
+        architecture at this point.  We assume the objfile architecture
+        will contain all the standard registers that occur in debug info
+        in that objfile.  */
+      regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
+

       if (SYMBOL_IS_ARGUMENT (sym))
        printf_filtered (_("an argument in register %s"),
       if (SYMBOL_IS_ARGUMENT (sym))
        printf_filtered (_("an argument in register %s"),

-                        gdbarch_register_name (current_gdbarch, val));
+                        gdbarch_register_name (gdbarch, regno));

       else
        printf_filtered (_("a variable in register %s"),
       else
        printf_filtered (_("a variable in register %s"),

-                        gdbarch_register_name (current_gdbarch, val));
+                        gdbarch_register_name (gdbarch, regno));

       break;
 
     case LOC_STATIC:
       printf_filtered (_("static storage at address "));
       break;
 
     case LOC_STATIC:
       printf_filtered (_("static storage at address "));

-     fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
-                    gdb_stdout);
+      load_addr = SYMBOL_VALUE_ADDRESS (sym);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (_(",\n -- loaded at "));
       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (_(",\n -- loaded at "));

-         fputs_filtered (paddress (load_addr), gdb_stdout);
+         fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

          printf_filtered (_(" in overlay section %s"),
                           section->the_bfd_section->name);
        }
       break;
 
     case LOC_REGPARM_ADDR:
          printf_filtered (_(" in overlay section %s"),
                           section->the_bfd_section->name);
        }
       break;
 
     case LOC_REGPARM_ADDR:

+      /* Note comment at LOC_REGISTER.  */
+      regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);

       printf_filtered (_("address of an argument in register %s"),
       printf_filtered (_("address of an argument in register %s"),

-                      gdbarch_register_name (current_gdbarch, val));
+                      gdbarch_register_name (gdbarch, regno));

       break;
 
     case LOC_ARG:
       break;
 
     case LOC_ARG:


@@ -1176,12 +1333,12 @@ address_info (char *exp, int from_tty)
     case LOC_BLOCK:
       printf_filtered (_("a function at address "));
       load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
     case LOC_BLOCK:
       printf_filtered (_("a function at address "));
       load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));

-      fputs_filtered (paddress (load_addr), gdb_stdout);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (_(",\n -- loaded at "));
       if (section_is_overlay (section))
        {
          load_addr = overlay_unmapped_address (load_addr, section);
          printf_filtered (_(",\n -- loaded at "));

-         fputs_filtered (paddress (load_addr), gdb_stdout);
+         fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);

          printf_filtered (_(" in overlay section %s"),
                           section->the_bfd_section->name);
        }
          printf_filtered (_(" in overlay section %s"),
                           section->the_bfd_section->name);
        }


@@ -1197,16 +1354,26 @@ address_info (char *exp, int from_tty)
        else
          {
            section = SYMBOL_OBJ_SECTION (msym);
        else
          {
            section = SYMBOL_OBJ_SECTION (msym);

-           printf_filtered (_("static storage at address "));

            load_addr = SYMBOL_VALUE_ADDRESS (msym);
            load_addr = SYMBOL_VALUE_ADDRESS (msym);

-           fputs_filtered (paddress (load_addr), gdb_stdout);
-           if (section_is_overlay (section))
+
+           if (section
+               && (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
+             printf_filtered (_("a thread-local variable at offset %s "
+                                "in the thread-local storage for `%s'"),
+                              paddress (gdbarch, load_addr),
+                              section->objfile->name);
+           else

              {
              {

-               load_addr = overlay_unmapped_address (load_addr, section);
-               printf_filtered (_(",\n -- loaded at "));
-               fputs_filtered (paddress (load_addr), gdb_stdout);
-               printf_filtered (_(" in overlay section %s"),
-                                section->the_bfd_section->name);
+               printf_filtered (_("static storage at address "));
+               fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
+               if (section_is_overlay (section))
+                 {
+                   load_addr = overlay_unmapped_address (load_addr, section);
+                   printf_filtered (_(",\n -- loaded at "));
+                   fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
+                   printf_filtered (_(" in overlay section %s"),
+                                    section->the_bfd_section->name);
+                 }

              }
          }
       }
              }
          }
       }


@@ -1232,9 +1399,10 @@ x_command (char *exp, int from_tty)
   struct cleanup *old_chain;
   struct value *val;
 
   struct cleanup *old_chain;
   struct value *val;
 

-  fmt.format = last_format;
+  fmt.format = last_format ? last_format : 'x';

   fmt.size = last_size;
   fmt.count = 1;
   fmt.size = last_size;
   fmt.count = 1;

+  fmt.raw = 0;

 
   if (exp && *exp == '/')
     {
 
   if (exp && *exp == '/')
     {


@@ -1255,26 +1423,34 @@ x_command (char *exp, int from_tty)
       old_chain = make_cleanup (free_current_contents, &expr);
       val = evaluate_expression (expr);
       if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
       old_chain = make_cleanup (free_current_contents, &expr);
       val = evaluate_expression (expr);
       if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)

-       val = value_ind (val);
+       val = coerce_ref (val);

       /* In rvalue contexts, such as this, functions are coerced into
          pointers to functions.  This makes "x/i main" work.  */
       if (/* last_format == 'i'  && */ 
          TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
           && VALUE_LVAL (val) == lval_memory)
       /* In rvalue contexts, such as this, functions are coerced into
          pointers to functions.  This makes "x/i main" work.  */
       if (/* last_format == 'i'  && */ 
          TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
           && VALUE_LVAL (val) == lval_memory)

-       next_address = VALUE_ADDRESS (val);
+       next_address = value_address (val);

       else
        next_address = value_as_address (val);
       else
        next_address = value_as_address (val);

+
+      next_gdbarch = expr->gdbarch;

       do_cleanups (old_chain);
     }
 
       do_cleanups (old_chain);
     }
 

-  do_examine (fmt, next_address);
+  if (!next_gdbarch)
+    error_no_arg (_("starting display address"));
+
+  do_examine (fmt, next_gdbarch, next_address);

 
   /* If the examine succeeds, we remember its size and format for next
 
   /* If the examine succeeds, we remember its size and format for next

-     time.  */
-  last_size = fmt.size;
+     time.  Set last_size to 'b' for strings.  */
+  if (fmt.format == 's')
+    last_size = 'b';
+  else
+    last_size = fmt.size;

   last_format = fmt.format;
 
   last_format = fmt.format;
 

-  /* Set a couple of internal variables if appropriate. */
+  /* Set a couple of internal variables if appropriate.  */

   if (last_examine_value)
     {
       /* Make last address examined available to the user as $_.  Use
   if (last_examine_value)
     {
       /* Make last address examined available to the user as $_.  Use


@@ -1290,8 +1466,7 @@ x_command (char *exp, int from_tty)
         then don't fetch it now; instead mark it by voiding the $__
         variable.  */
       if (value_lazy (last_examine_value))
         then don't fetch it now; instead mark it by voiding the $__
         variable.  */
       if (value_lazy (last_examine_value))

-       set_internalvar (lookup_internalvar ("__"),
-                        allocate_value (builtin_type_void));
+       clear_internalvar (lookup_internalvar ("__"));

       else
        set_internalvar (lookup_internalvar ("__"), last_examine_value);
     }
       else
        set_internalvar (lookup_internalvar ("__"), last_examine_value);
     }


@@ -1338,15 +1513,18 @@ display_command (char *exp, int from_tty)
          fmt.format = 0;
          fmt.size = 0;
          fmt.count = 0;
          fmt.format = 0;
          fmt.size = 0;
          fmt.count = 0;

+         fmt.raw = 0;

        }
 
        }
 

-      innermost_block = 0;
+      innermost_block = NULL;

       expr = parse_expression (exp);
 
       new = (struct display *) xmalloc (sizeof (struct display));
 
       expr = parse_expression (exp);
 
       new = (struct display *) xmalloc (sizeof (struct display));
 

+      new->exp_string = xstrdup (exp);

       new->exp = expr;
       new->block = innermost_block;
       new->exp = expr;
       new->block = innermost_block;

+      new->pspace = current_program_space;

       new->next = display_chain;
       new->number = ++display_number;
       new->format = fmt;
       new->next = display_chain;
       new->number = ++display_number;
       new->format = fmt;


@@ -1363,6 +1541,7 @@ display_command (char *exp, int from_tty)
 static void
 free_display (struct display *d)
 {
 static void
 free_display (struct display *d)
 {

+  xfree (d->exp_string);

   xfree (d->exp);
   xfree (d);
 }
   xfree (d->exp);
   xfree (d);
 }


@@ -1377,41 +1556,31 @@ clear_displays (void)
 
   while ((d = display_chain) != NULL)
     {
 
   while ((d = display_chain) != NULL)
     {

-      xfree (d->exp);

       display_chain = d->next;
       display_chain = d->next;

-      xfree (d);
+      free_display (d);

     }
 }
 
     }
 }
 

-/* Delete the auto-display number NUM.  */
+/* Delete the auto-display DISPLAY.  */

 
 static void
 
 static void

-delete_display (int num)
+delete_display (struct display *display)

 {
 {

-  struct display *d1, *d;
+  struct display *d;

 
 

-  if (!display_chain)
-    error (_("No display number %d."), num);
+  gdb_assert (display != NULL);

 
 

-  if (display_chain->number == num)
-    {
-      d1 = display_chain;
-      display_chain = d1->next;
-      free_display (d1);
-    }
-  else
-    for (d = display_chain;; d = d->next)
+  if (display_chain == display)
+    display_chain = display->next;
+
+  ALL_DISPLAYS (d)
+    if (d->next == display)

       {
       {

-       if (d->next == 0)
-         error (_("No display number %d."), num);
-       if (d->next->number == num)
-         {
-           d1 = d->next;
-           d->next = d1->next;
-           free_display (d1);
-           break;
-         }
+       d->next = display->next;
+       break;

       }
       }

+
+  free_display (display);

 }
 
 /* Delete some values from the auto-display chain.
 }
 
 /* Delete some values from the auto-display chain.


@@ -1426,7 +1595,7 @@ undisplay_command (char *args, int from_tty)
 
   if (args == 0)
     {
 
   if (args == 0)
     {

-      if (query ("Delete all auto-display expressions? "))
+      if (query (_("Delete all auto-display expressions? ")))

        clear_displays ();
       dont_repeat ();
       return;
        clear_displays ();
       dont_repeat ();
       return;


@@ -1435,25 +1604,31 @@ undisplay_command (char *args, int from_tty)
   while (*p)
     {
       p1 = p;
   while (*p)
     {
       p1 = p;

-      while (*p1 >= '0' && *p1 <= '9')
-       p1++;
-      if (*p1 && *p1 != ' ' && *p1 != '\t')
-       error (_("Arguments must be display numbers."));

 
 

-      num = atoi (p);
+      num = get_number_or_range (&p1);
+      if (num == 0)
+       warning (_("bad display number at or near '%s'"), p);
+      else
+       {
+         struct display *d;

 
 

-      delete_display (num);
+         ALL_DISPLAYS (d)
+           if (d->number == num)
+             break;
+         if (d == NULL)
+           printf_unfiltered (_("No display number %d.\n"), num);
+         else
+           delete_display (d);
+       }

 
       p = p1;
 
       p = p1;

-      while (*p == ' ' || *p == '\t')
-       p++;

     }
   dont_repeat ();
 }
 
 /* Display a single auto-display.  
    Do nothing if the display cannot be printed in the current context,
     }
   dont_repeat ();
 }
 
 /* Display a single auto-display.  
    Do nothing if the display cannot be printed in the current context,

-   or if the display is disabled. */
+   or if the display is disabled.  */

 
 static void
 do_one_display (struct display *d)
 
 static void
 do_one_display (struct display *d)


@@ -1463,8 +1638,47 @@ do_one_display (struct display *d)
   if (d->enabled_p == 0)
     return;
 
   if (d->enabled_p == 0)
     return;
 

+  /* The expression carries the architecture that was used at parse time.
+     This is a problem if the expression depends on architecture features
+     (e.g. register numbers), and the current architecture is now different.
+     For example, a display statement like "display/i $pc" is expected to
+     display the PC register of the current architecture, not the arch at
+     the time the display command was given.  Therefore, we re-parse the
+     expression if the current architecture has changed.  */
+  if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
+    {
+      xfree (d->exp);
+      d->exp = NULL;
+      d->block = NULL;
+    }
+
+  if (d->exp == NULL)
+    {
+      volatile struct gdb_exception ex;
+
+      TRY_CATCH (ex, RETURN_MASK_ALL)
+       {
+         innermost_block = NULL;
+         d->exp = parse_expression (d->exp_string);
+         d->block = innermost_block;
+       }
+      if (ex.reason < 0)
+       {
+         /* Can't re-parse the expression.  Disable this display item.  */
+         d->enabled_p = 0;
+         warning (_("Unable to display \"%s\": %s"),
+                  d->exp_string, ex.message);
+         return;
+       }
+    }
+

   if (d->block)
   if (d->block)

-    within_current_scope = contained_in (get_selected_block (0), d->block);
+    {
+      if (d->pspace == current_program_space)
+       within_current_scope = contained_in (get_selected_block (0), d->block);
+      else
+       within_current_scope = 0;
+    }

   else
     within_current_scope = 1;
   if (!within_current_scope)
   else
     within_current_scope = 1;
   if (!within_current_scope)


@@ -1493,7 +1707,7 @@ do_one_display (struct display *d)
 
       annotate_display_expression ();
 
 
       annotate_display_expression ();
 

-      print_expression (d->exp, gdb_stdout);
+      puts_filtered (d->exp_string);

       annotate_display_expression_end ();
 
       if (d->format.count != 1 || d->format.format == 'i')
       annotate_display_expression_end ();
 
       if (d->format.count != 1 || d->format.format == 'i')


@@ -1504,11 +1718,11 @@ do_one_display (struct display *d)
       val = evaluate_expression (d->exp);
       addr = value_as_address (val);
       if (d->format.format == 'i')
       val = evaluate_expression (d->exp);
       addr = value_as_address (val);
       if (d->format.format == 'i')

-       addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
+       addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);

 
       annotate_display_value ();
 
 
       annotate_display_value ();
 

-      do_examine (d->format, addr);
+      do_examine (d->format, d->exp->gdbarch, addr);

     }
   else
     {
     }
   else
     {


@@ -1521,7 +1735,7 @@ do_one_display (struct display *d)
 
       annotate_display_expression ();
 
 
       annotate_display_expression ();
 

-      print_expression (d->exp, gdb_stdout);
+      puts_filtered (d->exp_string);

       annotate_display_expression_end ();
 
       printf_filtered (" = ");
       annotate_display_expression_end ();
 
       printf_filtered (" = ");


@@ -1529,6 +1743,7 @@ do_one_display (struct display *d)
       annotate_display_expression ();
 
       get_formatted_print_options (&opts, d->format.format);
       annotate_display_expression ();
 
       get_formatted_print_options (&opts, d->format.format);

+      opts.raw = d->format.raw;

       print_formatted (evaluate_expression (d->exp),
                       d->format.size, &opts, gdb_stdout);
       printf_filtered ("\n");
       print_formatted (evaluate_expression (d->exp),
                       d->format.size, &opts, gdb_stdout);
       printf_filtered ("\n");


@@ -1575,8 +1790,9 @@ disable_current_display (void)
   if (current_display_number >= 0)
     {
       disable_display (current_display_number);
   if (current_display_number >= 0)
     {
       disable_display (current_display_number);

-      fprintf_unfiltered (gdb_stderr, _("\
-Disabling display %d to avoid infinite recursion.\n"),
+      fprintf_unfiltered (gdb_stderr,
+                         _("Disabling display %d to "
+                           "avoid infinite recursion.\n"),

                          current_display_number);
     }
   current_display_number = -1;
                          current_display_number);
     }
   current_display_number = -1;


@@ -1601,7 +1817,7 @@ Num Enb Expression\n"));
                         d->format.format);
       else if (d->format.format)
        printf_filtered ("/%c ", d->format.format);
                         d->format.format);
       else if (d->format.format)
        printf_filtered ("/%c ", d->format.format);

-      print_expression (d->exp, gdb_stdout);
+      puts_filtered (d->exp_string);

       if (d->block && !contained_in (get_selected_block (0), d->block))
        printf_filtered (_(" (cannot be evaluated in the current context)"));
       printf_filtered ("\n");
       if (d->block && !contained_in (get_selected_block (0), d->block))
        printf_filtered (_(" (cannot be evaluated in the current context)"));
       printf_filtered ("\n");


@@ -1675,24 +1891,79 @@ disable_display_command (char *args, int from_tty)
          p++;
       }
 }
          p++;
       }
 }

+
+/* display_chain items point to blocks and expressions.  Some expressions in
+   turn may point to symbols.
+   Both symbols and blocks are obstack_alloc'd on objfile_stack, and are
+   obstack_free'd when a shared library is unloaded.
+   Clear pointers that are about to become dangling.
+   Both .exp and .block fields will be restored next time we need to display
+   an item by re-parsing .exp_string field in the new execution context.  */
+
+static void
+clear_dangling_display_expressions (struct so_list *solib)
+{
+  struct objfile *objfile = solib->objfile;
+  struct display *d;
+
+  /* With no symbol file we cannot have a block or expression from it.  */
+  if (objfile == NULL)
+    return;
+  if (objfile->separate_debug_objfile_backlink)
+    objfile = objfile->separate_debug_objfile_backlink;
+  gdb_assert (objfile->pspace == solib->pspace);
+
+  for (d = display_chain; d != NULL; d = d->next)
+    {
+      if (d->pspace != solib->pspace)
+       continue;
+
+      if (lookup_objfile_from_block (d->block) == objfile
+         || (d->exp && exp_uses_objfile (d->exp, objfile)))
+      {
+       xfree (d->exp);
+       d->exp = NULL;
+       d->block = NULL;
+      }
+    }
+}

 \f
 
 /* Print the value in stack frame FRAME of a variable specified by a
 \f
 
 /* Print the value in stack frame FRAME of a variable specified by a

-   struct symbol.  */
+   struct symbol.  NAME is the name to print; if NULL then VAR's print
+   name will be used.  STREAM is the ui_file on which to print the
+   value.  INDENT specifies the number of indent levels to print
+   before printing the variable name.  */

 
 void
 
 void

-print_variable_value (struct symbol *var, struct frame_info *frame,
-                     struct ui_file *stream)
+print_variable_and_value (const char *name, struct symbol *var,
+                         struct frame_info *frame,
+                         struct ui_file *stream, int indent)

 {
 {

-  struct value *val = read_var_value (var, frame);
-  struct value_print_options opts;
+  volatile struct gdb_exception except;

 
 

-  get_user_print_options (&opts);
-  value_print (val, stream, &opts);
+  if (!name)
+    name = SYMBOL_PRINT_NAME (var);
+
+  fprintf_filtered (stream, "%s%s = ", n_spaces (2 * indent), name);
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      struct value *val;
+      struct value_print_options opts;
+
+      val = read_var_value (var, frame);
+      get_user_print_options (&opts);
+      common_val_print (val, stream, indent, &opts, current_language);
+    }
+  if (except.reason < 0)
+    fprintf_filtered(stream, "<error reading variable %s (%s)>", name,
+                    except.message);
+  fprintf_filtered (stream, "\n");

 }
 
 }
 

-static void
-printf_command (char *arg, int from_tty)
+void
+string_printf (char *arg, struct ui_file *stream, printf_callback callback,
+              void *loc_v, void *aexpr_v)

 {
   char *f = NULL;
   char *s = arg;
 {
   char *f = NULL;
   char *s = arg;


@@ -1703,6 +1974,8 @@ printf_command (char *arg, int from_tty)
   int nargs = 0;
   int allocated_args = 20;
   struct cleanup *old_cleanups;
   int nargs = 0;
   int allocated_args = 20;
   struct cleanup *old_cleanups;

+  struct bp_location *loc = loc_v;
+  struct agent_expr *aexpr = aexpr_v;

 
   val_args = xmalloc (allocated_args * sizeof (struct value *));
   old_cleanups = make_cleanup (free_current_contents, &val_args);
 
   val_args = xmalloc (allocated_args * sizeof (struct value *));
   old_cleanups = make_cleanup (free_current_contents, &val_args);


@@ -1710,7 +1983,7 @@ printf_command (char *arg, int from_tty)
   if (s == 0)
     error_no_arg (_("format-control string and values to print"));
 
   if (s == 0)
     error_no_arg (_("format-control string and values to print"));
 

-  /* Skip white space before format string */
+  /* Skip white space before format string.  */

   while (*s == ' ' || *s == '\t')
     s++;
 
   while (*s == ' ' || *s == '\t')
     s++;
 


@@ -1762,7 +2035,7 @@ printf_command (char *arg, int from_tty)
              *f++ = '"';
              break;
            default:
              *f++ = '"';
              break;
            default:

-             /* ??? TODO: handle other escape sequences */
+             /* ??? TODO: handle other escape sequences.  */

              error (_("Unrecognized escape character \\%c in format string."),
                     c);
            }
              error (_("Unrecognized escape character \\%c in format string."),
                     c);
            }


@@ -1798,7 +2071,8 @@ printf_command (char *arg, int from_tty)
 
     enum argclass
       {
 
     enum argclass
       {

-       int_arg, long_arg, long_long_arg, ptr_arg, string_arg,
+       int_arg, long_arg, long_long_arg, ptr_arg,
+       string_arg, wide_string_arg, wide_char_arg,

        double_arg, long_double_arg, decfloat_arg
       };
     enum argclass *argclass;
        double_arg, long_double_arg, decfloat_arg
       };
     enum argclass *argclass;


@@ -1930,8 +2204,8 @@ printf_command (char *arg, int from_tty)
              break;
 
            case 'c':
              break;
 
            case 'c':

-             this_argclass = int_arg;
-             if (lcount || seen_h || seen_big_l)
+             this_argclass = lcount == 0 ? int_arg : wide_char_arg;
+             if (lcount > 1 || seen_h || seen_big_l)

                bad = 1;
              if (seen_prec || seen_zero || seen_space || seen_plus)
                bad = 1;
                bad = 1;
              if (seen_prec || seen_zero || seen_space || seen_plus)
                bad = 1;


@@ -1946,8 +2220,8 @@ printf_command (char *arg, int from_tty)
              break;
 
            case 's':
              break;
 
            case 's':

-             this_argclass = string_arg;
-             if (lcount || seen_h || seen_big_l)
+             this_argclass = lcount == 0 ? string_arg : wide_string_arg;
+             if (lcount > 1 || seen_h || seen_big_l)

                bad = 1;
              if (seen_zero || seen_space || seen_plus)
                bad = 1;
                bad = 1;
              if (seen_zero || seen_space || seen_plus)
                bad = 1;


@@ -1983,7 +2257,8 @@ printf_command (char *arg, int from_tty)
            }
 
          if (bad)
            }
 
          if (bad)

-           error (_("Inappropriate modifiers to format specifier '%c' in printf"),
+           error (_("Inappropriate modifiers to "
+                    "format specifier '%c' in printf"),

                   *f);
 
          f++;
                   *f);
 
          f++;


@@ -1993,12 +2268,23 @@ printf_command (char *arg, int from_tty)
              /* Windows' printf does support long long, but not the usual way.
                 Convert %lld to %I64d.  */
              int length_before_ll = f - last_arg - 1 - lcount;
              /* Windows' printf does support long long, but not the usual way.
                 Convert %lld to %I64d.  */
              int length_before_ll = f - last_arg - 1 - lcount;

+

              strncpy (current_substring, last_arg, length_before_ll);
              strcpy (current_substring + length_before_ll, "I64");
              current_substring[length_before_ll + 3] =
                last_arg[length_before_ll + lcount];
              current_substring += length_before_ll + 4;
            }
              strncpy (current_substring, last_arg, length_before_ll);
              strcpy (current_substring + length_before_ll, "I64");
              current_substring[length_before_ll + 3] =
                last_arg[length_before_ll + lcount];
              current_substring += length_before_ll + 4;
            }

+         else if (this_argclass == wide_string_arg
+                  || this_argclass == wide_char_arg)
+           {
+             /* Convert %ls or %lc to %s.  */
+             int length_before_ls = f - last_arg - 2;
+
+             strncpy (current_substring, last_arg, length_before_ls);
+             strcpy (current_substring + length_before_ls, "s");
+             current_substring += length_before_ls + 2;
+           }

          else
            {
              strncpy (current_substring, last_arg, f - last_arg);
          else
            {
              strncpy (current_substring, last_arg, f - last_arg);


@@ -2012,25 +2298,42 @@ printf_command (char *arg, int from_tty)
     /* Now, parse all arguments and evaluate them.
        Store the VALUEs in VAL_ARGS.  */
 
     /* Now, parse all arguments and evaluate them.
        Store the VALUEs in VAL_ARGS.  */
 

+    if (callback)
+      current_substring = substrings;

     while (*s != '\0')
       {
        char *s1;
     while (*s != '\0')
       {
        char *s1;

+
+       s1 = s;

        if (nargs == allocated_args)
          val_args = (struct value **) xrealloc ((char *) val_args,
                                                 (allocated_args *= 2)
                                                 * sizeof (struct value *));
        if (nargs == allocated_args)
          val_args = (struct value **) xrealloc ((char *) val_args,
                                                 (allocated_args *= 2)
                                                 * sizeof (struct value *));

-       s1 = s;
-       val_args[nargs] = parse_to_comma_and_eval (&s1);
+       if (callback)
+         {
+           if (nargs >= nargs_wanted)
+             error (_("Wrong number of arguments for specified "
+                      "format-string"));
+           callback (current_substring, &s1, loc, aexpr);
+           current_substring += strlen (current_substring) + 1;
+         }
+       else
+         val_args[nargs] = parse_to_comma_and_eval (&s1);

 
        nargs++;
        s = s1;
        if (*s == ',')
          s++;
       }
 
        nargs++;
        s = s1;
        if (*s == ',')
          s++;
       }

+    if (callback)
+      callback (last_arg, NULL, loc, aexpr);

 
     if (nargs != nargs_wanted)
       error (_("Wrong number of arguments for specified format-string"));
 
 
     if (nargs != nargs_wanted)
       error (_("Wrong number of arguments for specified format-string"));
 

+    if (!stream)
+      goto after_print;
+

     /* Now actually print them.  */
     current_substring = substrings;
     for (i = 0; i < nargs; i++)
     /* Now actually print them.  */
     current_substring = substrings;
     for (i = 0; i < nargs; i++)


@@ -2042,12 +2345,14 @@ printf_command (char *arg, int from_tty)
              gdb_byte *str;
              CORE_ADDR tem;
              int j;
              gdb_byte *str;
              CORE_ADDR tem;
              int j;

+

              tem = value_as_address (val_args[i]);
 
              /* This is a %s argument.  Find the length of the string.  */
              for (j = 0;; j++)
                {
                  gdb_byte c;
              tem = value_as_address (val_args[i]);
 
              /* This is a %s argument.  Find the length of the string.  */
              for (j = 0;; j++)
                {
                  gdb_byte c;

+

                  QUIT;
                  read_memory (tem + j, &c, 1);
                  if (c == 0)
                  QUIT;
                  read_memory (tem + j, &c, 1);
                  if (c == 0)


@@ -2060,7 +2365,86 @@ printf_command (char *arg, int from_tty)
                read_memory (tem, str, j);
              str[j] = 0;
 
                read_memory (tem, str, j);
              str[j] = 0;
 

-             printf_filtered (current_substring, (char *) str);
+              fprintf_filtered (stream, current_substring, (char *) str);
+           }
+           break;
+         case wide_string_arg:
+           {
+             gdb_byte *str;
+             CORE_ADDR tem;
+             int j;
+             struct gdbarch *gdbarch
+               = get_type_arch (value_type (val_args[i]));
+             enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+             struct type *wctype = lookup_typename (current_language, gdbarch,
+                                                    "wchar_t", NULL, 0);
+             int wcwidth = TYPE_LENGTH (wctype);
+             gdb_byte *buf = alloca (wcwidth);
+             struct obstack output;
+             struct cleanup *inner_cleanup;
+
+             tem = value_as_address (val_args[i]);
+
+             /* This is a %s argument.  Find the length of the string.  */
+             for (j = 0;; j += wcwidth)
+               {
+                 QUIT;
+                 read_memory (tem + j, buf, wcwidth);
+                 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)
+                   break;
+               }
+
+             /* Copy the string contents into a string inside GDB.  */
+             str = (gdb_byte *) alloca (j + wcwidth);
+             if (j != 0)
+               read_memory (tem, str, j);
+             memset (&str[j], 0, wcwidth);
+
+             obstack_init (&output);
+             inner_cleanup = make_cleanup_obstack_free (&output);
+
+             convert_between_encodings (target_wide_charset (gdbarch),
+                                        host_charset (),
+                                        str, j, wcwidth,
+                                        &output, translit_char);
+             obstack_grow_str0 (&output, "");
+
+             fprintf_filtered (stream, current_substring,
+                                obstack_base (&output));
+             do_cleanups (inner_cleanup);
+           }
+           break;
+         case wide_char_arg:
+           {
+             struct gdbarch *gdbarch
+               = get_type_arch (value_type (val_args[i]));
+             struct type *wctype = lookup_typename (current_language, gdbarch,
+                                                    "wchar_t", NULL, 0);
+             struct type *valtype;
+             struct obstack output;
+             struct cleanup *inner_cleanup;
+             const gdb_byte *bytes;
+
+             valtype = value_type (val_args[i]);
+             if (TYPE_LENGTH (valtype) != TYPE_LENGTH (wctype)
+                 || TYPE_CODE (valtype) != TYPE_CODE_INT)
+               error (_("expected wchar_t argument for %%lc"));
+
+             bytes = value_contents (val_args[i]);
+
+             obstack_init (&output);
+             inner_cleanup = make_cleanup_obstack_free (&output);
+
+             convert_between_encodings (target_wide_charset (gdbarch),
+                                        host_charset (),
+                                        bytes, TYPE_LENGTH (valtype),
+                                        TYPE_LENGTH (valtype),
+                                        &output, translit_char);
+             obstack_grow_str0 (&output, "");
+
+             fprintf_filtered (stream, current_substring,
+                                obstack_base (&output));
+             do_cleanups (inner_cleanup);

            }
            break;
          case double_arg:
            }
            break;
          case double_arg:


@@ -2071,12 +2455,12 @@ printf_command (char *arg, int from_tty)
 
              /* If format string wants a float, unchecked-convert the value
                 to floating point of the same size.  */
 
              /* If format string wants a float, unchecked-convert the value
                 to floating point of the same size.  */

-             type = float_type_from_length (current_gdbarch, type);
+             type = float_type_from_length (type);

              val = unpack_double (type, value_contents (val_args[i]), &inv);
              if (inv)
                error (_("Invalid floating value found in program."));
 
              val = unpack_double (type, value_contents (val_args[i]), &inv);
              if (inv)
                error (_("Invalid floating value found in program."));
 

-             printf_filtered (current_substring, (double) val);
+              fprintf_filtered (stream, current_substring, (double) val);

              break;
            }
          case long_double_arg:
              break;
            }
          case long_double_arg:


@@ -2088,12 +2472,13 @@ printf_command (char *arg, int from_tty)
 
              /* If format string wants a float, unchecked-convert the value
                 to floating point of the same size.  */
 
              /* If format string wants a float, unchecked-convert the value
                 to floating point of the same size.  */

-             type = float_type_from_length (current_gdbarch, type);
+             type = float_type_from_length (type);

              val = unpack_double (type, value_contents (val_args[i]), &inv);
              if (inv)
                error (_("Invalid floating value found in program."));
 
              val = unpack_double (type, value_contents (val_args[i]), &inv);
              if (inv)
                error (_("Invalid floating value found in program."));
 

-             printf_filtered (current_substring, (long double) val);
+             fprintf_filtered (stream, current_substring,
+                                (long double) val);

              break;
            }
 #else
              break;
            }
 #else


@@ -2103,7 +2488,8 @@ printf_command (char *arg, int from_tty)
 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
            {
              long long val = value_as_long (val_args[i]);
 #if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
            {
              long long val = value_as_long (val_args[i]);

-             printf_filtered (current_substring, val);
+
+              fprintf_filtered (stream, current_substring, val);

              break;
            }
 #else
              break;
            }
 #else


@@ -2112,13 +2498,15 @@ printf_command (char *arg, int from_tty)
          case int_arg:
            {
              int val = value_as_long (val_args[i]);
          case int_arg:
            {
              int val = value_as_long (val_args[i]);

-             printf_filtered (current_substring, val);
+
+              fprintf_filtered (stream, current_substring, val);

              break;
            }
          case long_arg:
            {
              long val = value_as_long (val_args[i]);
              break;
            }
          case long_arg:
            {
              long val = value_as_long (val_args[i]);

-             printf_filtered (current_substring, val);
+
+              fprintf_filtered (stream, current_substring, val);

              break;
            }
 
              break;
            }
 


@@ -2126,10 +2514,11 @@ printf_command (char *arg, int from_tty)
        case decfloat_arg:
            {
              const gdb_byte *param_ptr = value_contents (val_args[i]);
        case decfloat_arg:
            {
              const gdb_byte *param_ptr = value_contents (val_args[i]);

+

 #if defined (PRINTF_HAS_DECFLOAT)
              /* If we have native support for Decimal floating
                 printing, handle it here.  */
 #if defined (PRINTF_HAS_DECFLOAT)
              /* If we have native support for Decimal floating
                 printing, handle it here.  */

-             printf_filtered (current_substring, param_ptr);
+              fprintf_filtered (stream, current_substring, param_ptr);

 #else
 
              /* As a workaround until vasprintf has native support for DFP
 #else
 
              /* As a workaround until vasprintf has native support for DFP


@@ -2142,6 +2531,8 @@ printf_command (char *arg, int from_tty)
              /* Parameter data.  */
              struct type *param_type = value_type (val_args[i]);
              unsigned int param_len = TYPE_LENGTH (param_type);
              /* Parameter data.  */
              struct type *param_type = value_type (val_args[i]);
              unsigned int param_len = TYPE_LENGTH (param_type);

+             struct gdbarch *gdbarch = get_type_arch (param_type);
+             enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

 
              /* DFP output data.  */
              struct value *dfp_value = NULL;
 
              /* DFP output data.  */
              struct value *dfp_value = NULL;


@@ -2170,18 +2561,18 @@ printf_command (char *arg, int from_tty)
                  if (*sos == 'H')
                    {
                      dfp_len = 4;
                  if (*sos == 'H')
                    {
                      dfp_len = 4;

-                     dfp_type = builtin_type (current_gdbarch)->builtin_decfloat;
+                     dfp_type = builtin_type (gdbarch)->builtin_decfloat;

                    }
                  else if (*sos == 'D' && *(sos - 1) == 'D')
                    {
                      dfp_len = 16;
                    }
                  else if (*sos == 'D' && *(sos - 1) == 'D')
                    {
                      dfp_len = 16;

-                     dfp_type = builtin_type (current_gdbarch)->builtin_declong;
+                     dfp_type = builtin_type (gdbarch)->builtin_declong;

                      sos--;
                    }
                  else
                    {
                      dfp_len = 8;
                      sos--;
                    }
                  else
                    {
                      dfp_len = 8;

-                     dfp_type = builtin_type (current_gdbarch)->builtin_decdouble;
+                     dfp_type = builtin_type (gdbarch)->builtin_decdouble;

                    }
                }
 
                    }
                }
 


@@ -2201,21 +2592,22 @@ printf_command (char *arg, int from_tty)
 
              /* Conversion between different DFP types.  */
              if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
 
              /* Conversion between different DFP types.  */
              if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)

-               decimal_convert (param_ptr, param_len, dec, dfp_len);
+               decimal_convert (param_ptr, param_len, byte_order,
+                                dec, dfp_len, byte_order);

              else
                /* If this is a non-trivial conversion, just output 0.
                   A correct converted value can be displayed by explicitly
                   casting to a DFP type.  */
              else
                /* If this is a non-trivial conversion, just output 0.
                   A correct converted value can be displayed by explicitly
                   casting to a DFP type.  */

-               decimal_from_string (dec, dfp_len, "0");
+               decimal_from_string (dec, dfp_len, byte_order, "0");

 
              dfp_value = value_from_decfloat (dfp_type, dec);
 
              dfp_ptr = (gdb_byte *) value_contents (dfp_value);
 
 
              dfp_value = value_from_decfloat (dfp_type, dec);
 
              dfp_ptr = (gdb_byte *) value_contents (dfp_value);
 

-             decimal_to_string (dfp_ptr, dfp_len, decstr);
+             decimal_to_string (dfp_ptr, dfp_len, byte_order, decstr);

 
              /* Print the DFP value.  */
 
              /* Print the DFP value.  */

-             printf_filtered (current_substring, decstr);
+              fprintf_filtered (stream, current_substring, decstr);

 
              break;
 #endif
 
              break;
 #endif


@@ -2243,6 +2635,7 @@ printf_command (char *arg, int from_tty)
              while (*p)
                {
                  int is_percent = (*p == '%');
              while (*p)
                {
                  int is_percent = (*p == '%');

+

                  *fmt_p++ = *p++;
                  if (is_percent)
                    {
                  *fmt_p++ = *p++;
                  if (is_percent)
                    {


@@ -2269,13 +2662,13 @@ printf_command (char *arg, int from_tty)
                  *fmt_p++ = 'l';
                  *fmt_p++ = 'x';
                  *fmt_p++ = '\0';
                  *fmt_p++ = 'l';
                  *fmt_p++ = 'x';
                  *fmt_p++ = '\0';

-                 printf_filtered (fmt, val);
+                  fprintf_filtered (stream, fmt, val);

                }
              else
                {
                  *fmt_p++ = 's';
                  *fmt_p++ = '\0';
                }
              else
                {
                  *fmt_p++ = 's';
                  *fmt_p++ = '\0';

-                 printf_filtered (fmt, "(nil)");
+                  fprintf_filtered (stream, fmt, "(nil)");

                }
 
              break;
                }
 
              break;


@@ -2287,12 +2680,46 @@ printf_command (char *arg, int from_tty)
        /* Skip to the next substring.  */
        current_substring += strlen (current_substring) + 1;
       }
        /* Skip to the next substring.  */
        current_substring += strlen (current_substring) + 1;
       }

-    /* Print the portion of the format string after the last argument.  */
-    puts_filtered (last_arg);
+    /* Print the portion of the format string after the last argument.
+       Note that this will not include any ordinary %-specs, but it
+       might include "%%".  That is why we use printf_filtered and not
+       puts_filtered here.  Also, we pass a dummy argument because
+       some platforms have modified GCC to include -Wformat-security
+       by default, which will warn here if there is no argument.  */
+    fprintf_filtered (stream, last_arg, 0);

   }
   }

+
+after_print:

   do_cleanups (old_cleanups);
 }
 
   do_cleanups (old_cleanups);
 }
 

+/* Implement the "printf" command.  */
+
+void
+printf_command (char *arg, int from_tty)
+{
+  string_printf (arg, gdb_stdout, NULL, NULL, NULL);
+}
+
+/* Implement the "eval" command.  */
+
+static void
+eval_command (char *arg, int from_tty)
+{
+  struct ui_file *ui_out = mem_fileopen ();
+  struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
+  char *expanded;
+
+  string_printf (arg, ui_out, NULL, NULL, NULL);
+
+  expanded = ui_file_xstrdup (ui_out, NULL);
+  make_cleanup (xfree, expanded);
+
+  execute_command (expanded, from_tty);
+
+  do_cleanups (cleanups);
+}
+

 void
 _initialize_printcmd (void)
 {
 void
 _initialize_printcmd (void)
 {


@@ -2300,6 +2727,8 @@ _initialize_printcmd (void)
 
   current_display_number = -1;
 
 
   current_display_number = -1;
 

+  observer_attach_solib_unloaded (clear_dangling_display_expressions);
+

   add_info ("address", address_info,
            _("Describe where symbol SYM is stored."));
 
   add_info ("address", address_info,
            _("Describe where symbol SYM is stored."));
 


@@ -2393,7 +2822,7 @@ Use \"set variable\" for variables with names identical to set subcommands.\n\
 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
 You can see these environment settings with the \"show\" command."));
 
 \nWith a subcommand, this command modifies parts of the gdb environment.\n\
 You can see these environment settings with the \"show\" command."));
 

-  /* "call" is the same as "set", but handy for dbx users to call fns. */
+  /* "call" is the same as "set", but handy for dbx users to call fns.  */

   c = add_com ("call", class_vars, call_command, _("\
 Call a function in the program.\n\
 The argument is the function name and arguments, in the notation of the\n\
   c = add_com ("call", class_vars, call_command, _("\
 Call a function in the program.\n\
 The argument is the function name and arguments, in the notation of the\n\


@@ -2455,14 +2884,7 @@ Show printing of source filename and line number with <symbol>."), NULL,
                           show_print_symbol_filename,
                           &setprintlist, &showprintlist);
 
                           show_print_symbol_filename,
                           &setprintlist, &showprintlist);
 

-  /* For examine/instruction a single byte quantity is specified as
-     the data.  This avoids problems with value_at_lazy() requiring a
-     valid data type (and rejecting VOID). */
-  examine_i_type = init_type (TYPE_CODE_INT, 1, 0, "examine_i_type", NULL);
-
-  examine_b_type = init_type (TYPE_CODE_INT, 1, 0, "examine_b_type", NULL);
-  examine_h_type = init_type (TYPE_CODE_INT, 2, 0, "examine_h_type", NULL);
-  examine_w_type = init_type (TYPE_CODE_INT, 4, 0, "examine_w_type", NULL);
-  examine_g_type = init_type (TYPE_CODE_INT, 8, 0, "examine_g_type", NULL);
-
+  add_com ("eval", no_class, eval_command, _("\
+Convert \"printf format string\", arg1, arg2, arg3, ..., argn to\n\
+a command line, and call it."));

 }
 }