[deliverable/binutils-gdb.git] / gdb / sh-linux-tdep.c

/* Target-dependent code for GNU/Linux Super-H.

   Copyright (C) 2005-2020 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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "osabi.h"

#include "solib-svr4.h"
#include "symtab.h"

#include "trad-frame.h"
#include "tramp-frame.h"

#include "glibc-tdep.h"
#include "sh-tdep.h"
#include "linux-tdep.h"
#include "gdbarch.h"

#define REGSx16(base) \
  {(base),      0}, \
  {(base) +  1, 4}, \
  {(base) +  2, 8}, \
  {(base) +  3, 12}, \
  {(base) +  4, 16}, \
  {(base) +  5, 20}, \
  {(base) +  6, 24}, \
  {(base) +  7, 28}, \
  {(base) +  8, 32}, \
  {(base) +  9, 36}, \
  {(base) + 10, 40}, \
  {(base) + 11, 44}, \
  {(base) + 12, 48}, \
  {(base) + 13, 52}, \
  {(base) + 14, 56}, \
  {(base) + 15, 60}

/* Describe the contents of the .reg section of the core file.  */

static const struct sh_corefile_regmap gregs_table[] =
{
  REGSx16 (R0_REGNUM),
  {PC_REGNUM,   64},
  {PR_REGNUM,   68},
  {SR_REGNUM,   72},
  {GBR_REGNUM,  76},
  {MACH_REGNUM, 80},
  {MACL_REGNUM, 84},
  {-1 /* Terminator.  */, 0}
};

/* Describe the contents of the .reg2 section of the core file.  */

static const struct sh_corefile_regmap fpregs_table[] =
{
  REGSx16 (FR0_REGNUM),
  /* REGSx16 xfp_regs omitted.  */
  {FPSCR_REGNUM, 128},
  {FPUL_REGNUM,  132},
  {-1 /* Terminator.  */, 0}
};

/* SH signal handler frame support.  */

static void
sh_linux_sigtramp_cache (struct frame_info *this_frame,
			 struct trad_frame_cache *this_cache,
			 CORE_ADDR func, int regs_offset)
{
  int i;
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  CORE_ADDR base = get_frame_register_unsigned (this_frame,
						gdbarch_sp_regnum (gdbarch));
  CORE_ADDR regs = base + regs_offset;

  for (i = 0; i < 18; i++)
    trad_frame_set_reg_addr (this_cache, i, regs + i * 4);

  trad_frame_set_reg_addr (this_cache, SR_REGNUM, regs + 18 * 4);
  trad_frame_set_reg_addr (this_cache, GBR_REGNUM, regs + 19 * 4);
  trad_frame_set_reg_addr (this_cache, MACH_REGNUM, regs + 20 * 4);
  trad_frame_set_reg_addr (this_cache, MACL_REGNUM, regs + 21 * 4);

  /* Restore FP state if we have an FPU.  */
  if (gdbarch_fp0_regnum (gdbarch) != -1)
    {
      CORE_ADDR fpregs = regs + 22 * 4;
      for (i = FR0_REGNUM; i <= FP_LAST_REGNUM; i++)
	trad_frame_set_reg_addr (this_cache, i, fpregs + i * 4);
      trad_frame_set_reg_addr (this_cache, FPSCR_REGNUM, fpregs + 32 * 4);
      trad_frame_set_reg_addr (this_cache, FPUL_REGNUM, fpregs + 33 * 4);
    }

  /* Save a frame ID.  */
  trad_frame_set_id (this_cache, frame_id_build (base, func));
}

/* Implement struct tramp_frame "init" callbacks for signal
   trampolines on 32-bit SH.  */

static void
sh_linux_sigreturn_init (const struct tramp_frame *self,
			 struct frame_info *this_frame,
			 struct trad_frame_cache *this_cache,
			 CORE_ADDR func)
{
  /* SH 32-bit sigframe: sigcontext at start of sigframe,
     registers start after a single 'oldmask' word.  */
  sh_linux_sigtramp_cache (this_frame, this_cache, func, 4);
}

