variable objects and registers

[Vladimir Prus <vladimir at codesourcery dot com>]

I was working on implementing a new MI command that creates variable objects 
for registers, and I have something working good enough to discuss. This 
patch lacks docs, but I wanted to make sure the interface is fine with 
everybody before documenting it.

There are already some commands related to registers, for 
example, -data-list-register-names. But for registers that are not just 
integers, one has to use variable objects to property display them. As 
result, output of -data-list-register-names goes directly to a number 
of -var-create. It is more reasonable to have a command that immediately 
produces variable objects.

Further, when memory-mapped registers are involved, gdb might want to group 
them in some hierarchy. Using variable objects is a reasonable way to achieve 
that.

This patch adds new command -var-registers that creates and returns a list of 
variable objects for all registers gdb knows. The command takes one option -- 
the frame, which is specified just like for -var-create. While not all 
registers are saved, and so gdb might not know values of some registers in 
parent frames, for some registers it's possible, and frontends might want to 
access those values.

Since the command creates several variable objects, it does not accepts a name 
of varobj. Instead, it automatically generated names much like "var-create -" 
does.

Here's example output:

      -var-registers *
      ^done,registers={
		{name="var1",exp="$eax",numchild="0",value="16",type="int"},
		............
                {name="var10",exp="$eflags",numchild="0",value="[ SF IF ID ]",


As soon as we add the code to display memory-mapped registers, there will be a 
problem that existing frontends might wish to show the memory-mapped 
registers, but not wish (at the moment) to modify the code for displaying 
regular registers. I plan to address this by either adding new 
attribute "register-kind" to the output, that can be either "core" 
or "memory-mapped", or by adding an option to -var-registers that says what 
registers to show. But that's for future.

Comments?

- Volodya

	* mi/mi-cmds.h (mi_cmd_var_registers): New.
	* mi/mi-cmds.c: Register "var-registers".
	* mi/mi-cmd-var.c (create_varobj_in_frame): New function.
	(mi_cmd_var_create): Use the above.
	(mi_cmd_var_registers): New.

=== gdb/mi/mi-cmds.h
==================================================================
--- gdb/mi/mi-cmds.h	(/patches/gdb/varobj_printing/gdb_mainline)	(revision 2338)
+++ gdb/mi/mi-cmds.h	(/patches/gdb/varobj_for_registers/gdb_mainline)	(revision 2338)
@@ -105,6 +105,7 @@
 extern mi_cmd_argv_ftype mi_cmd_thread_select;
 extern mi_cmd_argv_ftype mi_cmd_var_assign;
 extern mi_cmd_argv_ftype mi_cmd_var_create;
+extern mi_cmd_argv_ftype mi_cmd_var_registers;
 extern mi_cmd_argv_ftype mi_cmd_var_delete;
 extern mi_cmd_argv_ftype mi_cmd_var_evaluate_expression;
 extern mi_cmd_argv_ftype mi_cmd_var_info_expression;
=== gdb/mi/mi-cmds.c
==================================================================
--- gdb/mi/mi-cmds.c	(/patches/gdb/varobj_printing/gdb_mainline)	(revision 2338)
+++ gdb/mi/mi-cmds.c	(/patches/gdb/varobj_for_registers/gdb_mainline)	(revision 2338)
@@ -153,6 +153,7 @@
   { "trace-stop", { NULL, 0 }, NULL, NULL },
   { "var-assign", { NULL, 0 }, 0, mi_cmd_var_assign},
   { "var-create", { NULL, 0 }, 0, mi_cmd_var_create},
+  { "var-registers", { NULL, 0 }, 0, mi_cmd_var_registers},
   { "var-delete", { NULL, 0 }, 0, mi_cmd_var_delete},
   { "var-evaluate-expression", { NULL, 0 }, 0, mi_cmd_var_evaluate_expression},
   { "var-info-expression", { NULL, 0 }, 0, mi_cmd_var_info_expression},
=== gdb/mi/mi-cmd-var.c
==================================================================
--- gdb/mi/mi-cmd-var.c	(/patches/gdb/varobj_printing/gdb_mainline)	(revision 2338)
+++ gdb/mi/mi-cmd-var.c	(/patches/gdb/varobj_for_registers/gdb_mainline)	(revision 2338)
@@ -68,16 +68,39 @@
 
 /* VAROBJ operations */
 
+static struct varobj *
+create_varobj_in_frame (char *name, char *expression, char *frame)
+{
+  CORE_ADDR frameaddr = 0;
+  struct cleanup *cleanup;
+  enum varobj_type var_type;
+
+  if (strcmp (frame, "*") == 0)
+    var_type = USE_CURRENT_FRAME;
+  else if (strcmp (frame, "@") == 0)
+    var_type = USE_SELECTED_FRAME;  
+  else
+    {
+      var_type = USE_SPECIFIED_FRAME;
+      frameaddr = string_to_core_addr (frame);
+    }
+
+  if (varobjdebug)
+    fprintf_unfiltered (gdb_stdlog,
+		    "Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n",
+			name, frame, paddr (frameaddr), expression);
+
+  return varobj_create (name, expression, frameaddr, var_type);
+}
+
 enum mi_cmd_result
 mi_cmd_var_create (char *command, char **argv, int argc)
 {
-  CORE_ADDR frameaddr = 0;
   struct varobj *var;
   char *name;
   char *frame;
   char *expr;
   struct cleanup *old_cleanups;
-  enum varobj_type var_type;
 
   if (argc != 3)
     {
@@ -104,23 +127,8 @@
   else if (!isalpha (*name))
     error (_("mi_cmd_var_create: name of object must begin with a letter"));
 
-  if (strcmp (frame, "*") == 0)
-    var_type = USE_CURRENT_FRAME;
-  else if (strcmp (frame, "@") == 0)
-    var_type = USE_SELECTED_FRAME;  
-  else
-    {
-      var_type = USE_SPECIFIED_FRAME;
-      frameaddr = string_to_core_addr (frame);
-    }
+  var = create_varobj_in_frame (name, expr, frame);
 
-  if (varobjdebug)
-    fprintf_unfiltered (gdb_stdlog,
-		    "Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n",
-			name, frame, paddr (frameaddr), expr);
-
-  var = varobj_create (name, expr, frameaddr, var_type);
-
   if (var == NULL)
     error (_("mi_cmd_var_create: unable to create variable object"));
 
@@ -131,6 +139,58 @@
 }
 
 enum mi_cmd_result
+mi_cmd_var_registers (char *command, char **argv, int argc)
+{
+  int regnum, numregs;
+  struct cleanup *cleanup;
+  char *frame;
+
+  if (argc != 1)
+    error (_("mi_cmd_var_registers: Usage: FRAME."));
+  
+  frame = xstrdup (argv[0]);
+  cleanup = make_cleanup (xfree, frame);
+
+  /* Note that the test for a valid register must include checking the
+     REGISTER_NAME because NUM_REGS may be allocated for the union of
+     the register sets within a family of related processors.  In this
+     case, some entries of REGISTER_NAME will change depending upon
+     the particular processor being debugged.  */
+
+  numregs = NUM_REGS + NUM_PSEUDO_REGS;
+
+  make_cleanup_ui_out_tuple_begin_end (uiout, "registers");
+
+  for (regnum = 0; regnum < numregs; regnum++)
+    {
+      if (REGISTER_NAME (regnum) != NULL
+	  && *(REGISTER_NAME (regnum)) != '\0')
+	{
+	  char *name;
+	  char *expression;
+	  struct varobj *var;
+	  struct cleanup *cleanup_child;
+
+	  name = varobj_gen_name ();
+	  make_cleanup (free_current_contents, &name);
+
+	  expression = xstrprintf ("$%s", REGISTER_NAME (regnum));
+	  make_cleanup (xfree, expression);
+
+	  var = create_varobj_in_frame (name, expression, frame);
+
+	  cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+	  print_varobj (var, PRINT_ALL_VALUES, 1 /* print expression */);
+	  do_cleanups (cleanup_child);
+	}
+    }
+
+  do_cleanups (cleanup);
+  return MI_CMD_DONE;
+}
+
+
+enum mi_cmd_result
 mi_cmd_var_delete (char *command, char **argv, int argc)
 {
   char *name;

Property changes on: 
___________________________________________________________________
Name: csl:base
 +/all/patches/gdb/varobj_printing/gdb_mainline