tmp105: Correct handling of temperature limit checks
[qemu.git] / linux-user / sparc / cpu_loop.c
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 }