Merge remote-tracking branch 'remotes/kraxel/tags/seabios-20220118-pull-request'...
[qemu.git] / target / s390x / gdbstub.c
1 /*
2 * s390x gdb server stub
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 * Copyright (c) 2013 SUSE LINUX Products GmbH
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library 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 GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "qemu/osdep.h"
22 #include "cpu.h"
23 #include "s390x-internal.h"
24 #include "exec/exec-all.h"
25 #include "exec/gdbstub.h"
26 #include "qemu/bitops.h"
27 #include "sysemu/hw_accel.h"
28 #include "sysemu/tcg.h"
29
30 int s390_cpu_gdb_read_register(CPUState *cs, GByteArray *mem_buf, int n)
31 {
32 S390CPU *cpu = S390_CPU(cs);
33 CPUS390XState *env = &cpu->env;
34
35 switch (n) {
36 case S390_PSWM_REGNUM:
37 return gdb_get_regl(mem_buf, s390_cpu_get_psw_mask(env));
38 case S390_PSWA_REGNUM:
39 return gdb_get_regl(mem_buf, env->psw.addr);
40 case S390_R0_REGNUM ... S390_R15_REGNUM:
41 return gdb_get_regl(mem_buf, env->regs[n - S390_R0_REGNUM]);
42 }
43 return 0;
44 }
45
46 int s390_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
47 {
48 S390CPU *cpu = S390_CPU(cs);
49 CPUS390XState *env = &cpu->env;
50 target_ulong tmpl = ldtul_p(mem_buf);
51
52 switch (n) {
53 case S390_PSWM_REGNUM:
54 s390_cpu_set_psw(env, tmpl, env->psw.addr);
55 break;
56 case S390_PSWA_REGNUM:
57 env->psw.addr = tmpl;
58 break;
59 case S390_R0_REGNUM ... S390_R15_REGNUM:
60 env->regs[n - S390_R0_REGNUM] = tmpl;
61 break;
62 default:
63 return 0;
64 }
65 return 8;
66 }
67
68 /* the values represent the positions in s390-acr.xml */
69 #define S390_A0_REGNUM 0
70 #define S390_A15_REGNUM 15
71 /* total number of registers in s390-acr.xml */
72 #define S390_NUM_AC_REGS 16
73
74 static int cpu_read_ac_reg(CPUS390XState *env, GByteArray *buf, int n)
75 {
76 switch (n) {
77 case S390_A0_REGNUM ... S390_A15_REGNUM:
78 return gdb_get_reg32(buf, env->aregs[n]);
79 default:
80 return 0;
81 }
82 }
83
84 static int cpu_write_ac_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
85 {
86 switch (n) {
87 case S390_A0_REGNUM ... S390_A15_REGNUM:
88 env->aregs[n] = ldl_p(mem_buf);
89 cpu_synchronize_post_init(env_cpu(env));
90 return 4;
91 default:
92 return 0;
93 }
94 }
95
96 /* the values represent the positions in s390-fpr.xml */
97 #define S390_FPC_REGNUM 0
98 #define S390_F0_REGNUM 1
99 #define S390_F15_REGNUM 16
100 /* total number of registers in s390-fpr.xml */
101 #define S390_NUM_FP_REGS 17
102
103 static int cpu_read_fp_reg(CPUS390XState *env, GByteArray *buf, int n)
104 {
105 switch (n) {
106 case S390_FPC_REGNUM:
107 return gdb_get_reg32(buf, env->fpc);
108 case S390_F0_REGNUM ... S390_F15_REGNUM:
109 return gdb_get_reg64(buf, *get_freg(env, n - S390_F0_REGNUM));
110 default:
111 return 0;
112 }
113 }
114
115 static int cpu_write_fp_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
116 {
117 switch (n) {
118 case S390_FPC_REGNUM:
119 env->fpc = ldl_p(mem_buf);
120 return 4;
121 case S390_F0_REGNUM ... S390_F15_REGNUM:
122 *get_freg(env, n - S390_F0_REGNUM) = ldtul_p(mem_buf);
123 return 8;
124 default:
125 return 0;
126 }
127 }
128
129 /* the values represent the positions in s390-vx.xml */
130 #define S390_V0L_REGNUM 0
131 #define S390_V15L_REGNUM 15
132 #define S390_V16_REGNUM 16
133 #define S390_V31_REGNUM 31
134 /* total number of registers in s390-vx.xml */
135 #define S390_NUM_VREGS 32
136
137 static int cpu_read_vreg(CPUS390XState *env, GByteArray *buf, int n)
138 {
139 int ret;
140
141 switch (n) {
142 case S390_V0L_REGNUM ... S390_V15L_REGNUM:
143 ret = gdb_get_reg64(buf, env->vregs[n][1]);
144 break;
145 case S390_V16_REGNUM ... S390_V31_REGNUM:
146 ret = gdb_get_reg64(buf, env->vregs[n][0]);
147 ret += gdb_get_reg64(buf, env->vregs[n][1]);
148 break;
149 default:
150 ret = 0;
151 }
152
153 return ret;
154 }
155
156 static int cpu_write_vreg(CPUS390XState *env, uint8_t *mem_buf, int n)
157 {
158 switch (n) {
159 case S390_V0L_REGNUM ... S390_V15L_REGNUM:
160 env->vregs[n][1] = ldtul_p(mem_buf + 8);
161 return 8;
162 case S390_V16_REGNUM ... S390_V31_REGNUM:
163 env->vregs[n][0] = ldtul_p(mem_buf);
164 env->vregs[n][1] = ldtul_p(mem_buf + 8);
165 return 16;
166 default:
167 return 0;
168 }
169 }
170
171 /* the values represent the positions in s390-cr.xml */
172 #define S390_C0_REGNUM 0
173 #define S390_C15_REGNUM 15
174 /* total number of registers in s390-cr.xml */
175 #define S390_NUM_C_REGS 16
176
177 #ifndef CONFIG_USER_ONLY
178 static int cpu_read_c_reg(CPUS390XState *env, GByteArray *buf, int n)
179 {
180 switch (n) {
181 case S390_C0_REGNUM ... S390_C15_REGNUM:
182 return gdb_get_regl(buf, env->cregs[n]);
183 default:
184 return 0;
185 }
186 }
187
188 static int cpu_write_c_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
189 {
190 switch (n) {
191 case S390_C0_REGNUM ... S390_C15_REGNUM:
192 env->cregs[n] = ldtul_p(mem_buf);
193 if (tcg_enabled()) {
194 tlb_flush(env_cpu(env));
195 }
196 cpu_synchronize_post_init(env_cpu(env));
197 return 8;
198 default:
199 return 0;
200 }
201 }
202
203 /* the values represent the positions in s390-virt.xml */
204 #define S390_VIRT_CKC_REGNUM 0
205 #define S390_VIRT_CPUTM_REGNUM 1
206 #define S390_VIRT_BEA_REGNUM 2
207 #define S390_VIRT_PREFIX_REGNUM 3
208 #define S390_VIRT_PP_REGNUM 4
209 #define S390_VIRT_PFT_REGNUM 5
210 #define S390_VIRT_PFS_REGNUM 6
211 #define S390_VIRT_PFC_REGNUM 7
212 /* total number of registers in s390-virt.xml */
213 #define S390_NUM_VIRT_REGS 8
214
215 static int cpu_read_virt_reg(CPUS390XState *env, GByteArray *mem_buf, int n)
216 {
217 switch (n) {
218 case S390_VIRT_CKC_REGNUM:
219 return gdb_get_regl(mem_buf, env->ckc);
220 case S390_VIRT_CPUTM_REGNUM:
221 return gdb_get_regl(mem_buf, env->cputm);
222 case S390_VIRT_BEA_REGNUM:
223 return gdb_get_regl(mem_buf, env->gbea);
224 case S390_VIRT_PREFIX_REGNUM:
225 return gdb_get_regl(mem_buf, env->psa);
226 case S390_VIRT_PP_REGNUM:
227 return gdb_get_regl(mem_buf, env->pp);
228 case S390_VIRT_PFT_REGNUM:
229 return gdb_get_regl(mem_buf, env->pfault_token);
230 case S390_VIRT_PFS_REGNUM:
231 return gdb_get_regl(mem_buf, env->pfault_select);
232 case S390_VIRT_PFC_REGNUM:
233 return gdb_get_regl(mem_buf, env->pfault_compare);
234 default:
235 return 0;
236 }
237 }
238
239 static int cpu_write_virt_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
240 {
241 switch (n) {
242 case S390_VIRT_CKC_REGNUM:
243 env->ckc = ldtul_p(mem_buf);
244 cpu_synchronize_post_init(env_cpu(env));
245 return 8;
246 case S390_VIRT_CPUTM_REGNUM:
247 env->cputm = ldtul_p(mem_buf);
248 cpu_synchronize_post_init(env_cpu(env));
249 return 8;
250 case S390_VIRT_BEA_REGNUM:
251 env->gbea = ldtul_p(mem_buf);
252 cpu_synchronize_post_init(env_cpu(env));
253 return 8;
254 case S390_VIRT_PREFIX_REGNUM:
255 env->psa = ldtul_p(mem_buf);
256 cpu_synchronize_post_init(env_cpu(env));
257 return 8;
258 case S390_VIRT_PP_REGNUM:
259 env->pp = ldtul_p(mem_buf);
260 cpu_synchronize_post_init(env_cpu(env));
261 return 8;
262 case S390_VIRT_PFT_REGNUM:
263 env->pfault_token = ldtul_p(mem_buf);
264 cpu_synchronize_post_init(env_cpu(env));
265 return 8;
266 case S390_VIRT_PFS_REGNUM:
267 env->pfault_select = ldtul_p(mem_buf);
268 cpu_synchronize_post_init(env_cpu(env));
269 return 8;
270 case S390_VIRT_PFC_REGNUM:
271 env->pfault_compare = ldtul_p(mem_buf);
272 cpu_synchronize_post_init(env_cpu(env));
273 return 8;
274 default:
275 return 0;
276 }
277 }
278 #endif
279
280 /* the values represent the positions in s390-gs.xml */
281 #define S390_GS_RESERVED_REGNUM 0
282 #define S390_GS_GSD_REGNUM 1
283 #define S390_GS_GSSM_REGNUM 2
284 #define S390_GS_GSEPLA_REGNUM 3
285 /* total number of registers in s390-gs.xml */
286 #define S390_NUM_GS_REGS 4
287
288 static int cpu_read_gs_reg(CPUS390XState *env, GByteArray *buf, int n)
289 {
290 return gdb_get_regl(buf, env->gscb[n]);
291 }
292
293 static int cpu_write_gs_reg(CPUS390XState *env, uint8_t *mem_buf, int n)
294 {
295 env->gscb[n] = ldtul_p(mem_buf);
296 cpu_synchronize_post_init(env_cpu(env));
297 return 8;
298 }
299
300 void s390_cpu_gdb_init(CPUState *cs)
301 {
302 gdb_register_coprocessor(cs, cpu_read_ac_reg,
303 cpu_write_ac_reg,
304 S390_NUM_AC_REGS, "s390-acr.xml", 0);
305
306 gdb_register_coprocessor(cs, cpu_read_fp_reg,
307 cpu_write_fp_reg,
308 S390_NUM_FP_REGS, "s390-fpr.xml", 0);
309
310 gdb_register_coprocessor(cs, cpu_read_vreg,
311 cpu_write_vreg,
312 S390_NUM_VREGS, "s390-vx.xml", 0);
313
314 gdb_register_coprocessor(cs, cpu_read_gs_reg,
315 cpu_write_gs_reg,
316 S390_NUM_GS_REGS, "s390-gs.xml", 0);
317
318 #ifndef CONFIG_USER_ONLY
319 gdb_register_coprocessor(cs, cpu_read_c_reg,
320 cpu_write_c_reg,
321 S390_NUM_C_REGS, "s390-cr.xml", 0);
322
323 if (kvm_enabled()) {
324 gdb_register_coprocessor(cs, cpu_read_virt_reg,
325 cpu_write_virt_reg,
326 S390_NUM_VIRT_REGS, "s390-virt.xml", 0);
327 }
328 #endif
329 }