> len * HOST_CHAR_BIT)
/* Getting this right would involve being very careful about
byte order. */
- error ("\
-Can't handle bitfield which doesn't fit in a single register.");
+ error ("Can't assign to bitfields that cross register "
+ "boundaries.");
read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
buffer, len);
return sp;
}
-/* Push onto the stack the specified value VALUE. */
+#ifndef PARM_BOUNDARY
+#define PARM_BOUNDARY (0)
+#endif
+
+/* Push onto the stack the specified value VALUE. Pad it correctly for
+ it to be an argument to a function. */
static CORE_ADDR
value_push (sp, arg)
value_ptr arg;
{
register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
+ register int container_len = len;
+ register int offset;
+
+ /* How big is the container we're going to put this value in? */
+ if (PARM_BOUNDARY)
+ container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1)
+ & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
+
+ /* Are we going to put it at the high or low end of the container? */
+ if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ offset = container_len - len;
+ else
+ offset = 0;
if (INNER_THAN (1, 2))
{
/* stack grows downward */
- sp -= len;
- write_memory (sp, VALUE_CONTENTS_ALL (arg), len);
+ sp -= container_len;
+ write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
}
else
{
/* stack grows upward */
- write_memory (sp, VALUE_CONTENTS_ALL (arg), len);
- sp += len;
+ write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
+ sp += container_len;
}
return sp;
{
register CORE_ADDR sp;
register int i;
+ int rc;
CORE_ADDR start_sp;
/* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
is in host byte order. Before calling FIX_CALL_DUMMY, we byteswap it
/* Execute the stack dummy routine, calling FUNCTION.
When it is done, discard the empty frame
after storing the contents of all regs into retbuf. */
- if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
+ rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
+
+ if (rc == 1)
{
- /* We stopped somewhere besides the call dummy. */
+ /* We stopped inside the FUNCTION because of a random signal.
+ Further execution of the FUNCTION is not allowed. */
+
+ /* In this case, we must do the cleanups because we don't
+ want the dummy anymore (the dummy frame has been poped already. */
+ do_cleanups (old_chain);
+
+ /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
+ a C++ name with arguments and stuff. */
+ error ("\
+The program being debugged stopped while in a function called from GDB.\n\
+Evaluation of the expression containing the function (%s) will be abandoned.",
+ name);
+ }
+
+ if (rc == 2)
+ {
+ /* We hit a breakpoint inside the FUNCTION. */
/* If we did the cleanups, we would print a spurious error
message (Unable to restore previously selected frame),
the function call).", name);
}
+ /* If we get here the called FUNCTION run to completion. */
do_cleanups (old_chain);
/* Figure out the value returned by the function. */
int i = -1;
func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
+ /* If the name is NULL this must be a C-style function.
+ Just return the same symbol. */
+ if (!func_name)
+ {
+ *symp = fsym;
+ return 0;
+ }
+
oload_syms = make_symbol_overload_list (fsym);
while (oload_syms[++i])
num_fns++;