static void
sh_linux_rt_sigreturn_init (const struct tramp_frame *self,
			    struct frame_info *this_frame,
			    struct trad_frame_cache *this_cache,
			    CORE_ADDR func)
{
  /* SH 32-bit rt_sigframe: starts with a siginfo (128 bytes), then
     we can find sigcontext embedded within a ucontext (offset 20 bytes).
     Then registers start after a single 'oldmask' word.  */
  sh_linux_sigtramp_cache (this_frame, this_cache, func,
			   128 /* sizeof (struct siginfo)  */
			   + 20 /* offsetof (struct ucontext, uc_mcontext) */
			   + 4 /* oldmask word at start of sigcontext */);
}

/* Instruction patterns.  */
#define SH_MOVW     0x9305
#define SH_TRAP     0xc300
#define SH_OR_R0_R0 0x200b       

/* SH sigreturn syscall numbers.  */
#define SH_NR_SIGRETURN 0x0077
#define SH_NR_RT_SIGRETURN 0x00ad

static struct tramp_frame sh_linux_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  2,
  {
    { SH_MOVW, 0xffff },
    { SH_TRAP, 0xff00 }, /* #imm argument part filtered out.  */
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_NR_SIGRETURN, 0xffff },
    { TRAMP_SENTINEL_INSN }
  },
  sh_linux_sigreturn_init
};

static struct tramp_frame sh_linux_rt_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  2,
  {
    { SH_MOVW, 0xffff },
    { SH_TRAP, 0xff00 }, /* #imm argument part filtered out.  */
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_OR_R0_R0, 0xffff },
    { SH_NR_RT_SIGRETURN, 0xffff },
    { TRAMP_SENTINEL_INSN }
  },
  sh_linux_rt_sigreturn_init
};

static void
sh_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  linux_init_abi (info, gdbarch);

  /* GNU/Linux uses SVR4-style shared libraries.  */
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
  set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);

  set_gdbarch_fetch_tls_load_module_address (gdbarch,
                                             svr4_fetch_objfile_link_map);

  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  /* Remember regset characteristics.  The sizes should match
     elf_gregset_t and elf_fpregset_t from Linux.  */
  tdep->core_gregmap = (struct sh_corefile_regmap *) gregs_table;
  tdep->sizeof_gregset = 92;
  tdep->core_fpregmap = (struct sh_corefile_regmap *) fpregs_table;
  tdep->sizeof_fpregset = 136;

  tramp_frame_prepend_unwinder (gdbarch, &sh_linux_sigreturn_tramp_frame);
  tramp_frame_prepend_unwinder (gdbarch, &sh_linux_rt_sigreturn_tramp_frame);
}

void _initialize_sh_linux_tdep ();
void
_initialize_sh_linux_tdep ()
{
  gdbarch_register_osabi (bfd_arch_sh, 0, GDB_OSABI_LINUX, sh_linux_init_abi);
}
Commit	Line	Data
ccf00f21 MK	1	/* Target-dependent code for GNU/Linux Super-H.
ccf00f21 MK	2
b811d2c2	3	Copyright (C) 2005-2020 Free Software Foundation, Inc.
ccf00f21 MK	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
ccf00f21 MK	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
ccf00f21 MK	19
	20	#include "defs.h"
	21	#include "osabi.h"
	22
	23	#include "solib-svr4.h"
982e9687	24	#include "symtab.h"
ccf00f21	25
1e1f6591 CLT	26	#include "trad-frame.h"
	27	#include "tramp-frame.h"
	28
e25c958c	29	#include "glibc-tdep.h"
c9ac0a72	30	#include "sh-tdep.h"
a5ee0f0c	31	#include "linux-tdep.h"
0d12e84c	32	#include "gdbarch.h"
c9ac0a72 AS	33
	34	#define REGSx16(base) \
	35	{(base), 0}, \
	36	{(base) + 1, 4}, \
	37	{(base) + 2, 8}, \
	38	{(base) + 3, 12}, \
	39	{(base) + 4, 16}, \
	40	{(base) + 5, 20}, \
	41	{(base) + 6, 24}, \
	42	{(base) + 7, 28}, \
	43	{(base) + 8, 32}, \
	44	{(base) + 9, 36}, \
	45	{(base) + 10, 40}, \
	46	{(base) + 11, 44}, \
	47	{(base) + 12, 48}, \
	48	{(base) + 13, 52}, \
	49	{(base) + 14, 56}, \
	50	{(base) + 15, 60}
	51
	52	/* Describe the contents of the .reg section of the core file. */
	53
	54	static const struct sh_corefile_regmap gregs_table[] =
	55	{
	56	REGSx16 (R0_REGNUM),
	57	{PC_REGNUM, 64},
	58	{PR_REGNUM, 68},
	59	{SR_REGNUM, 72},
	60	{GBR_REGNUM, 76},
	61	{MACH_REGNUM, 80},
	62	{MACL_REGNUM, 84},
	63	{-1 /* Terminator. */, 0}
	64	};
	65
	66	/* Describe the contents of the .reg2 section of the core file. */
	67
	68	static const struct sh_corefile_regmap fpregs_table[] =
	69	{
	70	REGSx16 (FR0_REGNUM),
	71	/* REGSx16 xfp_regs omitted. */
	72	{FPSCR_REGNUM, 128},
	73	{FPUL_REGNUM, 132},
	74	{-1 /* Terminator. */, 0}
	75	};
