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-common.h" 22 #include "qemu.h" 23 #include "cpu_loop-common.h" 24 25 #define SPARC64_STACK_BIAS 2047 26 27 //#define DEBUG_WIN 28 29 /* WARNING: dealing with register windows _is_ complicated. More info 30 can be found at http://www.sics.se/~psm/sparcstack.html */ 31 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) 32 { 33 index = (index + cwp * 16) % (16 * env->nwindows); 34 /* wrap handling : if cwp is on the last window, then we use the 35 registers 'after' the end */ 36 if (index < 8 && env->cwp == env->nwindows - 1) 37 index += 16 * env->nwindows; 38 return index; 39 } 40 41 /* save the register window 'cwp1' */ 42 static inline void save_window_offset(CPUSPARCState *env, int cwp1) 43 { 44 unsigned int i; 45 abi_ulong sp_ptr; 46 47 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 48 #ifdef TARGET_SPARC64 49 if (sp_ptr & 3) 50 sp_ptr += SPARC64_STACK_BIAS; 51 #endif 52 #if defined(DEBUG_WIN) 53 printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n", 54 sp_ptr, cwp1); 55 #endif 56 for(i = 0; i < 16; i++) { 57 /* FIXME - what to do if put_user() fails? */ 58 put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 59 sp_ptr += sizeof(abi_ulong); 60 } 61 } 62 63 static void save_window(CPUSPARCState *env) 64 { 65 #ifndef TARGET_SPARC64 66 unsigned int new_wim; 67 new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) & 68 ((1LL << env->nwindows) - 1); 69 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 70 env->wim = new_wim; 71 #else 72 /* 73 * cansave is zero if the spill trap handler is triggered by `save` and 74 * nonzero if triggered by a `flushw` 75 */ 76 save_window_offset(env, cpu_cwp_dec(env, env->cwp - env->cansave - 2)); 77 env->cansave++; 78 env->canrestore--; 79 #endif 80 } 81 82 static void restore_window(CPUSPARCState *env) 83 { 84 #ifndef TARGET_SPARC64 85 unsigned int new_wim; 86 #endif 87 unsigned int i, cwp1; 88 abi_ulong sp_ptr; 89 90 #ifndef TARGET_SPARC64 91 new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) & 92 ((1LL << env->nwindows) - 1); 93 #endif 94 95 /* restore the invalid window */ 96 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 97 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 98 #ifdef TARGET_SPARC64 99 if (sp_ptr & 3) 100 sp_ptr += SPARC64_STACK_BIAS; 101 #endif 102 #if defined(DEBUG_WIN) 103 printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n", 104 sp_ptr, cwp1); 105 #endif 106 for(i = 0; i < 16; i++) { 107 /* FIXME - what to do if get_user() fails? */ 108 get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 109 sp_ptr += sizeof(abi_ulong); 110 } 111 #ifdef TARGET_SPARC64 112 env->canrestore++; 113 if (env->cleanwin < env->nwindows - 1) 114 env->cleanwin++; 115 env->cansave--; 116 #else 117 env->wim = new_wim; 118 #endif 119 } 120 121 static void flush_windows(CPUSPARCState *env) 122 { 123 int offset, cwp1; 124 125 offset = 1; 126 for(;;) { 127 /* if restore would invoke restore_window(), then we can stop */ 128 cwp1 = cpu_cwp_inc(env, env->cwp + offset); 129 #ifndef TARGET_SPARC64 130 if (env->wim & (1 << cwp1)) 131 break; 132 #else 133 if (env->canrestore == 0) 134 break; 135 env->cansave++; 136 env->canrestore--; 137 #endif 138 save_window_offset(env, cwp1); 139 offset++; 140 } 141 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 142 #ifndef TARGET_SPARC64 143 /* set wim so that restore will reload the registers */ 144 env->wim = 1 << cwp1; 145 #endif 146 #if defined(DEBUG_WIN) 147 printf("flush_windows: nb=%d\n", offset - 1); 148 #endif 149 } 150 151 void cpu_loop (CPUSPARCState *env) 152 { 153 CPUState *cs = env_cpu(env); 154 int trapnr; 155 abi_long ret; 156 target_siginfo_t info; 157 158 while (1) { 159 cpu_exec_start(cs); 160 trapnr = cpu_exec(cs); 161 cpu_exec_end(cs); 162 process_queued_cpu_work(cs); 163 164 /* Compute PSR before exposing state. */ 165 if (env->cc_op != CC_OP_FLAGS) { 166 cpu_get_psr(env); 167 } 168 169 switch (trapnr) { 170 #ifndef TARGET_SPARC64 171 case 0x88: 172 case 0x90: 173 #else 174 case 0x110: 175 case 0x16d: 176 #endif 177 ret = do_syscall (env, env->gregs[1], 178 env->regwptr[0], env->regwptr[1], 179 env->regwptr[2], env->regwptr[3], 180 env->regwptr[4], env->regwptr[5], 181 0, 0); 182 if (ret == -TARGET_ERESTARTSYS || ret == -TARGET_QEMU_ESIGRETURN) { 183 break; 184 } 185 if ((abi_ulong)ret >= (abi_ulong)(-515)) { 186 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 187 env->xcc |= PSR_CARRY; 188 #else 189 env->psr |= PSR_CARRY; 190 #endif 191 ret = -ret; 192 } else { 193 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 194 env->xcc &= ~PSR_CARRY; 195 #else 196 env->psr &= ~PSR_CARRY; 197 #endif 198 } 199 env->regwptr[0] = ret; 200 /* next instruction */ 201 env->pc = env->npc; 202 env->npc = env->npc + 4; 203 break; 204 case 0x83: /* flush windows */ 205 #ifdef TARGET_ABI32 206 case 0x103: 207 #endif 208 flush_windows(env); 209 /* next instruction */ 210 env->pc = env->npc; 211 env->npc = env->npc + 4; 212 break; 213 #ifndef TARGET_SPARC64 214 case TT_WIN_OVF: /* window overflow */ 215 save_window(env); 216 break; 217 case TT_WIN_UNF: /* window underflow */ 218 restore_window(env); 219 break; 220 case TT_TFAULT: 221 case TT_DFAULT: 222 { 223 info.si_signo = TARGET_SIGSEGV; 224 info.si_errno = 0; 225 /* XXX: check env->error_code */ 226 info.si_code = TARGET_SEGV_MAPERR; 227 info._sifields._sigfault._addr = env->mmuregs[4]; 228 queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info); 229 } 230 break; 231 #else 232 case TT_SPILL: /* window overflow */ 233 save_window(env); 234 break; 235 case TT_FILL: /* window underflow */ 236 restore_window(env); 237 break; 238 case TT_TFAULT: 239 case TT_DFAULT: 240 { 241 info.si_signo = TARGET_SIGSEGV; 242 info.si_errno = 0; 243 /* XXX: check env->error_code */ 244 info.si_code = TARGET_SEGV_MAPERR; 245 if (trapnr == TT_DFAULT) 246 info._sifields._sigfault._addr = env->dmmu.mmuregs[4]; 247 else 248 info._sifields._sigfault._addr = cpu_tsptr(env)->tpc; 249 queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info); 250 } 251 break; 252 #ifndef TARGET_ABI32 253 case 0x16e: 254 flush_windows(env); 255 sparc64_get_context(env); 256 break; 257 case 0x16f: 258 flush_windows(env); 259 sparc64_set_context(env); 260 break; 261 #endif 262 #endif 263 case EXCP_INTERRUPT: 264 /* just indicate that signals should be handled asap */ 265 break; 266 case TT_ILL_INSN: 267 { 268 info.si_signo = TARGET_SIGILL; 269 info.si_errno = 0; 270 info.si_code = TARGET_ILL_ILLOPC; 271 info._sifields._sigfault._addr = env->pc; 272 queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info); 273 } 274 break; 275 case EXCP_DEBUG: 276 info.si_signo = TARGET_SIGTRAP; 277 info.si_errno = 0; 278 info.si_code = TARGET_TRAP_BRKPT; 279 queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info); 280 break; 281 case EXCP_ATOMIC: 282 cpu_exec_step_atomic(cs); 283 break; 284 default: 285 fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr); 286 cpu_dump_state(cs, stderr, 0); 287 exit(EXIT_FAILURE); 288 } 289 process_pending_signals (env); 290 } 291 } 292 293 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs) 294 { 295 int i; 296 env->pc = regs->pc; 297 env->npc = regs->npc; 298 env->y = regs->y; 299 for(i = 0; i < 8; i++) 300 env->gregs[i] = regs->u_regs[i]; 301 for(i = 0; i < 8; i++) 302 env->regwptr[i] = regs->u_regs[i + 8]; 303 } 304