GDB 7.6.50

gdb/tui/tui-regs.c

 /* TUI display registers in window.
 
-   Copyright (C) 1998-2004, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 1998-2013 Free Software Foundation, Inc.
 
    Contributed by Hewlett-Packard Company.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "arch-utils.h"
 #include "tui/tui.h"
 #include "tui/tui-data.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "gdbcmd.h"
 #include "frame.h"
 #include "regcache.h"
 #include "inferior.h"
 #include "target.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "tui/tui-layout.h"
 #include "tui/tui-win.h"
 #include "tui/tui-windata.h"
 #include "tui/tui-wingeneral.h"
 #include "tui/tui-file.h"
 #include "tui/tui-regs.h"
 #include "reggroups.h"
 #include "valprint.h"
 
 #include "gdb_curses.h"
 
 
 /*****************************************
 ** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
 ******************************************/
 static void
 tui_display_register (struct tui_data_element *data,
                       struct tui_gen_win_info *win_info);
 
 static enum tui_status tui_show_register_group (struct reggroup *group,
                                                 struct frame_info *frame,
                                                 int refresh_values_only);
 
 static enum tui_status tui_get_register (struct frame_info *frame,
                                          struct tui_data_element *data,
                                          int regnum, int *changedp);
 
-static void tui_register_format (struct frame_info *,
-                                 struct tui_data_element*, int);
-
 static void tui_scroll_regs_forward_command (char *, int);
 static void tui_scroll_regs_backward_command (char *, int);
 
 
 
 /*****************************************
 ** PUBLIC FUNCTIONS                     **
 ******************************************/
 
 /* Answer the number of the last line in the regs display.  If there
@@ skipping 76 matching lines @@
   display_info = &TUI_DATA_WIN->detail.data_display_info;
   if (group == 0)
     group = general_reggroup;
 
   /* Say that registers should be displayed, even if there is a
      problem.  */
   display_info->display_regs = TRUE;
 
   if (target_has_registers && target_has_stack && target_has_memory)
     {
-      ret = tui_show_register_group (group, get_current_frame (),
+      ret = tui_show_register_group (group, get_selected_frame (NULL),
                                      group == display_info->current_group);
     }
   if (ret == TUI_FAILURE)
     {
       display_info->current_group = 0;
       tui_erase_data_content (NO_REGS_STRING);
     }
   else
     {
       int i;
@@ skipping 483 matching lines @@
       add_com ("-r", class_tui, tui_scroll_regs_backward_command,
                _("Scroll the register window backward\n"));
     }
 }
 
 
 /*****************************************
 ** STATIC LOCAL FUNCTIONS                 **
 ******************************************/
 
-extern int pagination_enabled;
-
 static void
 tui_restore_gdbout (void *ui)
 {
   ui_file_delete (gdb_stdout);
   gdb_stdout = (struct ui_file*) ui;
   pagination_enabled = 1;
 }
 
-/* Get the register from the frame and make a printable representation
-   of it in the data element.  */
-static void
-tui_register_format (struct frame_info *frame,
-                     struct tui_data_element *data_element, 
-                     int regnum)
+/* Get the register from the frame and return a printable
+   representation of it.  */
+
+static char *
+tui_register_format (struct frame_info *frame, int regnum)
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   struct ui_file *stream;
   struct ui_file *old_stdout;
-  const char *name;
   struct cleanup *cleanups;
   char *p, *s;
-
-  name = gdbarch_register_name (gdbarch, regnum);
-  if (name == 0 || *name == '\0')
-    return;
+  char *ret;
 
   pagination_enabled = 0;
   old_stdout = gdb_stdout;
   stream = tui_sfileopen (256);
   gdb_stdout = stream;
   cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
   gdbarch_print_registers_info (gdbarch, stream, frame, regnum, 1);
 
   /* Save formatted output in the buffer.  */
   p = tui_file_get_strbuf (stream);
 
   /* Remove the possible \n.  */
   s = strrchr (p, '\n');
   if (s && s[1] == 0)
     *s = 0;
 
-  xfree (data_element->content);
-  data_element->content = xstrdup (p);
+  ret = xstrdup (p);
   do_cleanups (cleanups);
+
+  return ret;
 }
 
 /* Get the register value from the given frame and format it for the
    display.  When changep is set, check if the new register value has
    changed with respect to the previous call.  */
 static enum tui_status
 tui_get_register (struct frame_info *frame,
                   struct tui_data_element *data, 
                   int regnum, int *changedp)
 {
   enum tui_status ret = TUI_FAILURE;
 
   if (changedp)
     *changedp = FALSE;
   if (target_has_registers)
     {
-      struct value *old_val = data->value;
+      char *prev_content = data->content;
 
-      data->value = get_frame_register_value (frame, regnum);
-      release_value (data->value);
-      if (changedp)
-        {
-          struct gdbarch *gdbarch = get_frame_arch (frame);
-          int size = register_size (gdbarch, regnum);
+      data->content = tui_register_format (frame, regnum);
 
-          if (value_optimized_out (data->value) != value_optimized_out (old_val)
-              || !value_available_contents_eq (data->value, 0,
-                                               old_val, 0, size))
-            *changedp = TRUE;
-        }
+      if (changedp != NULL
+          && strcmp (prev_content, data->content) != 0)
+        *changedp = 1;
 
-      value_free (old_val);
-
-      /* Reformat the data content if the value changed.  */
-      if (changedp == 0 || *changedp == TRUE)
-        tui_register_format (frame, data, regnum);
+      xfree (prev_content);
 
       ret = TUI_SUCCESS;
     }
   return ret;
 }
 
 static void
 tui_scroll_regs_forward_command (char *arg, int from_tty)
 {
   tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
 }
 
 
 static void
 tui_scroll_regs_backward_command (char *arg, int from_tty)
 {
   tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
 }