1 /* 2 * qemu user cpu loop 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 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 2 of the License, or 9 * (at your option) any later version. 10 * 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. 15 * 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/>. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "qemu.h" 22 #include "user-internals.h" 23 #include "cpu_loop-common.h" 24 #include "signal-common.h" 25 26 #define SPARC64_STACK_BIAS 2047 27 28 //#define DEBUG_WIN 29 30 /* WARNING: dealing with register windows _is_ complicated. More info 31 can be found at http://www.sics.se/~psm/sparcstack.html */ 32 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) 33 { 34 index = (index + cwp * 16) % (16 * env->nwindows); 35 /* wrap handling : if cwp is on the last window, then we use the 36 registers 'after' the end */ 37 if (index < 8 && env->cwp == env->nwindows - 1) 38 index += 16 * env->nwindows; 39 return index; 40 } 41 42 /* save the register window 'cwp1' */ 43 static inline void save_window_offset(CPUSPARCState *env, int cwp1) 44 { 45 unsigned int i; 46 abi_ulong sp_ptr; 47 48 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 49 #ifdef TARGET_SPARC64 50 if (sp_ptr & 3) 51 sp_ptr += SPARC64_STACK_BIAS; 52 #endif 53 #if defined(DEBUG_WIN) 54 printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n", 55 sp_ptr, cwp1); 56 #endif 57 for(i = 0; i < 16; i++) { 58 /* FIXME - what to do if put_user() fails? */ 59 put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 60 sp_ptr += sizeof(abi_ulong); 61 } 62 } 63 64 static void save_window(CPUSPARCState *env) 65 { 66 #ifndef TARGET_SPARC64 67 unsigned int new_wim; 68 new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) & 69 ((1LL << env->nwindows) - 1); 70 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 71 env->wim = new_wim; 72 #else 73 /* 74 * cansave is zero if the spill trap handler is triggered by `save` and 75 * nonzero if triggered by a `flushw` 76 */ 77 save_window_offset(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2)); 78 env->cansave++; 79 env->canrestore--; 80 #endif 81 } 82 83 static void restore_window(CPUSPARCState *env) 84 { 85 #ifndef TARGET_SPARC64 86 unsigned int new_wim; 87 #endif 88 unsigned int i, cwp1; 89 abi_ulong sp_ptr; 90 91 #ifndef TARGET_SPARC64 92 new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) & 93 ((1LL << env->nwindows) - 1); 94 #endif 95 96 /* restore the invalid window */ 97 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 98 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 99 #ifdef TARGET_SPARC64 100 if (sp_ptr & 3) 101 sp_ptr += SPARC64_STACK_BIAS; 102 #endif 103 #if defined(DEBUG_WIN) 104 printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n", 105 sp_ptr, cwp1); 106 #endif 107 for(i = 0; i < 16; i++) { 108 /* FIXME - what to do if get_user() fails? */ 109 get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 110 sp_ptr += sizeof(abi_ulong); 111 } 112 #ifdef TARGET_SPARC64 113 env->canrestore++; 114 if (env->cleanwin < env->nwindows - 1) 115 env->cleanwin++; 116 env->cansave--; 117 #else 118 env->wim = new_wim; 119 #endif 120 } 121 122 static void flush_windows(CPUSPARCState *env) 123 { 124 int offset, cwp1; 125 126 offset = 1; 127 for(;;) { 128 /* if restore would invoke restore_window(), then we can stop */ 129 cwp1 = cpu_cwp_inc(env, env->cwp + offset); 130 #ifndef TARGET_SPARC64 131 if (env->wim & (1 << cwp1)) 132 break; 133 #else 134 if (env->canrestore == 0) 135 break; 136 env->cansave++; 137 env->canrestore--; 138 #endif 139 save_window_offset(env, cwp1); 140 offset++; 141 } 142 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 143 #ifndef TARGET_SPARC64 144 /* set wim so that restore will reload the registers */ 145 env->wim = 1 << cwp1; 146 #endif 147 #if defined(DEBUG_WIN) 148 printf("flush_windows: nb=%d\n", offset - 1); 149 #endif 150 } 151 152 static void next_instruction(CPUSPARCState *env) 153 { 154 env->pc = env->npc; 155 env->npc = env->npc + 4; 156 } 157 158 static uint32_t do_getcc(CPUSPARCState *env) 159 { 160 #ifdef TARGET_SPARC64 161 return cpu_get_ccr(env) & 0xf; 162 #else 163 return extract32(cpu_get_psr(env), 20, 4); 164 #endif 165 } 166 167 static void do_setcc(CPUSPARCState *env, uint32_t icc) 168 { 169 #ifdef TARGET_SPARC64 170 cpu_put_ccr(env, (cpu_get_ccr(env) & 0xf0) | (icc & 0xf)); 171 #else 172 cpu_put_psr(env, deposit32(cpu_get_psr(env), 20, 4, icc)); 173 #endif 174 } 175 176 static uint32_t do_getpsr(CPUSPARCState *env) 177 { 178 #ifdef TARGET_SPARC64 179 const uint64_t TSTATE_CWP = 0x1f; 180 const uint64_t TSTATE_ICC = 0xfull << 32; 181 const uint64_t TSTATE_XCC = 0xfull << 36; 182 const uint32_t PSR_S = 0x00000080u; 183 const uint32_t PSR_V8PLUS = 0xff000000u; 184 uint64_t tstate = sparc64_tstate(env); 185 186 /* See <asm/psrcompat.h>, tstate_to_psr. */ 187 return ((tstate & TSTATE_CWP) | 188 PSR_S | 189 ((tstate & TSTATE_ICC) >> 12) | 190 ((tstate & TSTATE_XCC) >> 20) | 191 PSR_V8PLUS); 192 #else 193 return (cpu_get_psr(env) & (PSR_ICC | PSR_CWP)) | PSR_S; 194 #endif 195 } 196 197 /* Avoid ifdefs below for the abi32 and abi64 paths. */ 198 #ifdef TARGET_ABI32 199 #define TARGET_TT_SYSCALL (TT_TRAP + 0x10) /* t_linux */ 200 #else 201 #define TARGET_TT_SYSCALL (TT_TRAP + 0x6d) /* tl0_linux64 */ 202 #endif 203 204 /* Avoid ifdefs below for the v9 and pre-v9 hw traps. */ 205 #ifdef TARGET_SPARC64 206 #define TARGET_TT_SPILL TT_SPILL 207 #define TARGET_TT_FILL TT_FILL 208 #else 209 #define TARGET_TT_SPILL TT_WIN_OVF 210 #define TARGET_TT_FILL TT_WIN_UNF 211 #endif 212 213 void cpu_loop (CPUSPARCState *env) 214 { 215 CPUState *cs = env_cpu(env); 216 int trapnr; 217 abi_long ret; 218 219 while (1) { 220 cpu_exec_start(cs); 221 trapnr = cpu_exec(cs); 222 cpu_exec_end(cs); 223 process_queued_cpu_work(cs); 224 225 switch (trapnr) { 226 case TARGET_TT_SYSCALL: 227 ret = do_syscall (env, env->gregs[1], 228 env->regwptr[0], env->regwptr[1], 229 env->regwptr[2], env->regwptr[3], 230 env->regwptr[4], env->regwptr[5], 231 0, 0); 232 if (ret == -QEMU_ERESTARTSYS || ret == -QEMU_ESIGRETURN) { 233 break; 234 } 235 if ((abi_ulong)ret >= (abi_ulong)(-515)) { 236 set_syscall_C(env, 1); 237 ret = -ret; 238 } else { 239 set_syscall_C(env, 0); 240 } 241 env->regwptr[0] = ret; 242 /* next instruction */ 243 env->pc = env->npc; 244 env->npc = env->npc + 4; 245 break; 246 247 case TT_TRAP + 0x01: /* breakpoint */ 248 case EXCP_DEBUG: 249 force_sig_fault(TARGET_SIGTRAP, TARGET_TRAP_BRKPT, env->pc); 250 break; 251 252 case TT_TRAP + 0x02: /* div0 */ 253 case TT_DIV_ZERO: 254 force_sig_fault(TARGET_SIGFPE, TARGET_FPE_INTDIV, env->pc); 255 break; 256 257 case TT_TRAP + 0x03: /* flush windows */ 258 flush_windows(env); 259 next_instruction(env); 260 break; 261 262 case TT_TRAP + 0x20: /* getcc */ 263 env->gregs[1] = do_getcc(env); 264 next_instruction(env); 265 break; 266 case TT_TRAP + 0x21: /* setcc */ 267 do_setcc(env, env->gregs[1]); 268 next_instruction(env); 269 break; 270 case TT_TRAP + 0x22: /* getpsr */ 271 env->gregs[1] = do_getpsr(env); 272 next_instruction(env); 273 break; 274 275 #ifdef TARGET_SPARC64 276 case TT_TRAP + 0x6e: 277 flush_windows(env); 278 sparc64_get_context(env); 279 break; 280 case TT_TRAP + 0x6f: 281 flush_windows(env); 282 sparc64_set_context(env); 283 break; 284 #endif 285 286 case TARGET_TT_SPILL: /* window overflow */ 287 save_window(env); 288 break; 289 case TARGET_TT_FILL: /* window underflow */ 290 restore_window(env); 291 break; 292 293 case TT_FP_EXCP: 294 { 295 int code = TARGET_FPE_FLTUNK; 296 target_ulong fsr = env->fsr; 297 298 if ((fsr & FSR_FTT_MASK) == FSR_FTT_IEEE_EXCP) { 299 if (fsr & FSR_NVC) { 300 code = TARGET_FPE_FLTINV; 301 } else if (fsr & FSR_OFC) { 302 code = TARGET_FPE_FLTOVF; 303 } else if (fsr & FSR_UFC) { 304 code = TARGET_FPE_FLTUND; 305 } else if (fsr & FSR_DZC) { 306 code = TARGET_FPE_FLTDIV; 307 } else if (fsr & FSR_NXC) { 308 code = TARGET_FPE_FLTRES; 309 } 310 } 311 force_sig_fault(TARGET_SIGFPE, code, env->pc); 312 } 313 break; 314 315 case EXCP_INTERRUPT: 316 /* just indicate that signals should be handled asap */ 317 break; 318 case TT_ILL_INSN: 319 force_sig_fault(TARGET_SIGILL, TARGET_ILL_ILLOPC, env->pc); 320 break; 321 case TT_PRIV_INSN: 322 force_sig_fault(TARGET_SIGILL, TARGET_ILL_PRVOPC, env->pc); 323 break; 324 case TT_TOVF: 325 force_sig_fault(TARGET_SIGEMT, TARGET_EMT_TAGOVF, env->pc); 326 break; 327 #ifdef TARGET_SPARC64 328 case TT_PRIV_ACT: 329 /* Note do_privact defers to do_privop. */ 330 force_sig_fault(TARGET_SIGILL, TARGET_ILL_PRVOPC, env->pc); 331 break; 332 #else 333 case TT_NCP_INSN: 334 force_sig_fault(TARGET_SIGILL, TARGET_ILL_COPROC, env->pc); 335 break; 336 case TT_UNIMP_FLUSH: 337 next_instruction(env); 338 break; 339 #endif 340 case EXCP_ATOMIC: 341 cpu_exec_step_atomic(cs); 342 break; 343 default: 344 /* 345 * Most software trap numbers vector to BAD_TRAP. 346 * Handle anything not explicitly matched above. 347 */ 348 if (trapnr >= TT_TRAP && trapnr <= TT_TRAP + 0x7f) { 349 force_sig_fault(TARGET_SIGILL, ILL_ILLTRP, env->pc); 350 break; 351 } 352 fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr); 353 cpu_dump_state(cs, stderr, 0); 354 exit(EXIT_FAILURE); 355 } 356 process_pending_signals (env); 357 } 358 } 359 360 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs) 361 { 362 int i; 363 env->pc = regs->pc; 364 env->npc = regs->npc; 365 env->y = regs->y; 366 for(i = 0; i < 8; i++) 367 env->gregs[i] = regs->u_regs[i]; 368 for(i = 0; i < 8; i++) 369 env->regwptr[i] = regs->u_regs[i + 8]; 370 } 371