/* Perform an inferior function call, for GDB, the GNU debugger.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GDB.
value_arg_coerce (struct value *arg, struct type *param_type,
int is_prototyped)
{
- struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+ struct type *arg_type = check_typedef (value_type (arg));
struct type *type
= param_type ? check_typedef (param_type) : arg_type;
&& TYPE_CODE (arg_type) != TYPE_CODE_PTR)
{
arg = value_addr (arg);
- VALUE_TYPE (arg) = param_type;
+ deprecated_set_value_type (arg, param_type);
return arg;
}
break;
CORE_ADDR
find_function_addr (struct value *function, struct type **retval_type)
{
- struct type *ftype = check_typedef (VALUE_TYPE (function));
+ struct type *ftype = check_typedef (value_type (function));
enum type_code code = TYPE_CODE (ftype);
struct type *value_type;
CORE_ADDR funaddr;
value_type = builtin_type_int;
}
else
- error ("Invalid data type for function to be called.");
+ error (_("Invalid data type for function to be called."));
if (retval_type != NULL)
*retval_type = value_type;
{
CORE_ADDR sp;
CORE_ADDR dummy_addr;
- struct type *value_type;
+ struct type *values_type;
unsigned char struct_return;
CORE_ADDR struct_addr = 0;
struct regcache *retbuf;
CORE_ADDR funaddr;
int using_gcc; /* Set to version of gcc in use, or zero if not gcc */
CORE_ADDR real_pc;
- struct type *ftype = check_typedef (SYMBOL_TYPE (function));
+ struct type *ftype = check_typedef (value_type (function));
CORE_ADDR bp_addr;
struct regcache *caller_regcache;
struct cleanup *caller_regcache_cleanup;
sp = old_sp;
}
- funaddr = find_function_addr (function, &value_type);
- CHECK_TYPEDEF (value_type);
+ funaddr = find_function_addr (function, &values_type);
+ CHECK_TYPEDEF (values_type);
{
struct block *b = block_for_pc (funaddr);
/* Are we returning a value using a structure return or a normal
value return? */
- struct_return = using_struct_return (value_type, using_gcc);
+ struct_return = using_struct_return (values_type, using_gcc);
/* Determine the location of the breakpoint (and possibly other
stuff) that the called function will return to. The SPARC, for a
if (INNER_THAN (1, 2))
{
sp = push_dummy_code (current_gdbarch, sp, funaddr,
- using_gcc, args, nargs, value_type,
+ using_gcc, args, nargs, values_type,
&real_pc, &bp_addr);
dummy_addr = sp;
}
{
dummy_addr = sp;
sp = push_dummy_code (current_gdbarch, sp, funaddr,
- using_gcc, args, nargs, value_type,
+ using_gcc, args, nargs, values_type,
&real_pc, &bp_addr);
}
break;
break;
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
if (nargs < TYPE_NFIELDS (ftype))
- error ("too few arguments in function call");
+ error (_("too few arguments in function call"));
{
int i;
this point. */
/* Go see if the actual parameter is a variable of
type pointer to function or just a function. */
- if (args[i]->lval == not_lval)
+ if (VALUE_LVAL (args[i]) == not_lval)
{
char *arg_name;
- if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
- error ("\
+ /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
+ if (find_pc_partial_function ((CORE_ADDR) value_contents (args[i])[0], &arg_name, NULL, NULL))
+ error (_("\
You cannot use function <%s> as argument. \n\
-You must use a pointer to function type variable. Command ignored.", arg_name);
+You must use a pointer to function type variable. Command ignored."), arg_name);
}
}
}
pointer to the structure, not the structure itself. */
for (i = nargs - 1; i >= 0; i--)
{
- struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+ struct type *arg_type = check_typedef (value_type (args[i]));
if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
|| TYPE_CODE (arg_type) == TYPE_CODE_UNION
|| TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
CORE_ADDR addr;
int len; /* = TYPE_LENGTH (arg_type); */
int aligned_len;
- arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+ arg_type = check_typedef (value_enclosing_type (args[i]));
len = TYPE_LENGTH (arg_type);
aligned_len = len;
sp += aligned_len;
}
/* Push the structure. */
- write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
+ write_memory (addr, value_contents_all (args[i]), len);
/* The value we're going to pass is the address of the
thing we just pushed. */
- /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+ /*args[i] = value_from_longest (lookup_pointer_type (values_type),
(LONGEST) addr); */
args[i] = value_from_pointer (lookup_pointer_type (arg_type),
addr);
if (struct_return)
{
- int len = TYPE_LENGTH (value_type);
+ int len = TYPE_LENGTH (values_type);
if (INNER_THAN (1, 2))
{
/* Stack grows downward. Align STRUCT_ADDR and SP after
sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return,
struct_addr);
else
- error ("This target does not support function calls");
+ error (_("This target does not support function calls"));
/* Set up a frame ID for the dummy frame so we can pass it to
set_momentary_breakpoint. We need to give the breakpoint a frame
{
/* Can't use a cleanup here. It is discarded, instead use
an alloca. */
- char *tmp = xstrprintf ("at %s", local_hex_string (funaddr));
+ char *tmp = xstrprintf ("at %s", hex_string (funaddr));
char *a = alloca (strlen (tmp) + 1);
strcpy (a, tmp);
xfree (tmp);
/* FIXME: Insert a bunch of wrap_here; name can be very
long if it's a C++ name with arguments and stuff. */
- error ("\
+ error (_("\
The program being debugged was signaled while in a function called from GDB.\n\
GDB has restored the context to what it was before the call.\n\
To change this behavior use \"set unwindonsignal off\"\n\
-Evaluation of the expression containing the function (%s) will be abandoned.",
+Evaluation of the expression containing the function (%s) will be abandoned."),
name);
}
else
discard_inferior_status (inf_status);
/* FIXME: Insert a bunch of wrap_here; name can be very
long if it's a C++ name with arguments and stuff. */
- error ("\
+ error (_("\
The program being debugged was signaled while in a function called from GDB.\n\
GDB remains in the frame where the signal was received.\n\
To change this behavior use \"set unwindonsignal on\"\n\
-Evaluation of the expression containing the function (%s) will be abandoned.",
+Evaluation of the expression containing the function (%s) will be abandoned."),
name);
}
}
someday this will be implemented (it would not be easy). */
/* FIXME: Insert a bunch of wrap_here; name can be very long if it's
a C++ name with arguments and stuff. */
- error ("\
+ error (_("\
The program being debugged stopped while in a function called from GDB.\n\
When the function (%s) is done executing, GDB will silently\n\
stop (instead of continuing to evaluate the expression containing\n\
-the function call).", name);
+the function call)."), name);
}
/* The above code errors out, so ... */
- internal_error (__FILE__, __LINE__, "... should not be here");
+ internal_error (__FILE__, __LINE__, _("... should not be here"));
}
/* If we get here the called FUNCTION run to completion. */
/* Figure out the value returned by the function, return that. */
{
struct value *retval;
- if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
+ if (TYPE_CODE (values_type) == TYPE_CODE_VOID)
/* If the function returns void, don't bother fetching the
return value. */
- retval = allocate_value (value_type);
+ retval = allocate_value (values_type);
else if (struct_return)
/* NOTE: cagney/2003-09-27: This assumes that PUSH_DUMMY_CALL
has correctly stored STRUCT_ADDR in the target. In the past
you're seeing problems with values being returned using the
"struct return convention", check that PUSH_DUMMY_CALL isn't
playing tricks. */
- retval = value_at (value_type, struct_addr, NULL);
+ retval = value_at (values_type, struct_addr);
else
{
/* This code only handles "register convention". */
- retval = allocate_value (value_type);
- gdb_assert (gdbarch_return_value (current_gdbarch, value_type,
+ retval = allocate_value (values_type);
+ gdb_assert (gdbarch_return_value (current_gdbarch, values_type,
NULL, NULL, NULL)
== RETURN_VALUE_REGISTER_CONVENTION);
- gdbarch_return_value (current_gdbarch, value_type, retbuf,
- VALUE_CONTENTS_RAW (retval) /*read*/,
+ gdbarch_return_value (current_gdbarch, values_type, retbuf,
+ value_contents_raw (retval) /*read*/,
NULL /*write*/);
}
do_cleanups (retbuf_cleanup);
information to determine that a function is prototyped. If this flag is\n\
set, GDB will perform the conversion for a function it considers\n\
unprototyped.\n\
-The default is to perform the conversion.\n", "\
-Coercion of floats to doubles when calling functions is %s.",
+The default is to perform the conversion.\n",
+ NULL, /* PRINT: Coercion of floats to doubles when calling functions is %s. */
NULL, NULL, &setlist, &showlist);
add_setshow_boolean_cmd ("unwindonsignal", no_class,
The unwindonsignal lets the user determine what gdb should do if a signal\n\
is received while in a function called from gdb (call dummy). If set, gdb\n\
unwinds the stack and restore the context to what as it was before the call.\n\
-The default is to stop in the frame where the signal was received.", "\
-Unwinding of stack if a signal is received while in a call dummy is %s.",
+The default is to stop in the frame where the signal was received.",
+ NULL, /* PRINT: Unwinding of stack if a signal is received while in a call dummy is %s. */
NULL, NULL, &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff