[mi] fix 'editable' attribute for references

[Vladimir Prus <ghost at cs dot msu dot su>]

I've noticed that the -var-show-references returns 'attr=noneditable' for structures,
but 'attr=editable' for references to structures, which makes no sense.

This patch fixes this.

Some clarification is is order. Each varobj has three types associated with it.
One type is the declared type in the source program. Second type
is the type of the value we're actually storing. Third type is the type of value
we're operating with when getting children.

To be more concrete, first type is the type in program, no changes at all.
Second type is type in program with top-level reference stripped.
Third type also has top-level pointer dereferenced. 

This patch introduces, explicitly, a function to get the second type
and makes c_variable_ediatable use it.

OK?

- Volodya

	Fix the 'editable' attribute computation
	for references.

	testsuite/
	* gdb.mi/mi-var-cp.exp: Run the reference_to_struct
	testcase.
	* gdb.mi/mi-var-cp.cc (reference_to_struct): New function.
	(main): Call the above.

	gdb/
	* varobj.c (get_value_type): New function.
	(c_variable_editable): Use get_value_type.

--- gdb/testsuite/gdb.mi/mi-var-cp.exp	(/mirrors/gdb_mainline)	(revision 3171)
+++ gdb/testsuite/gdb.mi/mi-var-cp.exp	(/patches/gdb/path_3_5_references/gdb_mainline)	(revision 3171)
@@ -44,6 +44,7 @@ mi_prepare_inline_tests $srcfile
 mi_run_inline_test reference_update
 mi_run_inline_test base_in_reference
 mi_run_inline_test reference_to_pointer
+mi_run_inline_test reference_to_struct
 
 mi_gdb_exit
 return 0
--- gdb/testsuite/gdb.mi/mi-var-cp.cc	(/mirrors/gdb_mainline)	(revision 3171)
+++ gdb/testsuite/gdb.mi/mi-var-cp.cc	(/patches/gdb/path_3_5_references/gdb_mainline)	(revision 3171)
@@ -96,10 +96,30 @@ int reference_to_pointer ()
   /*: END: reference_to_pointer :*/
 }
 
+int reference_to_struct ()
+{
+  /*: BEGIN: reference_to_struct :*/
+  S s;
+  S& r = s;
+  /*:
+    mi_create_varobj S s "create varobj for s"
+    mi_create_varobj R r "create varobj for s"
+    mi_gdb_test "-var-show-attributes S" \
+	"\\^done,attr=\"noneditable\"" \
+	"check attributes of S"
+    mi_gdb_test "-var-show-attributes R" \
+	"\\^done,attr=\"noneditable\"" \
+	"check attributes of R"
+    :*/
+  return 99;
+  /*: END: reference_to_struct :*/
+}
+
 int main ()
 {
   reference_update_tests ();
   base_in_reference_test_main ();
   reference_to_pointer ();
+  reference_to_struct ();
   return 0;
 }
--- gdb/varobj.c	(/mirrors/gdb_mainline)	(revision 3171)
+++ gdb/varobj.c	(/patches/gdb/path_3_5_references/gdb_mainline)	(revision 3171)
@@ -176,6 +176,8 @@ static struct cleanup *make_cleanup_free
 
 static struct type *get_type (struct varobj *var);
 
+static struct type *get_value_type (struct varobj *var);
+
 static struct type *get_type_deref (struct varobj *var);
 
 static struct type *get_target_type (struct type *);
@@ -1459,6 +1461,35 @@ get_type (struct varobj *var)
   return type;
 }
 
+/* Return the type of the value that's stored in VAR,
+   or that would have being stored there if the
+   value were accessible.  
+
+   This differs from VAR->type in that VAR->type is always
+   the true type of the expession in the source language.
+   The return value of this function is the type we're
+   actually storing in varobj, and using for displaying
+   the values and for comparing previous and new values.
+
+   For example, top-level references are always stripped.  */
+static struct type *
+get_value_type (struct varobj *var)
+{
+  struct type *type;
+
+  if (var->value)
+    type = value_type (var->value);
+  else
+    type = var->type;
+
+  if (TYPE_CODE (type) == TYPE_CODE_REF)
+    type = get_target_type (type);
+
+  type = check_typedef (type);
+
+  return type;
+}
+
 /* This returns the type of the variable, dereferencing references, pointers
    and references to pointers, too. */
 static struct type *
@@ -2020,7 +2051,7 @@ c_type_of_child (struct varobj *parent, 
 static int
 c_variable_editable (struct varobj *var)
 {
-  switch (TYPE_CODE (get_type (var)))
+  switch (TYPE_CODE (get_value_type (var)))
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION: