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

Global variables defined

Functions defined

Macros defined

Source code

  1. /* GNU/Linux/CRIS 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"
  21. #include <sys/ptrace.h>

  23. /* Defined in auto-generated file reg-cris.c.  */
  24. void init_registers_cris (void);
  25. extern const struct target_desc *tdesc_cris;

  27. /* CRISv10 */
  28. ‌#define cris_num_regs 32

  30. /* Locations need to match <include/asm/arch/ptrace.h>.  */
  31. ‌static int cris_regmap[] = {
  32.   15*4, 14*4, 13*4, 12*4,
  33.   11*4, 10*4, 9*4, 8*4,
  34.   7*4, 6*4, 5*4, 4*4,
  35.   3*4, 2*4, 23*4, 19*4,

  37.   -1, -1, -1, -1,
  38.   -1, 17*4, -1, 16*4,
  39.   -1, -1, -1, 18*4,
  40.   -1, 17*4, -1, -1

  42. };

  44. static int
  45. ‌cris_cannot_store_register (int regno)
  46. {
  47.   if (cris_regmap[regno] == -1)
  48.     return 1;

  50.   return (regno >= cris_num_regs);
  51. }

  53. static int
  54. ‌cris_cannot_fetch_register (int regno)
  55. {
  56.   if (cris_regmap[regno] == -1)
  57.     return 1;

  59.   return (regno >= cris_num_regs);
  60. }

  62. extern int debug_threads;

  64. static CORE_ADDR
  65. ‌cris_get_pc (struct regcache *regcache, void)
  66. {
  67.   unsigned long pc;
  68.   collect_register_by_name (regcache, "pc", &pc);
  69.   if (debug_threads)
  70.     debug_printf ("stop pc is %08lx\n", pc);
  71.   return pc;
  72. }

  74. static void
  75. ‌cris_set_pc (struct regcache *regcache, CORE_ADDR pc)
  76. {
  77.   unsigned long newpc = pc;
  78.   supply_register_by_name (regcache, "pc", &newpc);
  79. }

  81. ‌static const unsigned short cris_breakpoint = 0xe938;
  82. ‌#define cris_breakpoint_len 2

  84. static int
  85. ‌cris_breakpoint_at (CORE_ADDR where)
  86. {
  87.   unsigned short insn;

  89.   (*the_target->read_memory) (where, (unsigned char *) &insn,
  90.                               cris_breakpoint_len);
  91.   if (insn == cris_breakpoint)
  92.     return 1;

  94.   /* If necessary, recognize more trap instructions here.  GDB only uses the
  95.      one.  */
  96.   return 0;
  97. }

  99. /* We only place breakpoints in empty marker functions, and thread locking
  100.    is outside of the function.  So rather than importing software single-step,
  101.    we can just run until exit.  */
  102. static CORE_ADDR
  103. ‌cris_reinsert_addr (void)
  104. {
  105.   struct regcache *regcache = get_thread_regcache (current_thread, 1);
  106.   unsigned long pc;
  107.   collect_register_by_name (regcache, "srp", &pc);
  108.   return pc;
  109. }

  111. static void
  112. ‌cris_arch_setup (void)
  113. {
  114.   current_process ()->tdesc = tdesc_cris;
  115. }

  117. ‌static struct usrregs_info cris_usrregs_info =
  118.   {
  119.     cris_num_regs,
  120.     cris_regmap,
  121.   };

  123. ‌static struct regs_info regs_info =
  124.   {
  125.     NULL, /* regset_bitmap */
  126.     &cris_usrregs_info,
  127.   };

  129. static const struct regs_info *
  130. ‌cris_regs_info (void)
  131. {
  132.   return &regs_info;
  133. }

  135. ‌struct linux_target_ops the_low_target = {
  136.   cris_arch_setup,
  137.   cris_regs_info,
  138.   cris_cannot_fetch_register,
  139.   cris_cannot_store_register,
  140.   NULL, /* fetch_register */
  141.   cris_get_pc,
  142.   cris_set_pc,
  143.   (const unsigned char *) &cris_breakpoint,
  144.   cris_breakpoint_len,
  145.   cris_reinsert_addr,
  146.   0,
  147.   cris_breakpoint_at,
  148.   0,
  149.   0,
  150.   0,
  151.   0,
  152. };

  154. void
  155. ‌initialize_low_arch (void)
  156. {
  157.   init_registers_cris ();
  158. }