* object.cc (Sized_relobj::do_layout): Don't get confused if

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

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index cab70323a9d7f72c332e9539de62a175715042e1..88db08b01cef02e80944bd79e5f0aa7db0b0a2b3 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, 2009 Free Software Foundation, Inc.
+   2008, 2009, 2010 Free Software Foundation, Inc.

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


@@ -49,6 +49,7 @@
 #include "solib.h"
 #include "parser-defs.h"
 #include "charset.h"
 #include "solib.h"
 #include "parser-defs.h"
 #include "charset.h"

+#include "arch-utils.h"

 
 #ifdef TUI
 #include "tui/tui.h"           /* For tui_active et.al.   */
 
 #ifdef TUI
 #include "tui/tui.h"           /* For tui_active et.al.   */


@@ -68,18 +69,23 @@ struct format_data
     int count;
     char format;
     char size;
     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.  */


@@ -130,16 +136,25 @@ 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;
     /* 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;

+
+    /* Program space associated with `block'.  */
+    struct program_space *pspace;
+

     /* Innermost block required by this expression when evaluated */
     struct block *block;
     /* Innermost block required by this expression when evaluated */
     struct block *block;

+

     /* Status of this display (enabled or disabled) */
     int enabled_p;
   };
     /* Status of this display (enabled or disabled) */
     int enabled_p;
   };


@@ -181,6 +196,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);


@@ -193,6 +209,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


@@ -221,18 +242,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.  */


