Hello,

this patch removes builtin_type_ macros from infcall.c.  The instances
in value_arg_coerce are simply made per-arch by passing in the architecture
from the (sole) call site.

find_function_addr used to return a default "builtin_type_int" if the
actual function return type could not be detected from debug data.
However: most callers to not even look at the return type computed
by find_function_addr, and the call site in eval.c implements its own
unknown return type handling.  Thus the patch moves the return type
default setting to the sole remaining caller, call_function_by_hand.

Bye,
Ulrich


ChangeLog:

	* infcall.c (value_arg_coerce): Add GDBARCH parameter.  Use its
	associates types instead of builtin_type_ macros.
	(find_function_addr): Leave output VALUE_TYPE NULL if unknown.
	(call_function_by_hand): Use per-architecture "int" type as
	fall-back if find_function_addr returns NULL VALUE_TYPE.
	Update call to value_arg_coerce.


Index: gdb-head/gdb/infcall.c
===================================================================
--- gdb-head.orig/gdb/infcall.c
+++ gdb-head/gdb/infcall.c
@@ -100,9 +100,10 @@ Unwinding of stack if a signal is receiv
    its value as needed).  */
 
 static struct value *
-value_arg_coerce (struct value *arg, struct type *param_type,
-		  int is_prototyped, CORE_ADDR *sp)
+value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
+		  struct type *param_type, int is_prototyped, CORE_ADDR *sp)
 {
+  const struct builtin_type *builtin = builtin_type (gdbarch);
   struct type *arg_type = check_typedef (value_type (arg));
   struct type *type
     = param_type ? check_typedef (param_type) : arg_type;
@@ -141,22 +142,22 @@ value_arg_coerce (struct value *arg, str
       /* If we don't have a prototype, coerce to integer type if necessary.  */
       if (!is_prototyped)
 	{
-	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-	    type = builtin_type_int;
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
+	    type = builtin->builtin_int;
 	}
       /* Currently all target ABIs require at least the width of an integer
          type for an argument.  We may have to conditionalize the following
          type coercion for future targets.  */
-      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
-	type = builtin_type_int;
+      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
+	type = builtin->builtin_int;
       break;
     case TYPE_CODE_FLT:
       if (!is_prototyped && coerce_float_to_double_p)
 	{
-	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
-	    type = builtin_type_double;
-	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
-	    type = builtin_type_long_double;
+	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
+	    type = builtin->builtin_double;
+	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
+	    type = builtin->builtin_long_double;
 	}
       break;
     case TYPE_CODE_FUNC:
@@ -199,7 +200,7 @@ find_function_addr (struct value *functi
 {
   struct type *ftype = check_typedef (value_type (function));
   enum type_code code = TYPE_CODE (ftype);
-  struct type *value_type;
+  struct type *value_type = NULL;
   CORE_ADDR funaddr;
 
   /* If it's a member function, just look at the function
@@ -223,8 +224,6 @@ find_function_addr (struct value *functi
 							&current_target);
 	  value_type = TYPE_TARGET_TYPE (ftype);
 	}
-      else
-	value_type = builtin_type_int;
     }
   else if (code == TYPE_CODE_INT)
     {
@@ -251,8 +250,6 @@ find_function_addr (struct value *functi
 	    /* Handle integer used as address of a function.  */
 	    funaddr = (CORE_ADDR) value_as_long (function);
 	}
-
-      value_type = builtin_type_int;
     }
   else
     error (_("Invalid data type for function to be called."));
@@ -472,6 +469,9 @@ call_function_by_hand (struct value *fun
   funaddr = find_function_addr (function, &values_type);
   CHECK_TYPEDEF (values_type);
 
+  if (!values_type)
+    values_type = builtin_type (gdbarch)->builtin_int;
+
   /* Are we returning a value using a structure return (passing a
      hidden argument pointing to storage) or a normal value return?
      There are two cases: language-mandated structure return and
@@ -590,7 +590,8 @@ call_function_by_hand (struct value *fun
 	else
 	  param_type = NULL;
 
-	args[i] = value_arg_coerce (args[i], param_type, prototyped, &sp);
+	args[i] = value_arg_coerce (gdbarch, args[i],
+				    param_type, prototyped, &sp);
 
 	if (param_type != NULL && language_pass_by_reference (param_type))
 	  args[i] = value_addr (args[i]);

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com