#include "defs.h"
#include "gdbcore.h"
#include "doublest.h"
#include "floatformat.h"
#include "frame.h"
#include "target.h"
#include "gdb_string.h"
#include "gdbtypes.h"
#include "osabi.h"
#include "regcache.h"
#include "objfiles.h"
#include "symtab.h"
#include "m68k-tdep.h"
#define M68K_LINUX_JB_ELEMENT_SIZE 4
#define M68K_LINUX_JB_PC 7
#define IS_SIGTRAMP(insn1, insn2) \
( \
(insn1 == 0xdefc0014 && insn2 == 0x70774e40) \
\
|| insn1 == 0x70774e40)
#define IS_RT_SIGTRAMP(insn1, insn2) \
( \
(insn1 == 0x203c0000 && insn2 == 0x00ad4e40) \
\
|| (insn1 == 0x70524600 && (insn2 >> 16) == 0x4e40))
static int
m68k_linux_pc_in_sigtramp (CORE_ADDR pc, char *name)
{
CORE_ADDR sp;
char buf[12];
unsigned long insn0, insn1, insn2;
if (read_memory_nobpt (pc - 4, buf, sizeof (buf)))
return 0;
insn1 = extract_unsigned_integer (buf + 4, 4);
insn2 = extract_unsigned_integer (buf + 8, 4);
if (IS_SIGTRAMP (insn1, insn2))
return 1;
if (IS_RT_SIGTRAMP (insn1, insn2))
return 2;
insn0 = extract_unsigned_integer (buf, 4);
if (IS_SIGTRAMP (insn0, insn1))
return 1;
if (IS_RT_SIGTRAMP (insn0, insn1))
return 2;
insn0 = ((insn0 << 16) & 0xffffffff) | (insn1 >> 16);
insn1 = ((insn1 << 16) & 0xffffffff) | (insn2 >> 16);
if (IS_SIGTRAMP (insn0, insn1))
return 1;
if (IS_RT_SIGTRAMP (insn0, insn1))
return 2;
return 0;
}
static int m68k_linux_sigcontext_reg_offset[M68K_NUM_REGS] =
{
2 * 4,
3 * 4,
-1,
-1,
-1,
-1,
-1,
-1,
4 * 4,
5 * 4,
-1,
-1,
-1,
-1,
-1,
1 * 4,
5 * 4 + 2,
6 * 4 + 2,
8 * 4,
11 * 4,
-1,
-1,
-1,
-1,
-1,
-1,
14 * 4,
15 * 4,
16 * 4
};
static int m68k_linux_ucontext_reg_offset[M68K_NUM_REGS] =
{
6 * 4,
7 * 4,
8 * 4,
9 * 4,
10 * 4,
11 * 4,
12 * 4,
13 * 4,
14 * 4,
15 * 4,
16 * 4,
17 * 4,
18 * 4,
19 * 4,
20 * 4,
21 * 4,
23 * 4,
22 * 4,
27 * 4,
30 * 4,
33 * 4,
36 * 4,
39 * 4,
42 * 4,
45 * 4,
48 * 4,
24 * 4,
25 * 4,
26 * 4
};
static struct m68k_sigtramp_info
m68k_linux_get_sigtramp_info (struct frame_info *next_frame)
{
CORE_ADDR sp;
char buf[4];
struct m68k_sigtramp_info info;
frame_unwind_register (next_frame, M68K_SP_REGNUM, buf);
sp = extract_unsigned_integer (buf, 4);
info.sigcontext_addr = read_memory_unsigned_integer (sp + 8, 4);
if (m68k_linux_pc_in_sigtramp (frame_pc_unwind (next_frame), 0) == 2)
info.sc_reg_offset = m68k_linux_ucontext_reg_offset;
else
info.sc_reg_offset = m68k_linux_sigcontext_reg_offset;
return info;
}
static void
m68k_linux_extract_return_value (struct type *type, struct regcache *regcache,
void *valbuf)
{
int len = TYPE_LENGTH (type);
char buf[M68K_MAX_REGISTER_SIZE];
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type) == 1)
{
m68k_linux_extract_return_value (TYPE_FIELD_TYPE (type, 0), regcache,
valbuf);
return;
}
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
regcache_raw_read (regcache, M68K_FP0_REGNUM, buf);
convert_typed_floating (buf, builtin_type_m68881_ext, valbuf, type);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR)
regcache_raw_read (regcache, M68K_A0_REGNUM, valbuf);
else
{
if (len <= 4)
{
regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
memcpy (valbuf, buf + (4 - len), len);
}
else if (len <= 8)
{
regcache_raw_read (regcache, M68K_D0_REGNUM, buf);
memcpy (valbuf, buf + (8 - len), len - 4);
regcache_raw_read (regcache, M68K_D1_REGNUM,
(char *) valbuf + (len - 4));
}
else
internal_error (__FILE__, __LINE__,
"Cannot extract return value of %d bytes long.", len);
}
}
static void
m68k_linux_store_return_value (struct type *type, struct regcache *regcache,
const void *valbuf)
{
int len = TYPE_LENGTH (type);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
&& TYPE_NFIELDS (type) == 1)
{
m68k_linux_store_return_value (TYPE_FIELD_TYPE (type, 0), regcache,
valbuf);
return;
}
if (TYPE_CODE (type) == TYPE_CODE_FLT)
{
char buf[M68K_MAX_REGISTER_SIZE];
convert_typed_floating (valbuf, type, buf, builtin_type_m68881_ext);
regcache_raw_write (regcache, M68K_FP0_REGNUM, buf);
}
else if (TYPE_CODE (type) == TYPE_CODE_PTR)
regcache_raw_write (regcache, M68K_A0_REGNUM, valbuf);
else
{
if (len <= 4)
regcache_raw_write_part (regcache, M68K_D0_REGNUM,
4 - len, len, valbuf);
else if (len <= 8)
{
regcache_raw_write_part (regcache, M68K_D1_REGNUM, 8 - len,
len - 4, valbuf);
regcache_raw_write (regcache, M68K_D0_REGNUM,
(char *) valbuf + (len - 4));
}
else
internal_error (__FILE__, __LINE__,
"Cannot store return value of %d bytes long.", len);
}
}
static CORE_ADDR
m68k_linux_extract_struct_value_address (struct regcache *regcache)
{
char buf[4];
regcache_cooked_read (regcache, M68K_A0_REGNUM, buf);
return extract_unsigned_integer (buf, 4);
}
static void
m68k_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
tdep->jb_pc = M68K_LINUX_JB_PC;
tdep->jb_elt_size = M68K_LINUX_JB_ELEMENT_SIZE;
tdep->get_sigtramp_info = m68k_linux_get_sigtramp_info;
tdep->struct_return = reg_struct_return;
set_gdbarch_extract_return_value (gdbarch, m68k_linux_extract_return_value);
set_gdbarch_store_return_value (gdbarch, m68k_linux_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68k_linux_extract_struct_value_address);
set_gdbarch_pc_in_sigtramp (gdbarch, m68k_linux_pc_in_sigtramp);
set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
}
void
_initialize_m68k_linux_tdep (void)
{
gdbarch_register_osabi (bfd_arch_m68k, 0, GDB_OSABI_LINUX,
m68k_linux_init_abi);
}