[rfc][28/37] Eliminate builtin_type_ macros: Update infcall.c routines

uweigand
2008-08-31T18:15:35Z

[-- Attachment #1: diff-type-infcall --]
[-- Type: text/plain, Size: 4737 bytes --]

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]);