2003-10-01 Andrew Cagney <cagney@redhat.com>

* value.h (register_value_being_returned): Declare.  Replace
	"value_being_returned".
	* infcall.c (call_function_by_hand): Use
	register_value_being_returned.
	* infcmd.c (print_return_value): Call
	"register_value_being_returned", handle struct return locally.
	* values.c (register_value_being_returned): New function.  Replace
	"value_being_returned".

gdb/ChangeLog

@@ -1,4 +1,15 @@
-2003-09-24  Elena Zannoni  <ezannoni@redhat.com>
+2003-10-01  Andrew Cagney  <cagney@redhat.com>
+
+	* value.h (register_value_being_returned): Declare.  Replace
+	"value_being_returned".
+	* infcall.c (call_function_by_hand): Use
+	register_value_being_returned.
+	* infcmd.c (print_return_value): Call
+	"register_value_being_returned", handle struct return locally.
+	* values.c (register_value_being_returned): New function.  Replace
+	"value_being_returned".
+	
+2003-09-30  Elena Zannoni  <ezannoni@redhat.com>
 
 	* linux-proc.c (linux_do_registers): New function.
 	(linux_make_note_section): Use linux_do_registers in case of

gdb/infcall.c

@@ -1101,12 +1101,9 @@ the function call).", name);
     }
   else
     {
-      /* This call to value_being_returned is never made when the
+      /* The non-register case was handled above.  */
-         function uses "struct return convention".  Hence, pass "0"
+      struct value *retval = register_value_being_returned (value_type,
-         instead of STRUCT_RETURN.  Besides, VALUE_TYPE, in
+							    retbuf);
-         combination with RETURN_VALUE() (nee USE_STRUCT_CONVENTION)
-         can be used to re-construct the value of STRUCT_RETURN. */
-      struct value *retval = value_being_returned (value_type, retbuf, 0);
       do_cleanups (retbuf_cleanup);
       return retval;
     }

gdb/infcmd.c

@@ -1070,7 +1070,7 @@ print_return_value (int structure_return, struct type *value_type)
 
   if (!structure_return)
     {
-      value = value_being_returned (value_type, stop_registers, 0);
+      value = register_value_being_returned (value_type, stop_registers);
       stb = ui_out_stream_new (uiout);
       ui_out_text (uiout, "Value returned is ");
       ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value));
@@ -1081,11 +1081,6 @@ print_return_value (int structure_return, struct type *value_type)
     }
   else
     {
-      /* FIXME: 2003-09-27: This code block should be handling the
-         "use struct convention" case, and not the function
-         value_being_returned.  This would allow the dramatic
-         simplification of value_being_returned (perhaphs renamed to
-         register_value_being_returned).  */
       /* FIXME: 2003-09-27: When returning from a nested inferior
          function call, it's possible (with no help from the
          architecture vector) to locate and return/print a "struct
@@ -1103,7 +1098,34 @@ print_return_value (int structure_return, struct type *value_type)
       ui_out_text (uiout, ".");
       ui_out_text (uiout, " Cannot determine contents\n");
 #else
-      value = value_being_returned (value_type, stop_registers, 1);
+      if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
+	{
+	  CORE_ADDR addr = EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers);
+	  if (!addr)
+	    error ("Function return value unknown.");
+	  value = value_at (value_type, addr, NULL);
+	}
+      else if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
+	{
+	  char *buf = deprecated_grub_regcache_for_registers (stop_registers);
+	  CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf);
+	  if (!addr)
+	    error ("Function return value unknown.");
+	  value = value_at (value_type, addr, NULL);
+	}
+      else
+	{
+	  /* It is "struct return" yet the value is being extracted,
+             presumably from registers, using EXTRACT_RETURN_VALUE.
+             This doesn't make sense.  Unfortunatly, the legacy
+             interfaces allowed this behavior.  Sigh!  */
+	  value = allocate_value (value_type);
+	  CHECK_TYPEDEF (value_type);
+	  /* If the function returns void, don't bother fetching the
+	     return value.  */
+	  EXTRACT_RETURN_VALUE (value_type, stop_registers,
+				VALUE_CONTENTS_RAW (value));
+	}
       stb = ui_out_stream_new (uiout);
       ui_out_text (uiout, "Value returned is ");
       ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value));

gdb/value.h

@@ -416,9 +416,8 @@ extern struct value *value_repeat (struct value *arg1, int count);
 
 extern struct value *value_subscript (struct value *array, struct value *idx);
 
-extern struct value *value_being_returned (struct type *valtype,
+extern struct value *register_value_being_returned (struct type *valtype,
-					   struct regcache *retbuf,
+						    struct regcache *retbuf);
-					   int struct_return);
 
 extern struct value *value_in (struct value *element, struct value *set);
 

gdb/values.c

@@ -1202,60 +1202,25 @@ value_from_double (struct type *type, DOUBLEST num)
   return val;
 }
 
-/* Deal with the value that is "about to be returned".  */
+/* Deal with the value that is "about to be returned".
 
-/* Return the value that a function returning now
+   Return the value that a function, using the register convention,
-   would be returning to its caller, assuming its type is VALTYPE.
+   returning now would be returning to its caller, assuming its type
-   RETBUF is where we look for what ought to be the contents
+   is VALTYPE.  RETBUF is where we look for what ought to be the
-   of the registers (in raw form).  This is because it is often
+   contents of the registers (in raw form).  This is because it is
-   desirable to restore old values to those registers
+   often desirable to restore old values to those registers after
-   after saving the contents of interest, and then call
+   saving the contents of interest, and then call this function using
-   this function using the saved values.
+   the saved values.  */
-   struct_return is non-zero when the function in question is
-   using the structure return conventions on the machine in question;
-   0 when it is using the value returning conventions (this often
-   means returning pointer to where structure is vs. returning value). */
-
-/* FIXME: cagney/2003-09-27: Should move the "struct return
-   convention" code to the only call site in print_return_value that
-   needs it.  This function can then be renamed to
-   "register_value_being_returned" and with the "struct_return"
-   parameter dropped.  */
 
 struct value *
-value_being_returned (struct type *valtype, struct regcache *retbuf,
+register_value_being_returned (struct type *valtype, struct regcache *retbuf)
-		      int struct_return)
 {
-  struct value *val;
+  struct value *val = allocate_value (valtype);
-  CORE_ADDR addr;
-
-  /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
-  if (EXTRACT_STRUCT_VALUE_ADDRESS_P ())
-    if (struct_return)
-      {
-	addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
-	if (!addr)
-	  error ("Function return value unknown.");
-	return value_at (valtype, addr, NULL);
-      }
-
-  /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
-  if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
-    if (struct_return)
-      {
-	char *buf = deprecated_grub_regcache_for_registers (retbuf);
-	addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (buf);
-	if (!addr)
-	  error ("Function return value unknown.");
-	return value_at (valtype, addr, NULL);
-      }
-
-  val = allocate_value (valtype);
   CHECK_TYPEDEF (valtype);
-  /* If the function returns void, don't bother fetching the return value.  */
+  /* If the function returns void, don't bother fetching the return
+     value.  */
   if (TYPE_CODE (valtype) != TYPE_CODE_VOID)
     EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
-
   return val;
 }