gdb/gdbserver/linux-sh-low.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* GNU/Linux/SH specific low level interface, for the remote server for GDB.
  2.    Copyright (C) 1995-2015 Free Software Foundation, Inc.

  4.    This file is part of GDB.

  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 3 of the License, or
  9.    (at your option) any later version.

  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.

  16.    You should have received a copy of the GNU General Public License
  17.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  19. #include "server.h"
  20. #include "linux-low.h"

  22. /* Defined in auto-generated file reg-sh.c.  */
  23. void init_registers_sh (void);
  24. extern const struct target_desc *tdesc_sh;

  26. #ifdef HAVE_SYS_REG_H
  27. #include <sys/reg.h>
  28. #endif

  30. #include <asm/ptrace.h>

  32. ‌#define sh_num_regs 41

  34. /* Currently, don't check/send MQ.  */
  35. ‌static int sh_regmap[] = {
  36. 0,        4,        8,        12,        16,        20,        24,        28,
  37. 32,        36,        40,        44,        48,        52,        56,        60,

  39. REG_PC*4,   REG_PR*4,   REG_GBR*4,  -1,
  40. REG_MACH*4, REG_MACL*4, REG_SR*4,
  41. REG_FPUL*4, REG_FPSCR*4,

  43. REG_FPREG0*4+0,   REG_FPREG0*4+4,   REG_FPREG0*4+8,   REG_FPREG0*4+12,
  44. REG_FPREG0*4+16,  REG_FPREG0*4+20,  REG_FPREG0*4+24,  REG_FPREG0*4+28,
  45. REG_FPREG0*4+32,  REG_FPREG0*4+36,  REG_FPREG0*4+40,  REG_FPREG0*4+44,
  46. REG_FPREG0*4+48,  REG_FPREG0*4+52,  REG_FPREG0*4+56,  REG_FPREG0*4+60,
  47. };

  49. static int
  50. ‌sh_cannot_store_register (int regno)
  51. {
  52.   return 0;
  53. }

  55. static int
  56. ‌sh_cannot_fetch_register (int regno)
  57. {
  58.   return 0;
  59. }

  61. static CORE_ADDR
  62. ‌sh_get_pc (struct regcache *regcache)
  63. {
  64.   unsigned long pc;
  65.   collect_register_by_name (regcache, "pc", &pc);
  66.   return pc;
  67. }

  69. static void
  70. ‌sh_set_pc (struct regcache *regcache, CORE_ADDR pc)
  71. {
  72.   unsigned long newpc = pc;
  73.   supply_register_by_name (regcache, "pc", &newpc);
  74. }

  76. /* Correct in either endianness, obviously.  */
  77. ‌static const unsigned short sh_breakpoint = 0xc3c3;
  78. ‌#define sh_breakpoint_len 2

  80. static int
  81. ‌sh_breakpoint_at (CORE_ADDR where)
  82. {
  83.   unsigned short insn;

  85.   (*the_target->read_memory) (where, (unsigned char *) &insn, 2);
  86.   if (insn == sh_breakpoint)
  87.     return 1;

  89.   /* If necessary, recognize more trap instructions here.  GDB only uses the
  90.      one.  */
  91.   return 0;
  92. }

  94. /* Provide only a fill function for the general register set.  ps_lgetregs
  95.    will use this for NPTL support.  */

  97. ‌static void sh_fill_gregset (struct regcache *regcache, void *buf)
  98. {
  99.   int i;

  101.   for (i = 0; i < 23; i++)
  102.     if (sh_regmap[i] != -1)
  103.       collect_register (regcache, i, (char *) buf + sh_regmap[i]);
  104. }

  106. ‌static struct regset_info sh_regsets[] = {
  107.   { 0, 0, 0, 0, GENERAL_REGS, sh_fill_gregset, NULL },
  108.   { 0, 0, 0, -1, -1, NULL, NULL }
  109. };

  111. ‌static struct regsets_info sh_regsets_info =
  112.   {
  113.     sh_regsets, /* regsets */
  114.     0, /* num_regsets */
  115.     NULL, /* disabled_regsets */
  116.   };

  118. ‌static struct usrregs_info sh_usrregs_info =
  119.   {
  120.     sh_num_regs,
  121.     sh_regmap,
  122.   };

  124. ‌static struct regs_info regs_info =
  125.   {
  126.     NULL, /* regset_bitmap */
  127.     &sh_usrregs_info,
  128.     &sh_regsets_info
  129.   };

  131. static const struct regs_info *
  132. ‌sh_regs_info (void)
  133. {
  134.   return &regs_info;
  135. }

  137. static void
  138. ‌sh_arch_setup (void)
  139. {
  140.   current_process ()->tdesc = tdesc_sh;
  141. }

  143. ‌struct linux_target_ops the_low_target = {
  144.   sh_arch_setup,
  145.   sh_regs_info,
  146.   sh_cannot_fetch_register,
  147.   sh_cannot_store_register,
  148.   NULL, /* fetch_register */
  149.   sh_get_pc,
  150.   sh_set_pc,
  151.   (const unsigned char *) &sh_breakpoint,
  152.   sh_breakpoint_len,
  153.   NULL,
  154.   0,
  155.   sh_breakpoint_at,
  156. };

  158. void
  159. ‌initialize_low_arch (void)
  160. {
  161.   init_registers_sh ();

  163.   initialize_regsets_info (&sh_regsets_info);
  164. }