From: Jiangshuai Li Date: Tue, 13 Sep 2022 03:20:54 +0000 (+0800) Subject: gdbserver/csky add csky gdbserver support X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=02cd1b4e97120f71710c4246953bcb2d63cb4aea;p=binutils-gdb.git gdbserver/csky add csky gdbserver support Add new files: gdb/arch/csky.c gdb/arch/csky.h gdb/features/cskyv2-linux.c gdbserver/linux-csky-low.cc 1. In gdb/arch/csky.c file, add function "csky_create_target_description()" for csky_target::low_arch_setup(). later, it can be used for csky native gdb. 2. In gdb/features/cskyv2-linux.c file, create target_tdesc for csky, include gprs, pc, hi, lo, float, vector and float control registers. 3. In gdbserver/linux-csky-low.cc file, using PTRACE_GET/SET_RGESET to get/set registers. The main data structures in asm/ptrace.h are: struct pt_regs { unsigned long tls; unsigned long lr; unsigned long pc; unsigned long sr; unsigned long usp; /* * a0, a1, a2, a3: * r0, r1, r2, r3 */ unsigned long orig_a0; unsigned long a0; unsigned long a1; unsigned long a2; unsigned long a3; /* * r4 ~ r13 */ unsigned long regs[10]; /* r16 ~ r30 */ unsigned long exregs[15]; unsigned long rhi; unsigned long rlo; unsigned long dcsr; }; struct user_fp { unsigned long vr[96]; unsigned long fcr; unsigned long fesr; unsigned long fid; unsigned long reserved; }; --- diff --git a/gdb/NEWS b/gdb/NEWS index dee0ac2ecd8..555ef2ddf77 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -118,6 +118,8 @@ maintenance info line-table GNU/Linux/LoongArch (gdbserver) loongarch*-*-linux* +GNU/Linux/CSKY (gdbserver) csky*-*linux* + * Python API ** GDB will now reformat the doc string for gdb.Command and @@ -194,6 +196,8 @@ GNU/Linux/LoongArch (gdbserver) loongarch*-*-linux* * New features in the GDB remote stub, GDBserver ** GDBserver is now supported on LoongArch GNU/Linux. + + ** GDBserver is now supported on CSKY GNU/Linux. * LoongArch floating-point support diff --git a/gdb/arch/csky.c b/gdb/arch/csky.c new file mode 100644 index 00000000000..887796753c6 --- /dev/null +++ b/gdb/arch/csky.c @@ -0,0 +1,38 @@ +/* Copyright (C) 2022 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 . */ + +#include "gdbsupport/common-defs.h" +#include "csky.h" +#include + +#include "../features/cskyv2-linux.c" + +target_desc_up +csky_create_target_description (void) +{ + /* Now we should create a new target description. */ + target_desc_up tdesc = allocate_target_description (); + +#ifndef IN_PROCESS_AGENT + std::string arch_name = "csky"; + set_tdesc_architecture (tdesc.get (), arch_name.c_str ()); +#endif + + create_feature_cskyv2_linux (tdesc.get ()); + + return tdesc; +} diff --git a/gdb/arch/csky.h b/gdb/arch/csky.h new file mode 100644 index 00000000000..1c147a973a4 --- /dev/null +++ b/gdb/arch/csky.h @@ -0,0 +1,29 @@ +/* Common target-dependent functionality for CSKY + + Copyright (C) 2022 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 . */ + +#ifndef ARCH_CSKY_H +#define ARCH_CSKy_H + +#include "gdbsupport/tdesc.h" + +/* Used for gdbserver. */ + +target_desc_up csky_create_target_description (void); + +#endif /* ARCH_CSKY_H */ diff --git a/gdb/features/cskyv2-linux.c b/gdb/features/cskyv2-linux.c new file mode 100644 index 00000000000..e49b68c4b8d --- /dev/null +++ b/gdb/features/cskyv2-linux.c @@ -0,0 +1,127 @@ +/* THIS FILE IS GENERATED. -*- buffer-read-only: t -*- vi:set ro: + Original: cskyv2-linux.xml */ + +#include "gdbsupport/tdesc.h" + +static void +create_feature_cskyv2_linux (struct target_desc *result) +{ + struct tdesc_feature *feature; + + feature = tdesc_create_feature (result, "org.gnu.gdb.csky.abiv2"); + tdesc_create_reg (feature, "r0", 0, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r1", 1, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r2", 2, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r3", 3, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r4", 4, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r5", 5, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r6", 6, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r7", 7, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r8", 8, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r9", 9, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r10", 10, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r11", 11, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r12", 12, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r13", 13, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r14", 14, 1, NULL, 32, "data_ptr"); + tdesc_create_reg (feature, "r15", 15, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r16", 16, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r17", 17, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r18", 18, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r19", 19, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r20", 20, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r21", 21, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r22", 22, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r23", 23, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r24", 24, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r25", 25, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r26", 26, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r27", 27, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r28", 28, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r29", 29, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r30", 30, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "r31", 31, 1, NULL, 32, "int"); + + tdesc_create_reg (feature, "lo", 36, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "hi", 37, 1, NULL, 32, "int"); + + tdesc_create_reg (feature, "fr0", 40, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr1", 41, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr2", 42, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr3", 43, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr4", 44, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr5", 45, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr6", 46, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr7", 47, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr8", 48, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr9", 49, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr10", 50, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr11", 51, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr12", 52, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr13", 53, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr14", 54, 1, NULL, 64, "ieee_double"); + tdesc_create_reg (feature, "fr15", 55, 1, NULL, 64, "ieee_double"); + + tdesc_type *element_type; + element_type = tdesc_named_type (feature, "ieee_single"); + tdesc_create_vector (feature, "v4f", element_type, 4); + + element_type = tdesc_named_type (feature, "ieee_double"); + tdesc_create_vector (feature, "v2d", element_type, 2); + + element_type = tdesc_named_type (feature, "int8"); + tdesc_create_vector (feature, "v16i8", element_type, 16); + + element_type = tdesc_named_type (feature, "int16"); + tdesc_create_vector (feature, "v8i16", element_type, 8); + + element_type = tdesc_named_type (feature, "int32"); + tdesc_create_vector (feature, "v4i32", element_type, 4); + + element_type = tdesc_named_type (feature, "int64"); + tdesc_create_vector (feature, "v2i64", element_type, 2); + + tdesc_type_with_fields *type_with_fields; + type_with_fields = tdesc_create_union (feature, "vec128"); + tdesc_type *field_type; + field_type = tdesc_named_type (feature, "v4f"); + tdesc_add_field (type_with_fields, "v4_float", field_type); + field_type = tdesc_named_type (feature, "v2d"); + tdesc_add_field (type_with_fields, "v2_double", field_type); + field_type = tdesc_named_type (feature, "v16i8"); + tdesc_add_field (type_with_fields, "v16_int8", field_type); + field_type = tdesc_named_type (feature, "v8i16"); + tdesc_add_field (type_with_fields, "v8_int16", field_type); + field_type = tdesc_named_type (feature, "v4i32"); + tdesc_add_field (type_with_fields, "v4_int32", field_type); + field_type = tdesc_named_type (feature, "v2i64"); + tdesc_add_field (type_with_fields, "v2_int64", field_type); + field_type = tdesc_named_type (feature, "uint128"); + tdesc_add_field (type_with_fields, "uint128", field_type); + + + tdesc_create_reg (feature, "vr0", 56, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr1", 57, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr2", 58, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr3", 59, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr4", 60, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr5", 61, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr6", 62, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr7", 63, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr8", 64, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr9", 65, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr10", 66, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr11", 67, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr12", 68, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr13", 69, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr14", 70, 1, NULL, 128, "vec128"); + tdesc_create_reg (feature, "vr15", 71, 1, NULL, 128, "vec128"); + + tdesc_create_reg (feature, "pc", 72, 1, NULL, 32, "code_ptr"); + tdesc_create_reg (feature, "psr", 89, 1, NULL, 32, "int"); + + tdesc_create_reg (feature, "fid", 121, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "fcr", 122, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "fesr", 123, 1, NULL, 32, "int"); + tdesc_create_reg (feature, "usp", 127, 1, NULL, 32, "int"); +} diff --git a/gdbserver/Makefile.in b/gdbserver/Makefile.in index 75e497753e8..8462d78a859 100644 --- a/gdbserver/Makefile.in +++ b/gdbserver/Makefile.in @@ -175,6 +175,7 @@ SFILES = \ $(srcdir)/linux-aarch64-low.cc \ $(srcdir)/linux-arc-low.cc \ $(srcdir)/linux-arm-low.cc \ + $(srcdir)/linux-csky-low.cc \ $(srcdir)/linux-ia64-low.cc \ $(srcdir)/linux-loongarch-low.cc \ $(srcdir)/linux-low.cc \ @@ -212,6 +213,7 @@ SFILES = \ $(srcdir)/../gdb/arch/arm.c \ $(srcdir)/../gdb/arch/arm-get-next-pcs.c \ $(srcdir)/../gdb/arch/arm-linux.c \ + $(srcdir)/../gdb/arch/csky.c \ $(srcdir)/../gdb/arch/loongarch.c \ $(srcdir)/../gdb/arch/ppc-linux-common.c \ $(srcdir)/../gdb/arch/riscv.c \ diff --git a/gdbserver/configure.srv b/gdbserver/configure.srv index ebb6b32a6c4..f0101994529 100644 --- a/gdbserver/configure.srv +++ b/gdbserver/configure.srv @@ -88,6 +88,11 @@ case "${gdbserver_host}" in srv_linux_regsets=yes srv_linux_thread_db=yes ;; + csky*-*linux*) srv_tgtobj="$srv_linux_obj linux-csky-low.o" + srv_tgtobj="${srv_tgtobj} arch/csky.o" + srv_linux_regsets=yes + srv_linux_thread_db=yes + ;; i[34567]86-*-cygwin*) srv_regobj="" srv_tgtobj="x86-low.o nat/x86-dregs.o win32-low.o" srv_tgtobj="${srv_tgtobj} win32-i386-low.o" diff --git a/gdbserver/linux-csky-low.cc b/gdbserver/linux-csky-low.cc new file mode 100644 index 00000000000..708a8725d33 --- /dev/null +++ b/gdbserver/linux-csky-low.cc @@ -0,0 +1,351 @@ +/* GNU/Linux/MIPS specific low level interface, for the remote server for GDB. + Copyright (C) 2022 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 . */ + +#include "server.h" +#include "tdesc.h" +#include "linux-low.h" +#include +#include "gdb_proc_service.h" +#include +#include +#include "arch/csky.h" + +/* Linux target op definitions for the CSKY architecture. */ + +class csky_target : public linux_process_target +{ +public: + + const regs_info *get_regs_info () override; + + const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override; + + bool supports_z_point_type (char z_type) override; + + bool supports_hardware_single_step () override; + +protected: + + void low_arch_setup () override; + + bool low_cannot_fetch_register (int regno) override; + + bool low_cannot_store_register (int regno) override; + + CORE_ADDR low_get_pc (regcache *regcache) override; + + void low_set_pc (regcache *regcache, CORE_ADDR newpc) override; + + bool low_breakpoint_at (CORE_ADDR pc) override; +}; + +/* The singleton target ops object. */ + +static csky_target the_csky_target; + +/* Return the ptrace "address" of register REGNO. */ +static int csky_regmap[] = { + 0*4, 1*4, 2*4, 3*4, 4*4, 5*4, 6*4, 7*4, + 8*4, 9*4, 10*4, 11*4, 12*4, 13*4, 14*4, 15*4, + 16*4, 17*4, 18*4, 19*4, 20*4, 21*4, 22*4, 23*4, + 24*4, 25*4, 26*4, 27*4, 28*4, 29*4, 30*4, 31*4, + -1, -1, -1, -1, 34*4, 35*4, -1, -1, + 40*4, 42*4, 44*4, 46*4, 48*4, 50*4, 52*4, 54*4, /* fr0 ~ fr15, 64bit */ + 56*4, 58*4, 60*4, 62*4, 64*4, 66*4, 68*4, 70*4, + 72*4, 76*4, 80*4, 84*4, 88*4, 92*4, 96*4,100*4, /* vr0 ~ vr15, 128bit */ + 104*4,108*4,112*4,116*4,120*4,124*4,128*4,132*4, + 33*4, /* pc */ + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + 32*4, -1, -1, -1, -1, -1, -1, -1, /* psr */ + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + 73*4, 72*4, 74*4, -1, -1, -1, 14*4, /* fcr, fid, fesr, usp */ +}; + +/* CSKY software breakpoint instruction code. */ + +/* When the kernel code version is behind v4.x, + illegal insn 0x1464 will be a software bkpt trigger. + When an illegal insn exception happens, the case + that insn at EPC is 0x1464 will be recognized as SIGTRAP. */ +static unsigned short csky_breakpoint_illegal_2_v2 = 0x1464; +static unsigned int csky_breakpoint_illegal_4_v2 = 0x14641464; + +bool +csky_target::low_cannot_fetch_register (int regno) +{ + if (csky_regmap[regno] == -1) + return true; + + return false; +} + +bool +csky_target::low_cannot_store_register (int regno) +{ + if (csky_regmap[regno] == -1) + return true; + + return false; +} + +/* Get the value of pc register. */ + +CORE_ADDR +csky_target::low_get_pc (struct regcache *regcache) +{ + unsigned long pc; + collect_register_by_name (regcache, "pc", &pc); + return pc; +} + +/* Set pc register. */ + +void +csky_target::low_set_pc (struct regcache *regcache, CORE_ADDR pc) +{ + unsigned long new_pc = pc; + supply_register_by_name (regcache, "pc", &new_pc); +} + + +void +csky_target::low_arch_setup () +{ + static const char *expedite_regs[] = { "r14", "pc", NULL }; + target_desc_up tdesc = csky_create_target_description (); + + if (!tdesc->expedite_regs) + init_target_desc (tdesc.get (), expedite_regs); + + current_process ()->tdesc = tdesc.release (); + + return; +} + +/* Fetch the thread-local storage pointer for libthread_db. */ + +ps_err_e +ps_get_thread_area (struct ps_prochandle *ph, + lwpid_t lwpid, int idx, void **base) +{ + struct pt_regs regset; + if (ptrace (PTRACE_GETREGSET, lwpid, + (PTRACE_TYPE_ARG3) (long) NT_PRSTATUS, ®set) != 0) + return PS_ERR; + + *base = (void *) regset.tls; + + /* IDX is the bias from the thread pointer to the beginning of the + thread descriptor. It has to be subtracted due to implementation + quirks in libthread_db. */ + *base = (void *) ((char *)*base - idx); + + return PS_OK; +} + +/* Gdbserver uses PTRACE_GET/SET_RGESET. */ + +static void +csky_fill_pt_gregset (struct regcache *regcache, void *buf) +{ + int i, base; + struct pt_regs *regset = (struct pt_regs *)buf; + + collect_register_by_name (regcache, "r15", ®set->lr); + collect_register_by_name (regcache, "pc", ®set->pc); + collect_register_by_name (regcache, "psr", ®set->sr); + collect_register_by_name (regcache, "r14", ®set->usp); + + collect_register_by_name (regcache, "r0", ®set->a0); + collect_register_by_name (regcache, "r1", ®set->a1); + collect_register_by_name (regcache, "r2", ®set->a2); + collect_register_by_name (regcache, "r3", ®set->a3); + + base = find_regno (regcache->tdesc, "r4"); + + for (i = 0; i < 10; i++) + collect_register (regcache, base + i, ®set->regs[i]); + + base = find_regno (regcache->tdesc, "r16"); + for (i = 0; i < 16; i++) + collect_register (regcache, base + i, ®set->exregs[i]); + + collect_register_by_name (regcache, "hi", ®set->rhi); + collect_register_by_name (regcache, "lo", ®set->rlo); +} + +static void +csky_store_pt_gregset (struct regcache *regcache, const void *buf) +{ + int i, base; + const struct pt_regs *regset = (const struct pt_regs *) buf; + + supply_register_by_name (regcache, "r15", ®set->lr); + supply_register_by_name (regcache, "pc", ®set->pc); + supply_register_by_name (regcache, "psr", ®set->sr); + supply_register_by_name (regcache, "r14", ®set->usp); + + supply_register_by_name (regcache, "r0", ®set->a0); + supply_register_by_name (regcache, "r1", ®set->a1); + supply_register_by_name (regcache, "r2", ®set->a2); + supply_register_by_name (regcache, "r3", ®set->a3); + + base = find_regno (regcache->tdesc, "r4"); + + for (i = 0; i < 10; i++) + supply_register (regcache, base + i, ®set->regs[i]); + + base = find_regno (regcache->tdesc, "r16"); + for (i = 0; i < 16; i++) + supply_register (regcache, base + i, ®set->exregs[i]); + + supply_register_by_name (regcache, "hi", ®set->rhi); + supply_register_by_name (regcache, "lo", ®set->rlo); +} + +static void +csky_fill_pt_vrregset (struct regcache *regcache, void *buf) +{ + int i, base; + struct user_fp *regset = (struct user_fp *)buf; + + base = find_regno (regcache->tdesc, "vr0"); + + for (i = 0; i < 16; i++) + collect_register (regcache, base + i, ®set->vr[i * 4]); + collect_register_by_name (regcache, "fcr", ®set->fcr); + collect_register_by_name (regcache, "fesr", ®set->fesr); + collect_register_by_name (regcache, "fid", ®set->fid); +} + + +static void +csky_store_pt_vrregset (struct regcache *regcache, const void *buf) +{ + int i, base; + const struct user_fp *regset = (const struct user_fp *)buf; + + base = find_regno (regcache->tdesc, "vr0"); + + for (i = 0; i < 16; i++) + supply_register (regcache, base + i, ®set->vr[i * 4]); + + base = find_regno (regcache->tdesc, "fr0"); + + for (i = 0; i < 16; i++) + supply_register (regcache, base + i, ®set->vr[i * 4]); + supply_register_by_name (regcache, "fcr", ®set->fcr); + supply_register_by_name (regcache, "fesr", ®set->fesr); + supply_register_by_name (regcache, "fid", ®set->fid); +} + +struct regset_info csky_regsets[] = { + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_PRSTATUS, sizeof(struct pt_regs), + GENERAL_REGS, csky_fill_pt_gregset, csky_store_pt_gregset}, + + { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_FPREGSET, sizeof(struct user_fp), + FP_REGS, csky_fill_pt_vrregset, csky_store_pt_vrregset}, + NULL_REGSET +}; + + +static struct regsets_info csky_regsets_info = +{ + csky_regsets, /* Regsets */ + 0, /* Num_regsets */ + NULL, /* Disabled_regsets */ +}; + + +static struct regs_info csky_regs_info = +{ + NULL, /* FIXME: what's this */ + NULL, /* PEEKUSER/PORKUSR isn't supported by kernel > 4.x */ + &csky_regsets_info +}; + + +const regs_info * +csky_target::get_regs_info () +{ + return &csky_regs_info; +} + +/* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */ + +const gdb_byte * +csky_target::sw_breakpoint_from_kind (int kind, int *size) +{ + if (kind == 4) + { + *size = 4; + return (const gdb_byte *) &csky_breakpoint_illegal_4_v2; + } + else + { + *size = 2; + return (const gdb_byte *) &csky_breakpoint_illegal_2_v2; + } +} + +bool +csky_target::supports_z_point_type (char z_type) +{ + /* FIXME: hardware breakpoint support ?? */ + if (z_type == Z_PACKET_SW_BP) + return true; + + return false; +} + +bool +csky_target::low_breakpoint_at (CORE_ADDR where) +{ + unsigned int insn; + + /* Here just read 2 bytes, as csky_breakpoint_illegal_4_v2 + is double of csky_breakpoint_illegal_2_v2, csky_breakpoint_bkpt_4 + is double of csky_breakpoint_bkpt_2. Others are 2 bytes bkpt. */ + read_memory (where, (unsigned char *) &insn, 2); + + if (insn == csky_breakpoint_illegal_2_v2) + return true; + + return false; +} + +/* Support for hardware single step. */ + +bool +csky_target::supports_hardware_single_step () +{ + return true; +} + +/* The linux target ops object. */ + +linux_process_target *the_linux_target = &the_csky_target; + +void +initialize_low_arch (void) +{ + initialize_regsets_info (&csky_regsets_info); +}