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

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* GNU/Linux/Xtensa specific low level interface, for the remote server for GDB.
  2.    Copyright (C) 2007-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/>.  */


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

  23. /* Defined in auto-generated file reg-xtensa.c.  */
  24. void init_registers_xtensa (void);
  25. extern const struct target_desc *tdesc_xtensa;

  27. #include <asm/ptrace.h>
  28. #include <xtensa-config.h>

  30. #include "xtensa-xtregs.c"

  32. ‌enum regnum {
  33.         R_PC=0,        R_PS,
  34.         R_LBEG,        R_LEND,        R_LCOUNT,
  35.         R_SAR,
  36.         R_WS, R_WB,
  37.         R_A0 = 64
  38. };

  40. static void
  41. ‌xtensa_fill_gregset (struct regcache *regcache, void *buf)
  42. {
  43.   elf_greg_t* rset = (elf_greg_t*)buf;
  44.   const struct target_desc *tdesc = regcache->tdesc;
  45.   int ar0_regnum;
  46.   char *ptr;
  47.   int i;

  49.   /* Take care of AR registers.  */

  51.   ar0_regnum = find_regno (tdesc, "ar0");
  52.   ptr = (char*)&rset[R_A0];

  54.   for (i = ar0_regnum; i < ar0_regnum + XCHAL_NUM_AREGS; i++)
  55.     {
  56.       collect_register (regcache, i, ptr);
  57.       ptr += register_size (tdesc, i);
  58.     }

  60.   /* Loop registers, if hardware has it.  */

  62. #if XCHAL_HAVE_LOOP
  63.   collect_register_by_name (regcache, "lbeg", (char*)&rset[R_LBEG]);
  64.   collect_register_by_name (regcache, "lend", (char*)&rset[R_LEND]);
  65.   collect_register_by_name (regcache, "lcount", (char*)&rset[R_LCOUNT]);
  66. #endif

  68.   collect_register_by_name (regcache, "sar", (char*)&rset[R_SAR]);
  69.   collect_register_by_name (regcache, "pc", (char*)&rset[R_PC]);
  70.   collect_register_by_name (regcache, "ps", (char*)&rset[R_PS]);
  71.   collect_register_by_name (regcache, "windowbase", (char*)&rset[R_WB]);
  72.   collect_register_by_name (regcache, "windowstart", (char*)&rset[R_WS]);
  73. }

  75. static void
  76. ‌xtensa_store_gregset (struct regcache *regcache, const void *buf)
  77. {
  78.   const elf_greg_t* rset = (const elf_greg_t*)buf;
  79.   const struct target_desc *tdesc = regcache->tdesc;
  80.   int ar0_regnum;
  81.   char *ptr;
  82.   int i;

  84.   /* Take care of AR registers.  */

  86.   ar0_regnum = find_regno (tdesc, "ar0");
  87.   ptr = (char *)&rset[R_A0];

  89.   for (i = ar0_regnum; i < ar0_regnum + XCHAL_NUM_AREGS; i++)
  90.     {
  91.       supply_register (regcache, i, ptr);
  92.       ptr += register_size (tdesc, i);
  93.     }

  95.   /* Loop registers, if hardware has it.  */

  97. #if XCHAL_HAVE_LOOP
  98.   supply_register_by_name (regcache, "lbeg", (char*)&rset[R_LBEG]);
  99.   supply_register_by_name (regcache, "lend", (char*)&rset[R_LEND]);
  100.   supply_register_by_name (regcache, "lcount", (char*)&rset[R_LCOUNT]);
  101. #endif

  103.   supply_register_by_name (regcache, "sar", (char*)&rset[R_SAR]);
  104.   supply_register_by_name (regcache, "pc", (char*)&rset[R_PC]);
  105.   supply_register_by_name (regcache, "ps", (char*)&rset[R_PS]);
  106.   supply_register_by_name (regcache, "windowbase", (char*)&rset[R_WB]);
  107.   supply_register_by_name (regcache, "windowstart", (char*)&rset[R_WS]);
  108. }

  110. /* Xtensa GNU/Linux PTRACE interface includes extended register set.  */

  112. static void
  113. ‌xtensa_fill_xtregset (struct regcache *regcache, void *buf)
  114. {
  115.   const xtensa_regtable_t *ptr;

  117.   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
  118.     {
  119.       collect_register_by_name (regcache, ptr->name,
  120.                                 (char*)buf + ptr->ptrace_offset);
  121.     }
  122. }

  124. static void
  125. ‌xtensa_store_xtregset (struct regcache *regcache, const void *buf)
  126. {
  127.   const xtensa_regtable_t *ptr;

  129.   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
  130.     {
  131.       supply_register_by_name (regcache, ptr->name,
  132.                                 (char*)buf + ptr->ptrace_offset);
  133.     }
  134. }

  136. ‌static struct regset_info xtensa_regsets[] = {
  137.   { PTRACE_GETREGS, PTRACE_SETREGS, 0, sizeof (elf_gregset_t),
  138.     GENERAL_REGS,
  139.     xtensa_fill_gregset, xtensa_store_gregset },
  140.   { PTRACE_GETXTREGS, PTRACE_SETXTREGS, 0, XTENSA_ELF_XTREG_SIZE,
  141.     EXTENDED_REGS,
  142.     xtensa_fill_xtregset, xtensa_store_xtregset },
  143.   { 0, 0, 0, -1, -1, NULL, NULL }
  144. };

  146. #if XCHAL_HAVE_BE
  147. ‌#define XTENSA_BREAKPOINT {0xd2,0x0f}
  148. #else
  149. ‌#define XTENSA_BREAKPOINT {0x2d,0xf0}
  150. #endif

  152. ‌static const unsigned char xtensa_breakpoint[] = XTENSA_BREAKPOINT;
  153. ‌#define xtensa_breakpoint_len 2

  155. static CORE_ADDR
  156. ‌xtensa_get_pc (struct regcache *regcache)
  157. {
  158.   unsigned long pc;

  160.   collect_register_by_name (regcache, "pc", &pc);
  161.   return pc;
  162. }

  164. static void
  165. ‌xtensa_set_pc (struct regcache *regcache, CORE_ADDR pc)
  166. {
  167.   unsigned long newpc = pc;
  168.   supply_register_by_name (regcache, "pc", &newpc);
  169. }

  171. static int
  172. ‌xtensa_breakpoint_at (CORE_ADDR where)
  173. {
  174.     unsigned long insn;

  176.     (*the_target->read_memory) (where, (unsigned char *) &insn,
  177.                                 xtensa_breakpoint_len);
  178.     return memcmp((char *) &insn,
  179.                   xtensa_breakpoint, xtensa_breakpoint_len) == 0;
  180. }

  182. ‌static struct regsets_info xtensa_regsets_info =
  183.   {
  184.     xtensa_regsets, /* regsets */
  185.     0, /* num_regsets */
  186.     NULL, /* disabled_regsets */
  187.   };

  189. ‌static struct usrregs_info xtensa_usrregs_info =
  190.   {
  191.     xtensa_num_regs,
  192.     xtensa_regmap,
  193.   };

  195. ‌static struct regs_info regs_info =
  196.   {
  197.     NULL, /* regset_bitmap */
  198.     &xtensa_usrregs_info,
  199.     &xtensa_regsets_info
  200.   };

  202. static void
  203. ‌xtensa_arch_setup (void)
  204. {
  205.   current_process ()->tdesc = tdesc_xtensa;
  206. }

  208. static const struct regs_info *
  209. ‌xtensa_regs_info (void)
  210. {
  211.   return &regs_info;
  212. }

  214. ‌struct linux_target_ops the_low_target = {
  215.   xtensa_arch_setup,
  216.   xtensa_regs_info,
  217.   0,
  218.   0,
  219.   NULL, /* fetch_register */
  220.   xtensa_get_pc,
  221.   xtensa_set_pc,
  222.   xtensa_breakpoint,
  223.   xtensa_breakpoint_len,
  224.   NULL,
  225.   0,
  226.   xtensa_breakpoint_at,
  227. };


  230. void
  231. ‌initialize_low_arch (void)
  232. {
  233.   /* Initialize the Linux target descriptions.  */
  234.   init_registers_xtensa ();

  236.   initialize_regsets_info (&xtensa_regsets_info);
  237. }