e25c958c	76
1e1f6591 CLT	77	/* SH signal handler frame support. */
	78
	79	static void
	80	sh_linux_sigtramp_cache (struct frame_info *this_frame,
	81	struct trad_frame_cache *this_cache,
	82	CORE_ADDR func, int regs_offset)
	83	{
	84	int i;
	85	struct gdbarch *gdbarch = get_frame_arch (this_frame);
	86	CORE_ADDR base = get_frame_register_unsigned (this_frame,
	87	gdbarch_sp_regnum (gdbarch));
	88	CORE_ADDR regs = base + regs_offset;
	89
	90	for (i = 0; i < 18; i++)
	91	trad_frame_set_reg_addr (this_cache, i, regs + i * 4);
	92
	93	trad_frame_set_reg_addr (this_cache, SR_REGNUM, regs + 18 * 4);
	94	trad_frame_set_reg_addr (this_cache, GBR_REGNUM, regs + 19 * 4);
	95	trad_frame_set_reg_addr (this_cache, MACH_REGNUM, regs + 20 * 4);
	96	trad_frame_set_reg_addr (this_cache, MACL_REGNUM, regs + 21 * 4);
	97
	98	/* Restore FP state if we have an FPU. */
	99	if (gdbarch_fp0_regnum (gdbarch) != -1)
	100	{
	101	CORE_ADDR fpregs = regs + 22 * 4;
	102	for (i = FR0_REGNUM; i <= FP_LAST_REGNUM; i++)
	103	trad_frame_set_reg_addr (this_cache, i, fpregs + i * 4);
	104	trad_frame_set_reg_addr (this_cache, FPSCR_REGNUM, fpregs + 32 * 4);
	105	trad_frame_set_reg_addr (this_cache, FPUL_REGNUM, fpregs + 33 * 4);
	106	}
	107
	108	/* Save a frame ID. */
	109	trad_frame_set_id (this_cache, frame_id_build (base, func));
	110	}
	111
	112	/* Implement struct tramp_frame "init" callbacks for signal
	113	trampolines on 32-bit SH. */
	114
	115	static void
	116	sh_linux_sigreturn_init (const struct tramp_frame *self,
	117	struct frame_info *this_frame,
	118	struct trad_frame_cache *this_cache,
	119	CORE_ADDR func)
	120	{
	121	/* SH 32-bit sigframe: sigcontext at start of sigframe,
	122	registers start after a single 'oldmask' word. */
	123	sh_linux_sigtramp_cache (this_frame, this_cache, func, 4);
	124	}
	125
	126	static void
	127	sh_linux_rt_sigreturn_init (const struct tramp_frame *self,
	128	struct frame_info *this_frame,
	129	struct trad_frame_cache *this_cache,
	130	CORE_ADDR func)
	131	{
	132	/* SH 32-bit rt_sigframe: starts with a siginfo (128 bytes), then
	133	we can find sigcontext embedded within a ucontext (offset 20 bytes).
	134	Then registers start after a single 'oldmask' word. */
	135	sh_linux_sigtramp_cache (this_frame, this_cache, func,
	136	128 /* sizeof (struct siginfo) */
	137	+ 20 /* offsetof (struct ucontext, uc_mcontext) */
	138	+ 4 /* oldmask word at start of sigcontext */);
	139	}
	140
