f4f9705a2d
* gdbarch.h, gdbarch.c: Regenerate. * defs.h (breakpoint_from_pc_fn): Delete type definition. * target.h (memory_breakpoint_from_pc): Update declaration. * config/mcore/tm-mcore.h (mcore_breakpoint_from_p): Ditto. * arch-utils.c (legacy_breakpoint_from_pc): Update return type. * mcore-tdep.c (mcore_breakpoint_from_pc): Ditto. * mem-break.c (memory_breakpoint_from_pc): Ditto. * rs6000-tdep.c (rs6000_breakpoint_from_pc): Ditto. * s390-tdep.c (s390_breakpoint_from_pc): Ditto * xstormy16-tdep.c (xstormy16_breakpoint_from_pc): Ditto. * mn10300-tdep.c (mn10300_breakpoint_from_pc): Ditto. * mips-tdep.c (mips_breakpoint_from_pc): Ditto. * m68hc11-tdep.c (m68hc11_breakpoint_from_pc): Ditto. * ia64-tdep.c (ia64_breakpoint_from_pc): Ditto. * d10v-tdep.c (d10v_breakpoint_from_pc): Ditto. * arch-utils.c (legacy_breakpoint_from_pc): Ditto.. * mem-break.c (default_memory_insert_breakpoint): Make `bp' a const pointer. * monitor.c (monitor_insert_breakpoint): Ditto. * rs6000-tdep.c (rs6000_software_single_step): Ditto for `breakp'. * config/mcore/tm-mcore.h: Update copyright. * mem-break.c: Ditto. * xstormy16-tdep.c: Ditto.
1146 lines
35 KiB
C
1146 lines
35 KiB
C
/* Target-dependent code for the Sanyo Xstormy16a (LC590000) processor.
|
|
|
|
Copyright 2001, 2002 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#include "defs.h"
|
|
#include "value.h"
|
|
#include "inferior.h"
|
|
#include "symfile.h"
|
|
#include "arch-utils.h"
|
|
#include "regcache.h"
|
|
#include "gdbcore.h"
|
|
#include "objfiles.h"
|
|
|
|
struct gdbarch_tdep
|
|
{
|
|
/* gdbarch target dependent data here. Currently unused for Xstormy16. */
|
|
};
|
|
|
|
/* Extra info which is saved in each frame_info. */
|
|
struct frame_extra_info
|
|
{
|
|
int framesize;
|
|
int frameless_p;
|
|
};
|
|
|
|
enum gdb_regnum
|
|
{
|
|
/* Xstormy16 has 16 general purpose registers (R0-R15) plus PC.
|
|
Functions will return their values in register R2-R7 as they fit.
|
|
Otherwise a hidden pointer to an big enough area is given as argument
|
|
to the function in r2. Further arguments are beginning in r3 then.
|
|
R13 is used as frame pointer when GCC compiles w/o optimization
|
|
R14 is used as "PSW", displaying the CPU status.
|
|
R15 is used implicitely as stack pointer. */
|
|
E_R0_REGNUM,
|
|
E_R1_REGNUM,
|
|
E_R2_REGNUM, E_1ST_ARG_REGNUM = E_R2_REGNUM, E_PTR_RET_REGNUM = E_R2_REGNUM,
|
|
E_R3_REGNUM,
|
|
E_R4_REGNUM,
|
|
E_R5_REGNUM,
|
|
E_R6_REGNUM,
|
|
E_R7_REGNUM, E_LST_ARG_REGNUM = E_R7_REGNUM,
|
|
E_R8_REGNUM,
|
|
E_R9_REGNUM,
|
|
E_R10_REGNUM,
|
|
E_R11_REGNUM,
|
|
E_R12_REGNUM,
|
|
E_R13_REGNUM, E_FP_REGNUM = E_R13_REGNUM,
|
|
E_R14_REGNUM, E_PSW_REGNUM = E_R14_REGNUM,
|
|
E_R15_REGNUM, E_SP_REGNUM = E_R15_REGNUM,
|
|
E_PC_REGNUM,
|
|
E_NUM_REGS
|
|
};
|
|
|
|
/* Size of instructions, registers, etc. */
|
|
enum
|
|
{
|
|
xstormy16_inst_size = 2,
|
|
xstormy16_reg_size = 2,
|
|
xstormy16_pc_size = 4
|
|
};
|
|
|
|
/* Size of return datatype which fits into the remaining return registers. */
|
|
#define E_MAX_RETTYPE_SIZE(regnum) ((E_LST_ARG_REGNUM - (regnum) + 1) \
|
|
* xstormy16_reg_size)
|
|
|
|
/* Size of return datatype which fits into all return registers. */
|
|
enum
|
|
{
|
|
E_MAX_RETTYPE_SIZE_IN_REGS = E_MAX_RETTYPE_SIZE (E_R2_REGNUM)
|
|
};
|
|
|
|
|
|
/* Size of all registers as a whole. */
|
|
enum
|
|
{
|
|
E_ALL_REGS_SIZE = (E_NUM_REGS - 1) * xstormy16_reg_size + xstormy16_pc_size
|
|
};
|
|
|
|
/* Function: xstormy16_register_name
|
|
Returns the name of the standard Xstormy16 register N. */
|
|
|
|
static char *
|
|
xstormy16_register_name (int regnum)
|
|
{
|
|
static char *register_names[] = {
|
|
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
|
|
"r8", "r9", "r10", "r11", "r12", "r13",
|
|
"psw", "sp", "pc"
|
|
};
|
|
|
|
if (regnum < 0 ||
|
|
regnum >= sizeof (register_names) / sizeof (register_names[0]))
|
|
internal_error (__FILE__, __LINE__,
|
|
"xstormy16_register_name: illegal register number %d",
|
|
regnum);
|
|
else
|
|
return register_names[regnum];
|
|
|
|
}
|
|
|
|
/* Function: xstormy16_register_byte
|
|
Returns the byte position in the register cache for register N. */
|
|
|
|
static int
|
|
xstormy16_register_byte (int regnum)
|
|
{
|
|
if (regnum < 0 || regnum >= E_NUM_REGS)
|
|
internal_error (__FILE__, __LINE__,
|
|
"xstormy16_register_byte: illegal register number %d",
|
|
regnum);
|
|
else
|
|
/* All registers occupy 2 bytes in the regcache except for PC
|
|
which is the last one. Therefore the byte position is still
|
|
simply a multiple of 2. */
|
|
return regnum * xstormy16_reg_size;
|
|
}
|
|
|
|
/* Function: xstormy16_register_raw_size
|
|
Returns the number of bytes occupied by the register on the target. */
|
|
|
|
static int
|
|
xstormy16_register_raw_size (int regnum)
|
|
{
|
|
if (regnum < 0 || regnum >= E_NUM_REGS)
|
|
internal_error (__FILE__, __LINE__,
|
|
"xstormy16_register_raw_size: illegal register number %d",
|
|
regnum);
|
|
/* Only the PC has 4 Byte, all other registers 2 Byte. */
|
|
else if (regnum == E_PC_REGNUM)
|
|
return xstormy16_pc_size;
|
|
else
|
|
return xstormy16_reg_size;
|
|
}
|
|
|
|
/* Function: xstormy16_register_virtual_size
|
|
Returns the number of bytes occupied by the register as represented
|
|
internally by gdb. */
|
|
|
|
static int
|
|
xstormy16_register_virtual_size (int regnum)
|
|
{
|
|
return xstormy16_register_raw_size (regnum);
|
|
}
|
|
|
|
/* Function: xstormy16_reg_virtual_type
|
|
Returns the default type for register N. */
|
|
|
|
static struct type *
|
|
xstormy16_reg_virtual_type (int regnum)
|
|
{
|
|
if (regnum < 0 || regnum >= E_NUM_REGS)
|
|
internal_error (__FILE__, __LINE__,
|
|
"xstormy16_register_virtual_type: illegal register number %d",
|
|
regnum);
|
|
else if (regnum == E_PC_REGNUM)
|
|
return builtin_type_uint32;
|
|
else
|
|
return builtin_type_uint16;
|
|
}
|
|
|
|
/* Function: xstormy16_get_saved_register
|
|
Find a register's saved value on the call stack. */
|
|
|
|
static void
|
|
xstormy16_get_saved_register (char *raw_buffer,
|
|
int *optimized,
|
|
CORE_ADDR *addrp,
|
|
struct frame_info *fi,
|
|
int regnum, enum lval_type *lval)
|
|
{
|
|
generic_get_saved_register (raw_buffer, optimized, addrp, fi, regnum, lval);
|
|
}
|
|
|
|
/* Function: xstormy16_type_is_scalar
|
|
Makes the decision if a given type is a scalar types. Scalar
|
|
types are returned in the registers r2-r7 as they fit. */
|
|
|
|
static int
|
|
xstormy16_type_is_scalar (struct type *t)
|
|
{
|
|
return (TYPE_CODE(t) != TYPE_CODE_STRUCT
|
|
&& TYPE_CODE(t) != TYPE_CODE_UNION
|
|
&& TYPE_CODE(t) != TYPE_CODE_ARRAY);
|
|
}
|
|
|
|
/* Function: xstormy16_extract_return_value
|
|
Copy the function's return value into VALBUF.
|
|
This function is called only in the context of "target function calls",
|
|
ie. when the debugger forces a function to be called in the child, and
|
|
when the debugger forces a function to return prematurely via the
|
|
"return" command. */
|
|
|
|
static void
|
|
xstormy16_extract_return_value (struct type *type, char *regbuf, char *valbuf)
|
|
{
|
|
CORE_ADDR return_buffer;
|
|
int offset = 0;
|
|
|
|
if (xstormy16_type_is_scalar (type)
|
|
&& TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
|
|
{
|
|
/* Scalar return values of <= 12 bytes are returned in
|
|
E_1ST_ARG_REGNUM to E_LST_ARG_REGNUM. */
|
|
memcpy (valbuf,
|
|
®buf[REGISTER_BYTE (E_1ST_ARG_REGNUM)] + offset,
|
|
TYPE_LENGTH (type));
|
|
}
|
|
else
|
|
{
|
|
/* Aggregates and return values > 12 bytes are returned in memory,
|
|
pointed to by R2. */
|
|
return_buffer =
|
|
extract_address (regbuf + REGISTER_BYTE (E_PTR_RET_REGNUM),
|
|
REGISTER_RAW_SIZE (E_PTR_RET_REGNUM));
|
|
|
|
read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
|
|
}
|
|
}
|
|
|
|
/* Function: xstormy16_push_arguments
|
|
Setup the function arguments for GDB to call a function in the inferior.
|
|
Called only in the context of a target function call from the debugger.
|
|
Returns the value of the SP register after the args are pushed.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
|
|
int struct_return, CORE_ADDR struct_addr)
|
|
{
|
|
CORE_ADDR stack_dest = sp;
|
|
int argreg = E_1ST_ARG_REGNUM;
|
|
int i, j;
|
|
int typelen, slacklen;
|
|
char *val;
|
|
|
|
/* If struct_return is true, then the struct return address will
|
|
consume one argument-passing register. */
|
|
if (struct_return)
|
|
argreg++;
|
|
|
|
/* Arguments are passed in R2-R7 as they fit. If an argument doesn't
|
|
fit in the remaining registers we're switching over to the stack.
|
|
No argument is put on stack partially and as soon as we switched
|
|
over to stack no further argument is put in a register even if it
|
|
would fit in the remaining unused registers. */
|
|
for (i = 0; i < nargs && argreg <= E_LST_ARG_REGNUM; i++)
|
|
{
|
|
typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
|
|
if (typelen > E_MAX_RETTYPE_SIZE (argreg))
|
|
break;
|
|
|
|
/* Put argument into registers wordwise. */
|
|
val = VALUE_CONTENTS (args[i]);
|
|
for (j = 0; j < typelen; j += xstormy16_reg_size)
|
|
write_register (argreg++,
|
|
extract_unsigned_integer (val + j,
|
|
typelen - j ==
|
|
1 ? 1 :
|
|
xstormy16_reg_size));
|
|
}
|
|
|
|
/* Align SP */
|
|
if (stack_dest & 1)
|
|
++stack_dest;
|
|
|
|
/* Loop backwards through remaining arguments and push them on the stack,
|
|
wordaligned. */
|
|
for (j = nargs - 1; j >= i; j--)
|
|
{
|
|
typelen = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[j]));
|
|
slacklen = typelen & 1;
|
|
val = alloca (typelen + slacklen);
|
|
memcpy (val, VALUE_CONTENTS (args[j]), typelen);
|
|
memset (val + typelen, 0, slacklen);
|
|
|
|
/* Now write this data to the stack. The stack grows upwards. */
|
|
write_memory (stack_dest, val, typelen + slacklen);
|
|
stack_dest += typelen + slacklen;
|
|
}
|
|
|
|
/* And that should do it. Return the new stack pointer. */
|
|
return stack_dest;
|
|
}
|
|
|
|
/* Function: xstormy16_push_return_address (pc)
|
|
Setup the return address for GDB to call a function in the inferior.
|
|
Called only in the context of a target function call from the debugger.
|
|
Returns the value of the SP register when the operation is finished
|
|
(which may or may not be the same as before).
|
|
*/
|
|
|
|
CORE_ADDR
|
|
xstormy16_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
|
|
{
|
|
unsigned char buf[xstormy16_pc_size];
|
|
|
|
store_unsigned_integer (buf, xstormy16_pc_size, CALL_DUMMY_ADDRESS ());
|
|
write_memory (sp, buf, xstormy16_pc_size);
|
|
return sp + xstormy16_pc_size;
|
|
}
|
|
|
|
/* Function: xstormy16_pop_frame
|
|
Destroy the innermost (Top-Of-Stack) stack frame, restoring the
|
|
machine state that was in effect before the frame was created.
|
|
Used in the contexts of the "return" command, and of
|
|
target function calls from the debugger.
|
|
*/
|
|
|
|
static void
|
|
xstormy16_pop_frame (void)
|
|
{
|
|
struct frame_info *fi = get_current_frame ();
|
|
int i;
|
|
|
|
if (fi == NULL)
|
|
return; /* paranoia */
|
|
|
|
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
|
|
{
|
|
generic_pop_dummy_frame ();
|
|
}
|
|
else
|
|
{
|
|
/* Restore the saved regs. */
|
|
for (i = 0; i < NUM_REGS; i++)
|
|
if (fi->saved_regs[i])
|
|
{
|
|
if (i == SP_REGNUM)
|
|
write_register (i, fi->saved_regs[i]);
|
|
else if (i == E_PC_REGNUM)
|
|
write_register (i, read_memory_integer (fi->saved_regs[i],
|
|
xstormy16_pc_size));
|
|
else
|
|
write_register (i, read_memory_integer (fi->saved_regs[i],
|
|
xstormy16_reg_size));
|
|
}
|
|
/* Restore the PC */
|
|
write_register (PC_REGNUM, FRAME_SAVED_PC (fi));
|
|
flush_cached_frames ();
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Function: xstormy16_store_struct_return
|
|
Copy the (struct) function return value to its destined location.
|
|
Called only in the context of a target function call from the debugger.
|
|
*/
|
|
|
|
static void
|
|
xstormy16_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
|
|
{
|
|
write_register (E_PTR_RET_REGNUM, addr);
|
|
}
|
|
|
|
/* Function: xstormy16_store_return_value
|
|
Copy the function return value from VALBUF into the
|
|
proper location for a function return.
|
|
Called only in the context of the "return" command.
|
|
*/
|
|
|
|
static void
|
|
xstormy16_store_return_value (struct type *type, char *valbuf)
|
|
{
|
|
CORE_ADDR return_buffer;
|
|
char buf[xstormy16_reg_size];
|
|
|
|
if (xstormy16_type_is_scalar (type) && TYPE_LENGTH (type) == 1)
|
|
{
|
|
/* Add leading zeros to the value. */
|
|
memset (buf, 0, xstormy16_reg_size);
|
|
memcpy (buf, valbuf, 1);
|
|
write_register_gen (E_1ST_ARG_REGNUM, buf);
|
|
}
|
|
else if (xstormy16_type_is_scalar (type) &&
|
|
TYPE_LENGTH (type) <= E_MAX_RETTYPE_SIZE_IN_REGS)
|
|
write_register_bytes (REGISTER_BYTE (E_1ST_ARG_REGNUM),
|
|
valbuf, TYPE_LENGTH (type));
|
|
else
|
|
{
|
|
return_buffer = read_register (E_PTR_RET_REGNUM);
|
|
write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
|
|
}
|
|
}
|
|
|
|
/* Function: xstormy16_extract_struct_value_address
|
|
Returns the address in which a function should return a struct value.
|
|
Used in the contexts of the "return" command, and of
|
|
target function calls from the debugger.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_extract_struct_value_address (char *regbuf)
|
|
{
|
|
return extract_address (regbuf +
|
|
xstormy16_register_byte (E_PTR_RET_REGNUM),
|
|
xstormy16_reg_size);
|
|
}
|
|
|
|
/* Function: xstormy16_use_struct_convention
|
|
Returns non-zero if the given struct type will be returned using
|
|
a special convention, rather than the normal function return method.
|
|
7sed in the contexts of the "return" command, and of
|
|
target function calls from the debugger.
|
|
*/
|
|
|
|
static int
|
|
xstormy16_use_struct_convention (int gcc_p, struct type *type)
|
|
{
|
|
return !xstormy16_type_is_scalar (type)
|
|
|| TYPE_LENGTH (type) > E_MAX_RETTYPE_SIZE_IN_REGS;
|
|
}
|
|
|
|
/* Function: frame_saved_register
|
|
Returns the value that regnum had in frame fi
|
|
(saved in fi or in one of its children).
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_frame_saved_register (struct frame_info *fi, int regnum)
|
|
{
|
|
int size = xstormy16_register_raw_size (regnum);
|
|
char *buf = (char *) alloca (size);
|
|
|
|
generic_get_saved_register (buf, NULL, NULL, fi, regnum, NULL);
|
|
return (CORE_ADDR) extract_unsigned_integer (buf, size);
|
|
}
|
|
|
|
/* Function: xstormy16_scan_prologue
|
|
Decode the instructions within the given address range.
|
|
Decide when we must have reached the end of the function prologue.
|
|
If a frame_info pointer is provided, fill in its saved_regs etc.
|
|
|
|
Returns the address of the first instruction after the prologue.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_scan_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
|
|
struct frame_info *fi, int *frameless)
|
|
{
|
|
CORE_ADDR sp = 0, fp = 0;
|
|
CORE_ADDR next_addr;
|
|
ULONGEST inst, inst2;
|
|
LONGEST offset;
|
|
int regnum;
|
|
|
|
if (frameless)
|
|
*frameless = 1;
|
|
if (fi)
|
|
{
|
|
/* In a call dummy, don't touch the frame. */
|
|
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
|
|
return start_addr;
|
|
|
|
/* Grab the frame-relative values of SP and FP, needed below.
|
|
The frame_saved_register function will find them on the
|
|
stack or in the registers as appropriate. */
|
|
sp = xstormy16_frame_saved_register (fi, E_SP_REGNUM);
|
|
fp = xstormy16_frame_saved_register (fi, E_FP_REGNUM);
|
|
|
|
/* Initialize framesize with size of PC put on stack by CALLF inst. */
|
|
fi->extra_info->framesize = xstormy16_pc_size;
|
|
}
|
|
for (next_addr = start_addr;
|
|
next_addr < end_addr; next_addr += xstormy16_inst_size)
|
|
{
|
|
inst = read_memory_unsigned_integer (next_addr, xstormy16_inst_size);
|
|
inst2 = read_memory_unsigned_integer (next_addr + xstormy16_inst_size,
|
|
xstormy16_inst_size);
|
|
|
|
if (inst >= 0x0082 && inst <= 0x008d) /* push r2 .. push r13 */
|
|
{
|
|
if (fi)
|
|
{
|
|
regnum = inst & 0x000f;
|
|
fi->saved_regs[regnum] = fi->extra_info->framesize;
|
|
fi->extra_info->framesize += xstormy16_reg_size;
|
|
}
|
|
}
|
|
|
|
/* optional stack allocation for args and local vars <= 4 byte */
|
|
else if (inst == 0x301f || inst == 0x303f) /* inc r15, #0x1/#0x3 */
|
|
{
|
|
if (fi) /* Record the frame size. */
|
|
fi->extra_info->framesize += ((inst & 0x0030) >> 4) + 1;
|
|
}
|
|
|
|
/* optional stack allocation for args and local vars > 4 && < 16 byte */
|
|
else if ((inst & 0xff0f) == 0x510f) /* 51Hf add r15, #0xH */
|
|
{
|
|
if (fi) /* Record the frame size. */
|
|
fi->extra_info->framesize += (inst & 0x00f0) >> 4;
|
|
}
|
|
|
|
/* optional stack allocation for args and local vars >= 16 byte */
|
|
else if (inst == 0x314f && inst2 >= 0x0010) /* 314f HHHH add r15, #0xH */
|
|
{
|
|
if (fi) /* Record the frame size. */
|
|
fi->extra_info->framesize += inst2;
|
|
next_addr += xstormy16_inst_size;
|
|
}
|
|
|
|
else if (inst == 0x46fd) /* mov r13, r15 */
|
|
{
|
|
if (fi) /* Record that the frame pointer is in use. */
|
|
fi->extra_info->frameless_p = 0;
|
|
if (frameless)
|
|
*frameless = 0;
|
|
}
|
|
|
|
/* optional copying of args in r2-r7 to r10-r13 */
|
|
/* Probably only in optimized case but legal action for prologue */
|
|
else if ((inst & 0xff00) == 0x4600 /* 46SD mov rD, rS */
|
|
&& (inst & 0x00f0) >= 0x0020 && (inst & 0x00f0) <= 0x0070
|
|
&& (inst & 0x000f) >= 0x00a0 && (inst & 0x000f) <= 0x000d)
|
|
;
|
|
|
|
/* optional copying of args in r2-r7 to stack */
|
|
/* 72DS HHHH mov.b (rD, 0xHHHH), r(S-8) (bit3 always 1, bit2-0 = reg) */
|
|
/* 73DS HHHH mov.w (rD, 0xHHHH), r(S-8) */
|
|
else if ((inst & 0xfed8) == 0x72d8 && (inst & 0x0007) >= 2)
|
|
{
|
|
if (fi)
|
|
{
|
|
regnum = inst & 0x0007;
|
|
/* Only 12 of 16 bits of the argument are used for the
|
|
signed offset. */
|
|
offset = (LONGEST) (inst2 & 0x0fff);
|
|
if (offset & 0x0800)
|
|
offset -= 0x1000;
|
|
|
|
fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
|
|
}
|
|
next_addr += xstormy16_inst_size;
|
|
}
|
|
|
|
#if 0
|
|
/* 2001-08-10: Not part of the prologue anymore due to change in
|
|
ABI. r8 and r9 are not used for argument passing anymore. */
|
|
|
|
/* optional copying of r8, r9 to stack */
|
|
/* 46S7; 73Df HHHH mov.w r7,rS; mov.w (rD, 0xHHHH), r7 D=8,9; S=13,15 */
|
|
/* 46S7; 72df HHHH mov.w r7,rS; mov.b (rD, 0xHHHH), r7 D=8,9; S=13,15 */
|
|
else if ((inst & 0xffef) == 0x4687 && (inst2 & 0xfedf) == 0x72df)
|
|
{
|
|
next_addr += xstormy16_inst_size;
|
|
if (fi)
|
|
{
|
|
regnum = (inst & 0x00f0) >> 4;
|
|
inst = inst2;
|
|
inst2 = read_memory_unsigned_integer (next_addr
|
|
+ xstormy16_inst_size,
|
|
xstormy16_inst_size);
|
|
/* Only 12 of 16 bits of the argument are used for the
|
|
signed offset. */
|
|
offset = (LONGEST) (inst2 & 0x0fff);
|
|
if (offset & 0x0800)
|
|
offset -= 0x1000;
|
|
|
|
fi->saved_regs[regnum] = fi->extra_info->framesize + offset;
|
|
}
|
|
next_addr += xstormy16_inst_size;
|
|
}
|
|
#endif
|
|
|
|
else /* Not a prologue instruction. */
|
|
break;
|
|
}
|
|
|
|
if (fi)
|
|
{
|
|
/* Special handling for the "saved" address of the SP:
|
|
The SP is of course never saved on the stack at all, so
|
|
by convention what we put here is simply the previous
|
|
_value_ of the SP (as opposed to an address where the
|
|
previous value would have been pushed). */
|
|
if (fi->extra_info->frameless_p)
|
|
{
|
|
fi->saved_regs[E_SP_REGNUM] = sp - fi->extra_info->framesize;
|
|
fi->frame = sp;
|
|
}
|
|
else
|
|
{
|
|
fi->saved_regs[E_SP_REGNUM] = fp - fi->extra_info->framesize;
|
|
fi->frame = fp;
|
|
}
|
|
|
|
/* So far only offsets to the beginning of the frame are
|
|
saved in the saved_regs. Now we now the relation between
|
|
sp, fp and framesize. We know the beginning of the frame
|
|
so we can translate the register offsets to real addresses. */
|
|
for (regnum = 0; regnum < E_SP_REGNUM; ++regnum)
|
|
if (fi->saved_regs[regnum])
|
|
fi->saved_regs[regnum] += fi->saved_regs[E_SP_REGNUM];
|
|
|
|
/* Save address of PC on stack. */
|
|
fi->saved_regs[E_PC_REGNUM] = fi->saved_regs[E_SP_REGNUM];
|
|
}
|
|
|
|
return next_addr;
|
|
}
|
|
|
|
/* Function: xstormy16_skip_prologue
|
|
If the input address is in a function prologue,
|
|
returns the address of the end of the prologue;
|
|
else returns the input address.
|
|
|
|
Note: the input address is likely to be the function start,
|
|
since this function is mainly used for advancing a breakpoint
|
|
to the first line, or stepping to the first line when we have
|
|
stepped into a function call. */
|
|
|
|
static CORE_ADDR
|
|
xstormy16_skip_prologue (CORE_ADDR pc)
|
|
{
|
|
CORE_ADDR func_addr = 0, func_end = 0;
|
|
char *func_name;
|
|
|
|
if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
|
|
{
|
|
struct symtab_and_line sal;
|
|
struct symbol *sym;
|
|
|
|
/* Don't trust line number debug info in frameless functions. */
|
|
int frameless = 1;
|
|
CORE_ADDR plg_end = xstormy16_scan_prologue (func_addr, func_end,
|
|
NULL, &frameless);
|
|
if (frameless)
|
|
return plg_end;
|
|
|
|
/* Found a function. */
|
|
sym = lookup_symbol (func_name, NULL, VAR_NAMESPACE, NULL, NULL);
|
|
/* Don't use line number debug info for assembly source files. */
|
|
if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
|
|
{
|
|
sal = find_pc_line (func_addr, 0);
|
|
if (sal.end && sal.end < func_end)
|
|
{
|
|
/* Found a line number, use it as end of prologue. */
|
|
return sal.end;
|
|
}
|
|
}
|
|
/* No useable line symbol. Use result of prologue parsing method. */
|
|
return plg_end;
|
|
}
|
|
|
|
/* No function symbol -- just return the PC. */
|
|
|
|
return (CORE_ADDR) pc;
|
|
}
|
|
|
|
/* The epilogue is defined here as the area at the end of a function,
|
|
either on the `ret' instruction itself or after an instruction which
|
|
destroys the function's stack frame. */
|
|
static int
|
|
xstormy16_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
|
|
{
|
|
CORE_ADDR addr, func_addr = 0, func_end = 0;
|
|
|
|
if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
|
|
{
|
|
ULONGEST inst, inst2;
|
|
CORE_ADDR addr = func_end - xstormy16_inst_size;
|
|
|
|
/* The Xstormy16 epilogue is max. 14 bytes long. */
|
|
if (pc < func_end - 7 * xstormy16_inst_size)
|
|
return 0;
|
|
|
|
/* Check if we're on a `ret' instruction. Otherwise it's
|
|
too dangerous to proceed. */
|
|
inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
|
|
if (inst != 0x0003)
|
|
return 0;
|
|
|
|
while ((addr -= xstormy16_inst_size) >= func_addr)
|
|
{
|
|
inst = read_memory_unsigned_integer (addr, xstormy16_inst_size);
|
|
if (inst >= 0x009a && inst <= 0x009d) /* pop r10...r13 */
|
|
continue;
|
|
if (inst == 0x305f || inst == 0x307f) /* dec r15, #0x1/#0x3 */
|
|
break;
|
|
inst2 = read_memory_unsigned_integer (addr - xstormy16_inst_size,
|
|
xstormy16_inst_size);
|
|
if (inst2 == 0x314f && inst >= 0x8000) /* add r15, neg. value */
|
|
{
|
|
addr -= xstormy16_inst_size;
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
if (pc > addr)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Function: xstormy16_frame_init_saved_regs
|
|
Set up the 'saved_regs' array.
|
|
This is a data structure containing the addresses on the stack
|
|
where each register has been saved, for each stack frame.
|
|
Registers that have not been saved will have zero here.
|
|
The stack register is special: rather than the address where the
|
|
stack register has been saved, saved_regs[SP_REGNUM] will have the
|
|
actual value of the previous frame's stack register.
|
|
|
|
This function may be called in any context where the saved register
|
|
values may be needed (backtrace, frame_info, get_saved_register).
|
|
On many targets, it is called directly by init_extra_frame_info,
|
|
in part because the information may be needed immediately by
|
|
frame_chain.
|
|
*/
|
|
|
|
static void
|
|
xstormy16_frame_init_saved_regs (struct frame_info *fi)
|
|
{
|
|
CORE_ADDR func_addr, func_end;
|
|
|
|
if (!fi->saved_regs)
|
|
{
|
|
frame_saved_regs_zalloc (fi);
|
|
|
|
/* Find the beginning of this function, so we can analyze its
|
|
prologue. */
|
|
if (find_pc_partial_function (fi->pc, NULL, &func_addr, &func_end))
|
|
xstormy16_scan_prologue (func_addr, fi->pc, fi, NULL);
|
|
/* Else we're out of luck (can't debug completely stripped code).
|
|
FIXME. */
|
|
}
|
|
}
|
|
|
|
/* Function: xstormy16_frame_saved_pc
|
|
Returns the return address for the selected frame.
|
|
Called by frame_info, frame_chain_valid, and sometimes by
|
|
get_prev_frame.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_frame_saved_pc (struct frame_info *fi)
|
|
{
|
|
CORE_ADDR saved_pc;
|
|
|
|
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
|
|
{
|
|
saved_pc = generic_read_register_dummy (fi->pc, fi->frame, E_PC_REGNUM);
|
|
}
|
|
else
|
|
{
|
|
saved_pc = read_memory_unsigned_integer (fi->saved_regs[E_PC_REGNUM],
|
|
xstormy16_pc_size);
|
|
}
|
|
|
|
return saved_pc;
|
|
}
|
|
|
|
/* Function: xstormy16_init_extra_frame_info
|
|
This is the constructor function for the frame_info struct,
|
|
called whenever a new frame_info is created (from create_new_frame,
|
|
and from get_prev_frame).
|
|
*/
|
|
|
|
static void
|
|
xstormy16_init_extra_frame_info (int fromleaf, struct frame_info *fi)
|
|
{
|
|
if (!fi->extra_info)
|
|
{
|
|
fi->extra_info = (struct frame_extra_info *)
|
|
frame_obstack_alloc (sizeof (struct frame_extra_info));
|
|
fi->extra_info->framesize = 0;
|
|
fi->extra_info->frameless_p = 1; /* Default frameless, detect framed */
|
|
|
|
/* By default, the fi->frame is set to the value of the FP reg by gdb.
|
|
This may not always be right; we may be in a frameless function,
|
|
or we may be in the prologue, before the FP has been set up.
|
|
Unfortunately, we can't make this determination without first
|
|
calling scan_prologue, and we can't do that unles we know the
|
|
fi->pc. */
|
|
|
|
if (!fi->pc)
|
|
{
|
|
/* Sometimes we are called from get_prev_frame without
|
|
the PC being set up first. Long history, don't ask.
|
|
Fortunately this will never happen from the outermost
|
|
frame, so we should be able to get the saved pc from
|
|
the next frame. */
|
|
if (fi->next)
|
|
fi->pc = xstormy16_frame_saved_pc (fi->next);
|
|
}
|
|
|
|
/* Take care of the saved_regs right here (non-lazy). */
|
|
xstormy16_frame_init_saved_regs (fi);
|
|
}
|
|
}
|
|
|
|
/* Function: xstormy16_frame_chain
|
|
Returns a pointer to the stack frame of the calling function.
|
|
Called only from get_prev_frame. Needed for backtrace, "up", etc.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_frame_chain (struct frame_info *fi)
|
|
{
|
|
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
|
|
{
|
|
/* Call dummy's frame is the same as caller's. */
|
|
return fi->frame;
|
|
}
|
|
else
|
|
{
|
|
/* Return computed offset from this frame's fp. */
|
|
return fi->frame - fi->extra_info->framesize;
|
|
}
|
|
}
|
|
|
|
static int
|
|
xstormy16_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
|
|
{
|
|
return chain < 0x8000 && FRAME_SAVED_PC (thisframe) >= 0x8000 &&
|
|
(thisframe->extra_info->frameless_p ||
|
|
thisframe->frame - thisframe->extra_info->framesize == chain);
|
|
}
|
|
|
|
/* Function: xstormy16_saved_pc_after_call
|
|
Returns the previous PC immediately after a function call.
|
|
This function is meant to bypass the regular get_saved_register
|
|
mechanism, ie. it is meant to work even if the frame isn't complete.
|
|
Called by step_over_function, and sometimes by get_prev_frame.
|
|
*/
|
|
|
|
static CORE_ADDR
|
|
xstormy16_saved_pc_after_call (struct frame_info *ignore)
|
|
{
|
|
CORE_ADDR sp, pc, tmp;
|
|
|
|
sp = read_register (E_SP_REGNUM) - xstormy16_pc_size;
|
|
pc = read_memory_integer (sp, xstormy16_pc_size);
|
|
|
|
/* Skip over jump table entry if necessary. */
|
|
if ((tmp = SKIP_TRAMPOLINE_CODE (pc)))
|
|
pc = tmp;
|
|
|
|
return pc;
|
|
}
|
|
|
|
const static unsigned char *
|
|
xstormy16_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
|
|
{
|
|
static unsigned char breakpoint[] = { 0x06, 0x0 };
|
|
*lenptr = sizeof (breakpoint);
|
|
return breakpoint;
|
|
}
|
|
|
|
/* Given a pointer to a jump table entry, return the address
|
|
of the function it jumps to. Return 0 if not found. */
|
|
static CORE_ADDR
|
|
xstormy16_resolve_jmp_table_entry (CORE_ADDR faddr)
|
|
{
|
|
struct obj_section *faddr_sect = find_pc_section (faddr);
|
|
|
|
if (faddr_sect)
|
|
{
|
|
LONGEST inst, inst2, addr;
|
|
char buf[2 * xstormy16_inst_size];
|
|
|
|
/* Return faddr if it's not pointing into the jump table. */
|
|
if (strcmp (faddr_sect->the_bfd_section->name, ".plt"))
|
|
return faddr;
|
|
|
|
if (!target_read_memory (faddr, buf, sizeof buf))
|
|
{
|
|
inst = extract_unsigned_integer (buf, xstormy16_inst_size);
|
|
inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
|
|
xstormy16_inst_size);
|
|
addr = inst2 << 8 | (inst & 0xff);
|
|
return addr;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Given a function's address, attempt to find (and return) the
|
|
address of the corresponding jump table entry. Return 0 if
|
|
not found. */
|
|
static CORE_ADDR
|
|
xstormy16_find_jmp_table_entry (CORE_ADDR faddr)
|
|
{
|
|
struct obj_section *faddr_sect = find_pc_section (faddr);
|
|
|
|
if (faddr_sect)
|
|
{
|
|
struct obj_section *osect;
|
|
|
|
/* Return faddr if it's already a pointer to a jump table entry. */
|
|
if (!strcmp (faddr_sect->the_bfd_section->name, ".plt"))
|
|
return faddr;
|
|
|
|
ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect)
|
|
{
|
|
if (!strcmp (osect->the_bfd_section->name, ".plt"))
|
|
break;
|
|
}
|
|
|
|
if (osect < faddr_sect->objfile->sections_end)
|
|
{
|
|
CORE_ADDR addr;
|
|
for (addr = osect->addr;
|
|
addr < osect->endaddr; addr += 2 * xstormy16_inst_size)
|
|
{
|
|
int status;
|
|
LONGEST inst, inst2, faddr2;
|
|
char buf[2 * xstormy16_inst_size];
|
|
|
|
if (target_read_memory (addr, buf, sizeof buf))
|
|
return 0;
|
|
inst = extract_unsigned_integer (buf, xstormy16_inst_size);
|
|
inst2 = extract_unsigned_integer (buf + xstormy16_inst_size,
|
|
xstormy16_inst_size);
|
|
faddr2 = inst2 << 8 | (inst & 0xff);
|
|
if (faddr == faddr2)
|
|
return addr;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static CORE_ADDR
|
|
xstormy16_skip_trampoline_code (CORE_ADDR pc)
|
|
{
|
|
int tmp = xstormy16_resolve_jmp_table_entry (pc);
|
|
|
|
if (tmp && tmp != pc)
|
|
return tmp;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
xstormy16_in_solib_call_trampoline (CORE_ADDR pc, char *name)
|
|
{
|
|
return xstormy16_skip_trampoline_code (pc) != 0;
|
|
}
|
|
|
|
static CORE_ADDR
|
|
xstormy16_pointer_to_address (struct type *type, void *buf)
|
|
{
|
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
|
CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
|
|
|
|
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
|
|
{
|
|
CORE_ADDR addr2 = xstormy16_resolve_jmp_table_entry (addr);
|
|
if (addr2)
|
|
addr = addr2;
|
|
}
|
|
|
|
return addr;
|
|
}
|
|
|
|
static void
|
|
xstormy16_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
|
|
{
|
|
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
|
|
|
|
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
|
|
{
|
|
CORE_ADDR addr2 = xstormy16_find_jmp_table_entry (addr);
|
|
if (addr2)
|
|
addr = addr2;
|
|
}
|
|
store_address (buf, TYPE_LENGTH (type), addr);
|
|
}
|
|
|
|
static CORE_ADDR
|
|
xstormy16_stack_align (CORE_ADDR addr)
|
|
{
|
|
if (addr & 1)
|
|
++addr;
|
|
return addr;
|
|
}
|
|
|
|
void
|
|
xstormy16_save_dummy_frame_tos (CORE_ADDR sp)
|
|
{
|
|
generic_save_dummy_frame_tos (sp - xstormy16_pc_size);
|
|
}
|
|
|
|
/* Function: xstormy16_gdbarch_init
|
|
Initializer function for the xstormy16 gdbarch vector.
|
|
Called by gdbarch. Sets up the gdbarch vector(s) for this target. */
|
|
|
|
static struct gdbarch *
|
|
xstormy16_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|
{
|
|
static LONGEST call_dummy_words[1] = { 0 };
|
|
struct gdbarch_tdep *tdep = NULL;
|
|
struct gdbarch *gdbarch;
|
|
|
|
/* find a candidate among the list of pre-declared architectures. */
|
|
arches = gdbarch_list_lookup_by_info (arches, &info);
|
|
if (arches != NULL)
|
|
return (arches->gdbarch);
|
|
|
|
#if 0
|
|
tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
|
|
#endif
|
|
|
|
gdbarch = gdbarch_alloc (&info, 0);
|
|
|
|
/*
|
|
* Basic register fields and methods.
|
|
*/
|
|
|
|
set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
|
|
set_gdbarch_num_pseudo_regs (gdbarch, 0);
|
|
set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
|
|
set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
|
|
set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
|
|
set_gdbarch_register_name (gdbarch, xstormy16_register_name);
|
|
set_gdbarch_register_size (gdbarch, xstormy16_reg_size);
|
|
set_gdbarch_register_bytes (gdbarch, E_ALL_REGS_SIZE);
|
|
set_gdbarch_register_byte (gdbarch, xstormy16_register_byte);
|
|
set_gdbarch_register_raw_size (gdbarch, xstormy16_register_raw_size);
|
|
set_gdbarch_max_register_raw_size (gdbarch, xstormy16_pc_size);
|
|
set_gdbarch_register_virtual_size (gdbarch, xstormy16_register_raw_size);
|
|
set_gdbarch_max_register_virtual_size (gdbarch, 4);
|
|
set_gdbarch_register_virtual_type (gdbarch, xstormy16_reg_virtual_type);
|
|
|
|
/*
|
|
* Frame Info
|
|
*/
|
|
set_gdbarch_init_extra_frame_info (gdbarch,
|
|
xstormy16_init_extra_frame_info);
|
|
set_gdbarch_frame_init_saved_regs (gdbarch,
|
|
xstormy16_frame_init_saved_regs);
|
|
set_gdbarch_frame_chain (gdbarch, xstormy16_frame_chain);
|
|
set_gdbarch_get_saved_register (gdbarch, xstormy16_get_saved_register);
|
|
set_gdbarch_saved_pc_after_call (gdbarch, xstormy16_saved_pc_after_call);
|
|
set_gdbarch_frame_saved_pc (gdbarch, xstormy16_frame_saved_pc);
|
|
set_gdbarch_skip_prologue (gdbarch, xstormy16_skip_prologue);
|
|
set_gdbarch_frame_chain_valid (gdbarch, xstormy16_frame_chain_valid);
|
|
set_gdbarch_frame_args_address (gdbarch, default_frame_address);
|
|
set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
|
|
|
|
set_gdbarch_in_function_epilogue_p (gdbarch,
|
|
xstormy16_in_function_epilogue_p);
|
|
|
|
/*
|
|
* Miscelany
|
|
*/
|
|
/* Stack grows up. */
|
|
set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
|
|
/* PC stops zero byte after a trap instruction
|
|
(which means: exactly on trap instruction). */
|
|
set_gdbarch_decr_pc_after_break (gdbarch, 0);
|
|
/* This value is almost never non-zero... */
|
|
set_gdbarch_function_start_offset (gdbarch, 0);
|
|
/* This value is almost never non-zero... */
|
|
set_gdbarch_frame_args_skip (gdbarch, 0);
|
|
/* OK to default this value to 'unknown'. */
|
|
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
|
|
|
|
/* W/o prototype, coerce float args to double. */
|
|
set_gdbarch_coerce_float_to_double (gdbarch,
|
|
standard_coerce_float_to_double);
|
|
|
|
/*
|
|
* Call Dummies
|
|
*
|
|
* These values and methods are used when gdb calls a target function. */
|
|
set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
|
|
set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
|
|
set_gdbarch_push_return_address (gdbarch, xstormy16_push_return_address);
|
|
set_gdbarch_extract_return_value (gdbarch, xstormy16_extract_return_value);
|
|
set_gdbarch_push_arguments (gdbarch, xstormy16_push_arguments);
|
|
set_gdbarch_pop_frame (gdbarch, xstormy16_pop_frame);
|
|
set_gdbarch_store_struct_return (gdbarch, xstormy16_store_struct_return);
|
|
set_gdbarch_store_return_value (gdbarch, xstormy16_store_return_value);
|
|
set_gdbarch_extract_struct_value_address (gdbarch,
|
|
xstormy16_extract_struct_value_address);
|
|
set_gdbarch_use_struct_convention (gdbarch,
|
|
xstormy16_use_struct_convention);
|
|
set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
|
|
set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
|
|
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
|
|
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
|
|
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
|
|
set_gdbarch_call_dummy_length (gdbarch, 0);
|
|
set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
|
|
set_gdbarch_call_dummy_p (gdbarch, 1);
|
|
set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
|
|
set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
|
|
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
|
|
/* set_gdbarch_call_dummy_stack_adjust */
|
|
set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
|
|
set_gdbarch_breakpoint_from_pc (gdbarch, xstormy16_breakpoint_from_pc);
|
|
|
|
set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
|
|
set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
|
|
set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
|
|
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
|
|
|
|
set_gdbarch_address_to_pointer (gdbarch, xstormy16_address_to_pointer);
|
|
set_gdbarch_pointer_to_address (gdbarch, xstormy16_pointer_to_address);
|
|
|
|
set_gdbarch_stack_align (gdbarch, xstormy16_stack_align);
|
|
set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
|
|
|
|
set_gdbarch_save_dummy_frame_tos (gdbarch, xstormy16_save_dummy_frame_tos);
|
|
|
|
set_gdbarch_skip_trampoline_code (gdbarch, xstormy16_skip_trampoline_code);
|
|
|
|
set_gdbarch_in_solib_call_trampoline (gdbarch,
|
|
xstormy16_in_solib_call_trampoline);
|
|
|
|
return gdbarch;
|
|
}
|
|
|
|
/* Function: _initialize_xstormy16_tdep
|
|
Initializer function for the Sanyo Xstormy16a module.
|
|
Called by gdb at start-up. */
|
|
|
|
void
|
|
_initialize_xstormy16_tdep (void)
|
|
{
|
|
extern int print_insn_xstormy16 ();
|
|
|
|
register_gdbarch_init (bfd_arch_xstormy16, xstormy16_gdbarch_init);
|
|
tm_print_insn = print_insn_xstormy16;
|
|
}
|