static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
-#ifdef CALL_DUMMY
static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
-#endif
#ifndef PUSH_ARGUMENTS
static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
+static struct fn_field *find_method_list PARAMS ((value_ptr *argp, char * method, int offset, int * static_memfuncp, struct type * type, int * num_fns, struct type ** basetype, int * boffset));
+
void _initialize_valops PARAMS ((void));
#define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
val = allocate_value (type);
-#ifdef GDB_TARGET_IS_D10V
- if (TYPE_CODE (type) == TYPE_CODE_PTR
+ if (GDB_TARGET_IS_D10V
+ && TYPE_CODE (type) == TYPE_CODE_PTR
&& TYPE_TARGET_TYPE (type)
&& (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
{
unsigned long num;
unsigned short snum;
snum = read_memory_unsigned_integer (addr, 2);
- num = D10V_MAKE_IADDR(snum);
- store_address ( VALUE_CONTENTS_RAW (val), 4, num);
+ num = D10V_MAKE_IADDR (snum);
+ store_address (VALUE_CONTENTS_RAW (val), 4, num);
}
- else if (TYPE_CODE(type) == TYPE_CODE_PTR)
+ else if (GDB_TARGET_IS_D10V
+ && TYPE_CODE(type) == TYPE_CODE_PTR)
{
/* pointer to data */
unsigned long num;
unsigned short snum;
snum = read_memory_unsigned_integer (addr, 2);
- num = D10V_MAKE_DADDR(snum);
- store_address ( VALUE_CONTENTS_RAW (val), 4, num);
+ num = D10V_MAKE_DADDR (snum);
+ store_address (VALUE_CONTENTS_RAW (val), 4, num);
}
else
-#endif
read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
VALUE_LVAL (val) = lval_memory;
CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
-#ifdef GDB_TARGET_IS_D10V
struct type *type = VALUE_TYPE(val);
- if (TYPE_CODE (type) == TYPE_CODE_PTR
+ if (GDB_TARGET_IS_D10V
+ && TYPE_CODE (type) == TYPE_CODE_PTR
&& TYPE_TARGET_TYPE (type)
&& (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
{
num = D10V_MAKE_IADDR(snum);
store_address ( VALUE_CONTENTS_RAW (val), 4, num);
}
- else if (TYPE_CODE(type) == TYPE_CODE_PTR)
+ else if (GDB_TARGET_IS_D10V
+ && TYPE_CODE(type) == TYPE_CODE_PTR)
{
/* pointer to data */
unsigned long num;
num = D10V_MAKE_DADDR(snum);
store_address ( VALUE_CONTENTS_RAW (val), 4, num);
}
- else
-#endif
-
- if (length)
+ else if (length)
read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
VALUE_BFD_SECTION (val));
VALUE_LAZY (val) = 0;
#endif /* !PUSH_ARGUMENTS */
-#ifdef CALL_DUMMY
/* Perform the standard coercions that are specified
for arguments to be passed to C functions.
ARGS is modified to contain coerced values. */
-value_ptr
-call_function_by_hand (function, nargs, args)
+static value_ptr hand_function_call PARAMS ((value_ptr function, int nargs, value_ptr *args));
+static value_ptr
+hand_function_call (function, nargs, args)
value_ptr function;
int nargs;
value_ptr *args;
sequence of instructions. But CISC machines will have
to pack the instructions into REGISTER_SIZE units (and
so will RISC machines for which INSTRUCTION_SIZE is not
- REGISTER_SIZE). */
+ REGISTER_SIZE).
+
+ NOTE: This is pretty stupid. CALL_DUMMY should be in strict
+ target byte order. */
- static ULONGEST dummy[] = CALL_DUMMY;
- char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (ULONGEST)];
+ static ULONGEST *dummy;
+ int sizeof_dummy1;
+ char *dummy1;
CORE_ADDR old_sp;
struct type *value_type;
unsigned char struct_return;
CORE_ADDR struct_addr = 0;
- struct inferior_status inf_status;
+ struct inferior_status *inf_status;
struct cleanup *old_chain;
CORE_ADDR funaddr;
int using_gcc; /* Set to version of gcc in use, or zero if not gcc */
struct type *param_type = NULL;
struct type *ftype = check_typedef (SYMBOL_TYPE (function));
+ dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
+ sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
+ dummy1 = alloca (sizeof_dummy1);
+ memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
+
if (!target_has_execution)
noprocess();
- save_inferior_status (&inf_status, 1);
+ inf_status = save_inferior_status (1);
old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status,
- &inf_status);
+ inf_status);
/* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
(and POP_FRAME for restoring them). (At least on most machines)
if (INNER_THAN (1, 2))
{
/* Stack grows down */
- sp -= sizeof dummy1;
+ sp -= sizeof_dummy1;
start_sp = sp;
}
else
{
/* Stack grows up */
start_sp = sp;
- sp += sizeof dummy1;
+ sp += sizeof_dummy1;
}
funaddr = find_function_addr (function, &value_type);
/* Create a call sequence customized for this function
and the number of arguments for it. */
- for (i = 0; i < (int) (sizeof (dummy) / sizeof (dummy[0])); i++)
+ for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
REGISTER_SIZE,
(ULONGEST)dummy[i]);
real_pc = start_sp;
#endif
-#if CALL_DUMMY_LOCATION == ON_STACK
- write_memory (start_sp, (char *)dummy1, sizeof dummy1);
-#endif /* On stack. */
-
-#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
- /* Convex Unix prohibits executing in the stack segment. */
- /* Hope there is empty room at the top of the text segment. */
- {
- extern CORE_ADDR text_end;
- static checked = 0;
- if (!checked)
- for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
- if (read_memory_integer (start_sp, 1) != 0)
- error ("text segment full -- no place to put call");
- checked = 1;
- sp = old_sp;
- real_pc = text_end - sizeof dummy1;
- write_memory (real_pc, (char *)dummy1, sizeof dummy1);
- }
-#endif /* Before text_end. */
+ if (CALL_DUMMY_LOCATION == ON_STACK)
+ {
+ write_memory (start_sp, (char *)dummy1, sizeof_dummy1);
+ }
-#if CALL_DUMMY_LOCATION == AFTER_TEXT_END
- {
- extern CORE_ADDR text_end;
- int errcode;
- sp = old_sp;
- real_pc = text_end;
- errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
- if (errcode != 0)
- error ("Cannot write text segment -- call_function failed");
- }
-#endif /* After text_end. */
+ if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
+ {
+ /* Convex Unix prohibits executing in the stack segment. */
+ /* Hope there is empty room at the top of the text segment. */
+ extern CORE_ADDR text_end;
+ static checked = 0;
+ if (!checked)
+ for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
+ if (read_memory_integer (start_sp, 1) != 0)
+ error ("text segment full -- no place to put call");
+ checked = 1;
+ sp = old_sp;
+ real_pc = text_end - sizeof_dummy1;
+ write_memory (real_pc, (char *)dummy1, sizeof_dummy1);
+ }
+
+ if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
+ {
+ extern CORE_ADDR text_end;
+ int errcode;
+ sp = old_sp;
+ real_pc = text_end;
+ errcode = target_write_memory (real_pc, (char *)dummy1, sizeof_dummy1);
+ if (errcode != 0)
+ error ("Cannot write text segment -- call_function failed");
+ }
-#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
- real_pc = funaddr;
-#endif /* At entry point. */
+ if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+ {
+ real_pc = funaddr;
+ }
#ifdef lint
sp = old_sp; /* It really is used, for some ifdef's... */
for (i = nargs - 1; i >= 0; i--)
len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
-#ifdef CALL_DUMMY_STACK_ADJUST
- len += CALL_DUMMY_STACK_ADJUST;
-#endif
+ if (CALL_DUMMY_STACK_ADJUST_P)
+ len += CALL_DUMMY_STACK_ADJUST;
sp -= STACK_ALIGN (len) - len;
}
#endif /* STACK_ALIGN */
{
/* If stack grows up, we must leave a hole at the bottom, note
that sp already has been advanced for the arguments! */
-#ifdef CALL_DUMMY_STACK_ADJUST
- sp += CALL_DUMMY_STACK_ADJUST;
-#endif
+ if (CALL_DUMMY_STACK_ADJUST_P)
+ sp += CALL_DUMMY_STACK_ADJUST;
sp = STACK_ALIGN (sp);
}
#endif /* STACK_ALIGN */
/* MVS 11/22/96: I think at least some of this stack_align code is
really broken. Better to let PUSH_ARGUMENTS adjust the stack in
a target-defined manner. */
-#ifdef CALL_DUMMY_STACK_ADJUST
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= CALL_DUMMY_STACK_ADJUST;
- }
-#endif /* CALL_DUMMY_STACK_ADJUST */
+ if (CALL_DUMMY_STACK_ADJUST_P)
+ if (INNER_THAN (1, 2))
+ {
+ /* stack grows downward */
+ sp -= CALL_DUMMY_STACK_ADJUST;
+ }
/* Store the address at which the structure is supposed to be
written. Note that this (and the code which reserved the space
{
/* We stopped somewhere besides the call dummy. */
- /* If we did the cleanups, we would print a spurious error message
- (Unable to restore previously selected frame), would write the
- registers from the inf_status (which is wrong), and would do other
- wrong things (like set stop_bpstat to the wrong thing). */
+ /* If we did the cleanups, we would print a spurious error
+ message (Unable to restore previously selected frame),
+ would write the registers from the inf_status (which is
+ wrong), and would do other wrong things. */
discard_cleanups (old_chain);
- /* Prevent memory leak. */
- bpstat_clear (&inf_status.stop_bpstat);
+ discard_inferior_status (inf_status);
/* The following error message used to say "The expression
which contained the function call has been discarded." It
return value_being_returned (value_type, retbuf, struct_return);
}
}
-#else /* no CALL_DUMMY. */
+
value_ptr
call_function_by_hand (function, nargs, args)
value_ptr function;
int nargs;
value_ptr *args;
{
- error ("Cannot invoke functions on this machine.");
+ if (CALL_DUMMY_P)
+ {
+ return hand_function_call (function, nargs, args);
+ }
+ else
+ {
+ error ("Cannot invoke functions on this machine.");
+ }
}
-#endif /* no CALL_DUMMY. */
+
\f
/* Create a value for an array by allocating space in the inferior, copying
* BASETYPE is set to the actual type of the subobject where the method is found
* BOFFSET is the offset of the base subobject where the method is found */
-struct fn_field *
+static struct fn_field *
find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
- value_ptr *argp;
- char * method;
- int offset;
- int * static_memfuncp;
- struct type * type;
- int * num_fns;
- struct type ** basetype;
- int * boffset;
+ value_ptr *argp;
+ char * method;
+ int offset;
+ int * static_memfuncp;
+ struct type * type;
+ int * num_fns;
+ struct type ** basetype;
+ int * boffset;
{
int i;
struct fn_field * f;
projects / deliverable / binutils-gdb.git / blobdiff