1 /* GNU/Linux/RISC-V specific low level interface, for the remote server
3 Copyright (C) 2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "linux-low.h"
24 #include "elf/common.h"
25 #include "nat/riscv-linux-tdesc.h"
26 #include "opcode/riscv.h"
28 /* Work around glibc header breakage causing ELF_NFPREG not to be usable. */
33 /* Implementation of linux_target_ops method "arch_setup". */
38 static const char *expedite_regs
[] = { "sp", "pc", NULL
};
40 const riscv_gdbarch_features features
41 = riscv_linux_read_features (lwpid_of (current_thread
));
42 target_desc
*tdesc
= riscv_create_target_description (features
);
44 if (!tdesc
->expedite_regs
)
45 init_target_desc (tdesc
, expedite_regs
);
46 current_process ()->tdesc
= tdesc
;
49 /* Collect GPRs from REGCACHE into BUF. */
52 riscv_fill_gregset (struct regcache
*regcache
, void *buf
)
54 const struct target_desc
*tdesc
= regcache
->tdesc
;
55 elf_gregset_t
*regset
= (elf_gregset_t
*) buf
;
56 int regno
= find_regno (tdesc
, "zero");
59 collect_register_by_name (regcache
, "pc", *regset
);
60 for (i
= 1; i
< ARRAY_SIZE (*regset
); i
++)
61 collect_register (regcache
, regno
+ i
, *regset
+ i
);
64 /* Supply GPRs from BUF into REGCACHE. */
67 riscv_store_gregset (struct regcache
*regcache
, const void *buf
)
69 const elf_gregset_t
*regset
= (const elf_gregset_t
*) buf
;
70 const struct target_desc
*tdesc
= regcache
->tdesc
;
71 int regno
= find_regno (tdesc
, "zero");
74 supply_register_by_name (regcache
, "pc", *regset
);
75 supply_register_zeroed (regcache
, regno
);
76 for (i
= 1; i
< ARRAY_SIZE (*regset
); i
++)
77 supply_register (regcache
, regno
+ i
, *regset
+ i
);
80 /* Collect FPRs from REGCACHE into BUF. */
83 riscv_fill_fpregset (struct regcache
*regcache
, void *buf
)
85 const struct target_desc
*tdesc
= regcache
->tdesc
;
86 int regno
= find_regno (tdesc
, "ft0");
87 int flen
= register_size (regcache
->tdesc
, regno
);
88 gdb_byte
*regbuf
= (gdb_byte
*) buf
;
91 for (i
= 0; i
< ELF_NFPREG
- 1; i
++, regbuf
+= flen
)
92 collect_register (regcache
, regno
+ i
, regbuf
);
93 collect_register_by_name (regcache
, "fcsr", regbuf
);
96 /* Supply FPRs from BUF into REGCACHE. */
99 riscv_store_fpregset (struct regcache
*regcache
, const void *buf
)
101 const struct target_desc
*tdesc
= regcache
->tdesc
;
102 int regno
= find_regno (tdesc
, "ft0");
103 int flen
= register_size (regcache
->tdesc
, regno
);
104 const gdb_byte
*regbuf
= (const gdb_byte
*) buf
;
107 for (i
= 0; i
< ELF_NFPREG
- 1; i
++, regbuf
+= flen
)
108 supply_register (regcache
, regno
+ i
, regbuf
);
109 supply_register_by_name (regcache
, "fcsr", regbuf
);
112 /* RISC-V/Linux regsets. FPRs are optional and come in different sizes,
113 so define multiple regsets for them marking them all as OPTIONAL_REGS
114 rather than FP_REGS, so that "regsets_fetch_inferior_registers" picks
115 the right one according to size. */
116 static struct regset_info riscv_regsets
[] = {
117 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_PRSTATUS
,
118 sizeof (elf_gregset_t
), GENERAL_REGS
,
119 riscv_fill_gregset
, riscv_store_gregset
},
120 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_FPREGSET
,
121 sizeof (struct __riscv_mc_q_ext_state
), OPTIONAL_REGS
,
122 riscv_fill_fpregset
, riscv_store_fpregset
},
123 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_FPREGSET
,
124 sizeof (struct __riscv_mc_d_ext_state
), OPTIONAL_REGS
,
125 riscv_fill_fpregset
, riscv_store_fpregset
},
126 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_FPREGSET
,
127 sizeof (struct __riscv_mc_f_ext_state
), OPTIONAL_REGS
,
128 riscv_fill_fpregset
, riscv_store_fpregset
},
132 /* RISC-V/Linux regset information. */
133 static struct regsets_info riscv_regsets_info
=
135 riscv_regsets
, /* regsets */
137 NULL
, /* disabled_regsets */
140 /* Definition of linux_target_ops data member "regs_info". */
141 static struct regs_info riscv_regs
=
143 NULL
, /* regset_bitmap */
148 /* Implementation of linux_target_ops method "regs_info". */
150 static const struct regs_info
*
156 /* Implementation of linux_target_ops method "fetch_register". */
159 riscv_fetch_register (struct regcache
*regcache
, int regno
)
161 const struct target_desc
*tdesc
= regcache
->tdesc
;
163 if (regno
!= find_regno (tdesc
, "zero"))
165 supply_register_zeroed (regcache
, regno
);
169 /* Implementation of linux_target_ops method "get_pc". */
172 riscv_get_pc (struct regcache
*regcache
)
174 elf_gregset_t regset
;
176 if (sizeof (regset
[0]) == 8)
177 return linux_get_pc_64bit (regcache
);
179 return linux_get_pc_32bit (regcache
);
182 /* Implementation of linux_target_ops method "set_pc". */
185 riscv_set_pc (struct regcache
*regcache
, CORE_ADDR newpc
)
187 elf_gregset_t regset
;
189 if (sizeof (regset
[0]) == 8)
190 linux_set_pc_64bit (regcache
, newpc
);
192 linux_set_pc_32bit (regcache
, newpc
);
195 /* Correct in either endianness. */
196 static const uint16_t riscv_ibreakpoint
[] = { 0x0073, 0x0010 };
197 static const uint16_t riscv_cbreakpoint
= 0x9002;
199 /* Implementation of linux_target_ops method "breakpoint_kind_from_pc". */
202 riscv_breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
211 if (target_read_memory (*pcptr
, buf
.bytes
, sizeof (buf
.insn
)) == 0
212 && riscv_insn_length (buf
.insn
== sizeof (riscv_ibreakpoint
)))
213 return sizeof (riscv_ibreakpoint
);
215 return sizeof (riscv_cbreakpoint
);
218 /* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */
220 static const gdb_byte
*
221 riscv_sw_breakpoint_from_kind (int kind
, int *size
)
226 case sizeof (riscv_ibreakpoint
):
227 return (const gdb_byte
*) &riscv_ibreakpoint
;
229 return (const gdb_byte
*) &riscv_cbreakpoint
;
233 /* Implementation of linux_target_ops method "breakpoint_at". */
236 riscv_breakpoint_at (CORE_ADDR pc
)
245 if (target_read_memory (pc
, buf
.bytes
, sizeof (buf
.insn
)) == 0
246 && (buf
.insn
== riscv_cbreakpoint
247 || (buf
.insn
== riscv_ibreakpoint
[0]
248 && target_read_memory (pc
+ sizeof (buf
.insn
), buf
.bytes
,
249 sizeof (buf
.insn
)) == 0
250 && buf
.insn
== riscv_ibreakpoint
[1])))
256 /* RISC-V/Linux target operations. */
257 struct linux_target_ops the_low_target
=
261 NULL
, /* cannot_fetch_register */
262 NULL
, /* cannot_store_register */
263 riscv_fetch_register
,
266 riscv_breakpoint_kind_from_pc
,
267 riscv_sw_breakpoint_from_kind
,
268 NULL
, /* get_next_pcs */
269 0, /* decr_pc_after_break */
273 /* Initialize the RISC-V/Linux target. */
276 initialize_low_arch ()
278 initialize_regsets_info (&riscv_regsets_info
);