gdbstub.c (9561B)
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 }