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

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

   Copyright (C) 2005-2017 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"

#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);

  /* Core files and signal handler frame unwinding are supported for
     32-bit SH only, at present.  */
  if (info.bfd_arch_info->mach != bfd_mach_sh5)
    {
      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);
    }
}

/* Provide a prototype to silence -Wmissing-prototypes.  */
extern void _initialize_sh_linux_tdep (void);

void
_initialize_sh_linux_tdep (void)
{
  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
61baf725	3	Copyright (C) 2005-2017 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"
c9ac0a72 AS	32
	33	#define REGSx16(base) \
	34	{(base), 0}, \
	35	{(base) + 1, 4}, \
	36	{(base) + 2, 8}, \
	37	{(base) + 3, 12}, \
	38	{(base) + 4, 16}, \
	39	{(base) + 5, 20}, \
	40	{(base) + 6, 24}, \
	41	{(base) + 7, 28}, \
	42	{(base) + 8, 32}, \
	43	{(base) + 9, 36}, \
	44	{(base) + 10, 40}, \
	45	{(base) + 11, 44}, \
	46	{(base) + 12, 48}, \
	47	{(base) + 13, 52}, \
	48	{(base) + 14, 56}, \
	49	{(base) + 15, 60}
	50
	51	/* Describe the contents of the .reg section of the core file. */
	52
	53	static const struct sh_corefile_regmap gregs_table[] =
	54	{
	55	REGSx16 (R0_REGNUM),
	56	{PC_REGNUM, 64},
	57	{PR_REGNUM, 68},
	58	{SR_REGNUM, 72},
	59	{GBR_REGNUM, 76},
	60	{MACH_REGNUM, 80},
	61	{MACL_REGNUM, 84},
	62	{-1 /* Terminator. */, 0}
	63	};
	64
	65	/* Describe the contents of the .reg2 section of the core file. */
	66
	67	static const struct sh_corefile_regmap fpregs_table[] =
	68	{
	69	REGSx16 (FR0_REGNUM),
	70	/* REGSx16 xfp_regs omitted. */
	71	{FPSCR_REGNUM, 128},
	72	{FPUL_REGNUM, 132},
	73	{-1 /* Terminator. */, 0}
	74	};
e25c958c	75
1e1f6591 CLT	76	/* SH signal handler frame support. */
	77
	78	static void
	79	sh_linux_sigtramp_cache (struct frame_info *this_frame,
	80	struct trad_frame_cache *this_cache,
	81	CORE_ADDR func, int regs_offset)
	82	{
	83	int i;
	84	struct gdbarch *gdbarch = get_frame_arch (this_frame);
	85	CORE_ADDR base = get_frame_register_unsigned (this_frame,
	86	gdbarch_sp_regnum (gdbarch));
	87	CORE_ADDR regs = base + regs_offset;
	88
	89	for (i = 0; i < 18; i++)
	90	trad_frame_set_reg_addr (this_cache, i, regs + i * 4);
	91
	92	trad_frame_set_reg_addr (this_cache, SR_REGNUM, regs + 18 * 4);
	93	trad_frame_set_reg_addr (this_cache, GBR_REGNUM, regs + 19 * 4);
	94	trad_frame_set_reg_addr (this_cache, MACH_REGNUM, regs + 20 * 4);
	95	trad_frame_set_reg_addr (this_cache, MACL_REGNUM, regs + 21 * 4);
	96
	97	/* Restore FP state if we have an FPU. */
	98	if (gdbarch_fp0_regnum (gdbarch) != -1)
	99	{
	100	CORE_ADDR fpregs = regs + 22 * 4;
	101	for (i = FR0_REGNUM; i <= FP_LAST_REGNUM; i++)
	102	trad_frame_set_reg_addr (this_cache, i, fpregs + i * 4);
	103	trad_frame_set_reg_addr (this_cache, FPSCR_REGNUM, fpregs + 32 * 4);
	104	trad_frame_set_reg_addr (this_cache, FPUL_REGNUM, fpregs + 33 * 4);
	105	}
	106
	107	/* Save a frame ID. */
	108	trad_frame_set_id (this_cache, frame_id_build (base, func));
	109	}
	110
	111	/* Implement struct tramp_frame "init" callbacks for signal
	112	trampolines on 32-bit SH. */
	113
	114	static void
	115	sh_linux_sigreturn_init (const struct tramp_frame *self,
	116	struct frame_info *this_frame,
	117	struct trad_frame_cache *this_cache,
	118	CORE_ADDR func)
	119	{
	120	/* SH 32-bit sigframe: sigcontext at start of sigframe,
	121	registers start after a single 'oldmask' word. */
	122	sh_linux_sigtramp_cache (this_frame, this_cache, func, 4);
	123	}
	124
	125	static void
	126	sh_linux_rt_sigreturn_init (const struct tramp_frame *self,
	127	struct frame_info *this_frame,
	128	struct trad_frame_cache *this_cache,
	129	CORE_ADDR func)
	130	{
	131	/* SH 32-bit rt_sigframe: starts with a siginfo (128 bytes), then
	132	we can find sigcontext embedded within a ucontext (offset 20 bytes).
	133	Then registers start after a single 'oldmask' word. */
	134	sh_linux_sigtramp_cache (this_frame, this_cache, func,
	135	128 /* sizeof (struct siginfo) */
	136	+ 20 /* offsetof (struct ucontext, uc_mcontext) */
	137	+ 4 /* oldmask word at start of sigcontext */);
	138	}
	139
140	/* Instruction patterns. */
141	#define SH_MOVW 0x9305
142	#define SH_TRAP 0xc300
143	#define SH_OR_R0_R0 0x200b
144
145	/* SH sigreturn syscall numbers. */
146	#define SH_NR_SIGRETURN 0x0077
147	#define SH_NR_RT_SIGRETURN 0x00ad
148
149	static struct tramp_frame sh_linux_sigreturn_tramp_frame = {
150	SIGTRAMP_FRAME,
151	2,
152	{
153	{ SH_MOVW, 0xffff },
154	{ SH_TRAP, 0xff00 }, /* #imm argument part filtered out. */
155	{ SH_OR_R0_R0, 0xffff },
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_NR_SIGRETURN, 0xffff },
161	{ TRAMP_SENTINEL_INSN }
162	},
163	sh_linux_sigreturn_init
164	};
165
166	static struct tramp_frame sh_linux_rt_sigreturn_tramp_frame = {
167	SIGTRAMP_FRAME,
168	2,
169	{
170	{ SH_MOVW, 0xffff },
171	{ SH_TRAP, 0xff00 }, /* #imm argument part filtered out. */
172	{ SH_OR_R0_R0, 0xffff },
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_NR_RT_SIGRETURN, 0xffff },
178	{ TRAMP_SENTINEL_INSN }
179	},
180	sh_linux_rt_sigreturn_init
181	};
182
ccf00f21 MK	183	static void
	184	sh_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
	185	{
a5ee0f0c PA	186	linux_init_abi (info, gdbarch);
a5ee0f0c PA	187
ccf00f21	188	/* GNU/Linux uses SVR4-style shared libraries. */
982e9687	189	set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
ccf00f21 MK	190	set_solib_svr4_fetch_link_map_offsets
ccf00f21 MK	191	(gdbarch, svr4_ilp32_fetch_link_map_offsets);
e25c958c DJ	192	set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
	193
	194	set_gdbarch_fetch_tls_load_module_address (gdbarch,
	195	svr4_fetch_objfile_link_map);
c9ac0a72	196
1e1f6591 CLT	197	/* Core files and signal handler frame unwinding are supported for
1e1f6591 CLT	198	32-bit SH only, at present. */
c9ac0a72 AS	199	if (info.bfd_arch_info->mach != bfd_mach_sh5)
	200	{
	201	struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
	202
c6d41a6f AA	203	/* Remember regset characteristics. The sizes should match
c6d41a6f AA	204	elf_gregset_t and elf_fpregset_t from Linux. */
c9ac0a72	205	tdep->core_gregmap = (struct sh_corefile_regmap *)gregs_table;
c6d41a6f	206	tdep->sizeof_gregset = 92;
c9ac0a72	207	tdep->core_fpregmap = (struct sh_corefile_regmap *)fpregs_table;
c6d41a6f	208	tdep->sizeof_fpregset = 136;
1e1f6591 CLT	209
	210	tramp_frame_prepend_unwinder (gdbarch, &sh_linux_sigreturn_tramp_frame);
	211	tramp_frame_prepend_unwinder (gdbarch, &sh_linux_rt_sigreturn_tramp_frame);
c9ac0a72	212	}
ccf00f21 MK	213	}
	214
	215	/* Provide a prototype to silence -Wmissing-prototypes. */
	216	extern void _initialize_sh_linux_tdep (void);
	217
	218	void
	219	_initialize_sh_linux_tdep (void)
	220	{
	221	gdbarch_register_osabi (bfd_arch_sh, 0, GDB_OSABI_LINUX, sh_linux_init_abi);
	222	}