141	/* Instruction patterns. */
142	#define SH_MOVW 0x9305
143	#define SH_TRAP 0xc300
144	#define SH_OR_R0_R0 0x200b
145
146	/* SH sigreturn syscall numbers. */
147	#define SH_NR_SIGRETURN 0x0077
148	#define SH_NR_RT_SIGRETURN 0x00ad
149
150	static struct tramp_frame sh_linux_sigreturn_tramp_frame = {
151	SIGTRAMP_FRAME,
152	2,
153	{
154	{ SH_MOVW, 0xffff },
155	{ SH_TRAP, 0xff00 }, /* #imm argument part filtered out. */
156	{ SH_OR_R0_R0, 0xffff },
157	{ SH_OR_R0_R0, 0xffff },
158	{ SH_OR_R0_R0, 0xffff },
159	{ SH_OR_R0_R0, 0xffff },
160	{ SH_OR_R0_R0, 0xffff },
161	{ SH_NR_SIGRETURN, 0xffff },
162	{ TRAMP_SENTINEL_INSN }
163	},
164	sh_linux_sigreturn_init
165	};
166
167	static struct tramp_frame sh_linux_rt_sigreturn_tramp_frame = {
168	SIGTRAMP_FRAME,
169	2,
170	{
171	{ SH_MOVW, 0xffff },
172	{ SH_TRAP, 0xff00 }, /* #imm argument part filtered out. */
173	{ SH_OR_R0_R0, 0xffff },
174	{ SH_OR_R0_R0, 0xffff },
175	{ SH_OR_R0_R0, 0xffff },
176	{ SH_OR_R0_R0, 0xffff },
177	{ SH_OR_R0_R0, 0xffff },
178	{ SH_NR_RT_SIGRETURN, 0xffff },
179	{ TRAMP_SENTINEL_INSN }
180	},
181	sh_linux_rt_sigreturn_init
182	};
183
ccf00f21 MK	184	static void
	185	sh_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	186	{
a5ee0f0c PA	187	linux_init_abi (info, gdbarch);
a5ee0f0c PA	188
ccf00f21	189	/* GNU/Linux uses SVR4-style shared libraries. */
982e9687	190	set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
ccf00f21 MK	191	set_solib_svr4_fetch_link_map_offsets
ccf00f21 MK	192	(gdbarch, svr4_ilp32_fetch_link_map_offsets);
e25c958c DJ	193	set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
	194
	195	set_gdbarch_fetch_tls_load_module_address (gdbarch,
	196	svr4_fetch_objfile_link_map);
c9ac0a72	197
8a3de5e1	198	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
c9ac0a72	199
8a3de5e1 PA	200	/* Remember regset characteristics. The sizes should match
	201	elf_gregset_t and elf_fpregset_t from Linux. */
	202	tdep->core_gregmap = (struct sh_corefile_regmap *) gregs_table;
	203	tdep->sizeof_gregset = 92;
	204	tdep->core_fpregmap = (struct sh_corefile_regmap *) fpregs_table;
	205	tdep->sizeof_fpregset = 136;
1e1f6591	206
8a3de5e1 PA	207	tramp_frame_prepend_unwinder (gdbarch, &sh_linux_sigreturn_tramp_frame);
8a3de5e1 PA	208	tramp_frame_prepend_unwinder (gdbarch, &sh_linux_rt_sigreturn_tramp_frame);
ccf00f21 MK	209	}
ccf00f21 MK	210
6c265988	211	void _initialize_sh_linux_tdep ();
ccf00f21	212	void
6c265988	213	_initialize_sh_linux_tdep ()
ccf00f21 MK	214	{
	215	gdbarch_register_osabi (bfd_arch_sh, 0, GDB_OSABI_LINUX, sh_linux_init_abi);
	216	}