@@ -290,7 +303,8 @@ print_formatted (struct value *val, int size,
          /* We often wrap here if there are long symbolic names.  */
          wrap_here ("    ");
          next_address = (value_address (val)
          /* We often wrap here if there are long symbolic names.  */
          wrap_here ("    ");
          next_address = (value_address (val)

-                         + gdb_print_insn (value_address (val), stream,
+                         + gdb_print_insn (get_type_arch (type),
+                                           value_address (val), stream,

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


@@ -314,8 +328,9 @@ print_formatted (struct value *val, int size,
 /* 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);
 


@@ -341,9 +356,10 @@ print_scalar_formatted (const void *valaddr, struct type *type,
                        const struct value_print_options *options,
                        int size, struct ui_file *stream)
 {
                        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
 
   /* 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


@@ -392,12 +408,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;


@@ -443,7 +459,7 @@ 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;
 
       }
       break;
 


@@ -451,18 +467,18 @@ print_scalar_formatted (const void *valaddr, struct type *type,
       {
        struct value_print_options opts = *options;
        opts.format = 0;
       {
        struct value_print_options opts = *options;
        opts.format = 0;

+

        if (TYPE_UNSIGNED (type))
        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;
 


@@ -530,6 +546,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 $_.  */


@@ -546,7 +563,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;


@@ -559,7 +577,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);


@@ -599,7 +617,8 @@ print_address_symbolic (CORE_ADDR addr, struct ui_file *stream,
    success, when all the info in the OUT paramters is valid. Return 1
    otherwise. */
 int
    success, when all the info in the OUT paramters is valid. Return 1
    otherwise. */
 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 */


@@ -642,6 +661,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);


@@ -702,10 +728,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


@@ -714,8 +761,8 @@ 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;
   get_user_print_options (&opts);
 {
   struct value_print_options opts;
   get_user_print_options (&opts);


@@ -725,31 +772,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;


@@ -762,6 +799,7 @@ 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;
 
   /* String or instruction format implies fetch single bytes
   next_address = addr;
 
   /* String or instruction format implies fetch single bytes


@@ -769,16 +807,29 @@ do_examine (struct format_data fmt, CORE_ADDR addr)
   if (format == 's' || format == 'i')
     size = 'b';
 
   if (format == 's' || format == 'i')
     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;

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


@@ -796,7 +847,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;


@@ -874,6 +927,7 @@ 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)


@@ -909,6 +963,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");


@@ -959,6 +1014,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 == '/')
     {


@@ -976,6 +1032,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 ();


@@ -1091,6 +1148,8 @@ 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 symbol *sym;
   struct minimal_symbol *msymbol;
   long val;


@@ -1123,20 +1182,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);
            }


@@ -1153,6 +1213,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))
     {


@@ -1163,13 +1224,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);
        }


@@ -1177,39 +1238,49 @@ 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, 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:


@@ -1231,12 +1302,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);
        }


@@ -1258,16 +1329,17 @@ address_info (char *exp, int from_tty)
                && (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'"),
                && (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'"),

-                              paddr_nz (load_addr), section->objfile->name);
+                              paddress (gdbarch, load_addr),
+                              section->objfile->name);

            else
              {
                printf_filtered (_("static storage at address "));
            else
              {
                printf_filtered (_("static storage at address "));

-               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);
                  }


@@ -1296,9 +1368,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 == '/')
     {


@@ -1328,10 +1401,15 @@ x_command (char *exp, int from_tty)
        next_address = value_address (val);
       else
        next_address = value_as_address (val);
        next_address = value_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
      time.  */
 
   /* If the examine succeeds, we remember its size and format for next
      time.  */


@@ -1354,8 +1432,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);
     }


@@ -1402,6 +1479,7 @@ 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 = NULL;
        }
 
       innermost_block = NULL;


@@ -1412,6 +1490,7 @@ display_command (char *exp, int from_tty)
       new->exp_string = xstrdup (exp);
       new->exp = expr;
       new->block = innermost_block;
       new->exp_string = xstrdup (exp);
       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;


@@ -1528,6 +1607,20 @@ 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;
   if (d->exp == NULL)
     {
       volatile struct gdb_exception ex;


@@ -1548,7 +1641,12 @@ do_one_display (struct display *d)
     }
 
   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)


@@ -1588,11 +1686,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
     {


@@ -1613,6 +1711,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");


@@ -1772,6 +1871,7 @@ display_uses_solib_p (const struct display *d,
   const union exp_element *const elts = exp->elts;
 
   if (d->block != NULL
   const union exp_element *const elts = exp->elts;
 
   if (d->block != NULL

+      && d->pspace == solib->pspace

       && solib_contains_address_p (solib, d->block->startaddr))
     return 1;
 
       && solib_contains_address_p (solib, d->block->startaddr))
     return 1;
 


@@ -1792,7 +1892,8 @@ display_uses_solib_p (const struct display *d,
            SYMBOL_OBJ_SECTION (symbol);
 
          if (block != NULL
            SYMBOL_OBJ_SECTION (symbol);
 
          if (block != NULL

-             && solib_contains_address_p (solib, block->startaddr))
+             && solib_contains_address_p (solib,
+                                          block->startaddr))

            return 1;
 
          if (section && section->objfile == solib->objfile)
            return 1;
 
          if (section && section->objfile == solib->objfile)


@@ -2242,7 +2343,11 @@ printf_command (char *arg, int from_tty)
              gdb_byte *str;
              CORE_ADDR tem;
              int j;
              gdb_byte *str;
              CORE_ADDR tem;
              int j;

-             struct type *wctype = lookup_typename ("wchar_t", NULL, 0);
+             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;
              int wcwidth = TYPE_LENGTH (wctype);
              gdb_byte *buf = alloca (wcwidth);
              struct obstack output;


@@ -2255,7 +2360,7 @@ printf_command (char *arg, int from_tty)
                {
                  QUIT;
                  read_memory (tem + j, buf, wcwidth);
                {
                  QUIT;
                  read_memory (tem + j, buf, wcwidth);

-                 if (extract_unsigned_integer (buf, wcwidth) == 0)
+                 if (extract_unsigned_integer (buf, wcwidth, byte_order) == 0)

                    break;
                }
 
                    break;
                }
 


@@ -2268,7 +2373,7 @@ printf_command (char *arg, int from_tty)
              obstack_init (&output);
              inner_cleanup = make_cleanup_obstack_free (&output);
 
              obstack_init (&output);
              inner_cleanup = make_cleanup_obstack_free (&output);
 

-             convert_between_encodings (target_wide_charset (),
+             convert_between_encodings (target_wide_charset (byte_order),

                                         host_charset (),
                                         str, j, wcwidth,
                                         &output, translit_char);
                                         host_charset (),
                                         str, j, wcwidth,
                                         &output, translit_char);


@@ -2280,7 +2385,11 @@ printf_command (char *arg, int from_tty)
            break;
          case wide_char_arg:
            {
            break;
          case wide_char_arg:
            {

-             struct type *wctype = lookup_typename ("wchar_t", NULL, 0);
+             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);

              struct type *valtype;
              struct obstack output;
              struct cleanup *inner_cleanup;
              struct type *valtype;
              struct obstack output;
              struct cleanup *inner_cleanup;


@@ -2296,7 +2405,7 @@ printf_command (char *arg, int from_tty)
              obstack_init (&output);
              inner_cleanup = make_cleanup_obstack_free (&output);
 
              obstack_init (&output);
              inner_cleanup = make_cleanup_obstack_free (&output);
 

-             convert_between_encodings (target_wide_charset (),
+             convert_between_encodings (target_wide_charset (byte_order),

                                         host_charset (),
                                         bytes, TYPE_LENGTH (valtype),
                                         TYPE_LENGTH (valtype),
                                         host_charset (),
                                         bytes, TYPE_LENGTH (valtype),
                                         TYPE_LENGTH (valtype),


@@ -2315,7 +2424,7 @@ 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."));


@@ -2332,7 +2441,7 @@ 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."));


@@ -2386,6 +2495,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;


@@ -2414,18 +2525,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;

                    }
                }
 
                    }
                }
 


@@ -2445,18 +2556,19 @@ 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.  */
              printf_filtered (current_substring, decstr);
 
              /* Print the DFP value.  */
              printf_filtered (current_substring, decstr);


@@ -2700,15 +2812,4 @@ Show printing of source filename and line number with <symbol>."), NULL,
                           NULL,
                           show_print_symbol_filename,
                           &setprintlist, &showprintlist);
                           NULL,
                           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);
-

 }
 }