]> git.proxmox.com Git - mirror_qemu.git/blob - target-mips/op_helper.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
target-mips: use softfloat constants when possible
[mirror_qemu.git] / target-mips / op_helper.c
1 /*
2 * MIPS emulation helpers for qemu.
3 *
4 * Copyright (c) 2004-2005 Jocelyn Mayer
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include <stdlib.h>
20 #include "cpu.h"
21 #include "host-utils.h"
22
23 #include "helper.h"
24
25 #if !defined(CONFIG_USER_ONLY)
26 #include "softmmu_exec.h"
27 #endif /* !defined(CONFIG_USER_ONLY) */
28
29 #ifndef CONFIG_USER_ONLY
30 static inline void cpu_mips_tlb_flush (CPUMIPSState *env, int flush_global);
31 #endif
32
33 /*****************************************************************************/
34 /* Exceptions processing helpers */
35
36 void helper_raise_exception_err(CPUMIPSState *env, uint32_t exception,
37 int error_code)
38 {
39 #if 1
40 if (exception < 0x100)
41 qemu_log("%s: %d %d\n", __func__, exception, error_code);
42 #endif
43 env->exception_index = exception;
44 env->error_code = error_code;
45 cpu_loop_exit(env);
46 }
47
48 void helper_raise_exception(CPUMIPSState *env, uint32_t exception)
49 {
50 helper_raise_exception_err(env, exception, 0);
51 }
52
53 #if !defined(CONFIG_USER_ONLY)
54 static void do_restore_state(CPUMIPSState *env, uintptr_t pc)
55 {
56 TranslationBlock *tb;
57
58 tb = tb_find_pc (pc);
59 if (tb) {
60 cpu_restore_state(tb, env, pc);
61 }
62 }
63 #endif
64
65 #if defined(CONFIG_USER_ONLY)
66 #define HELPER_LD(name, insn, type) \
67 static inline type do_##name(CPUMIPSState *env, target_ulong addr, \
68 int mem_idx) \
69 { \
70 return (type) insn##_raw(addr); \
71 }
72 #else
73 #define HELPER_LD(name, insn, type) \
74 static inline type do_##name(CPUMIPSState *env, target_ulong addr, \
75 int mem_idx) \
76 { \
77 switch (mem_idx) \
78 { \
79 case 0: return (type) cpu_##insn##_kernel(env, addr); break; \
80 case 1: return (type) cpu_##insn##_super(env, addr); break; \
81 default: \
82 case 2: return (type) cpu_##insn##_user(env, addr); break; \
83 } \
84 }
85 #endif
86 HELPER_LD(lbu, ldub, uint8_t)
87 HELPER_LD(lw, ldl, int32_t)
88 #ifdef TARGET_MIPS64
89 HELPER_LD(ld, ldq, int64_t)
90 #endif
91 #undef HELPER_LD
92
93 #if defined(CONFIG_USER_ONLY)
94 #define HELPER_ST(name, insn, type) \
95 static inline void do_##name(CPUMIPSState *env, target_ulong addr, \
96 type val, int mem_idx) \
97 { \
98 insn##_raw(addr, val); \
99 }
100 #else
101 #define HELPER_ST(name, insn, type) \
102 static inline void do_##name(CPUMIPSState *env, target_ulong addr, \
103 type val, int mem_idx) \
104 { \
105 switch (mem_idx) \
106 { \
107 case 0: cpu_##insn##_kernel(env, addr, val); break; \
108 case 1: cpu_##insn##_super(env, addr, val); break; \
109 default: \
110 case 2: cpu_##insn##_user(env, addr, val); break; \
111 } \
112 }
113 #endif
114 HELPER_ST(sb, stb, uint8_t)
115 HELPER_ST(sw, stl, uint32_t)
116 #ifdef TARGET_MIPS64
117 HELPER_ST(sd, stq, uint64_t)
118 #endif
119 #undef HELPER_ST
120
121 target_ulong helper_clo (target_ulong arg1)
122 {
123 return clo32(arg1);
124 }
125
126 target_ulong helper_clz (target_ulong arg1)
127 {
128 return clz32(arg1);
129 }
130
131 #if defined(TARGET_MIPS64)
132 target_ulong helper_dclo (target_ulong arg1)
133 {
134 return clo64(arg1);
135 }
136
137 target_ulong helper_dclz (target_ulong arg1)
138 {
139 return clz64(arg1);
140 }
141 #endif /* TARGET_MIPS64 */
142
143 /* 64 bits arithmetic for 32 bits hosts */
144 static inline uint64_t get_HILO(CPUMIPSState *env)
145 {
146 return ((uint64_t)(env->active_tc.HI[0]) << 32) | (uint32_t)env->active_tc.LO[0];
147 }
148
149 static inline target_ulong set_HIT0_LO(CPUMIPSState *env, uint64_t HILO)
150 {
151 target_ulong tmp;
152 env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
153 tmp = env->active_tc.HI[0] = (int32_t)(HILO >> 32);
154 return tmp;
155 }
156
157 static inline target_ulong set_HI_LOT0(CPUMIPSState *env, uint64_t HILO)
158 {
159 target_ulong tmp = env->active_tc.LO[0] = (int32_t)(HILO & 0xFFFFFFFF);
160 env->active_tc.HI[0] = (int32_t)(HILO >> 32);
161 return tmp;
162 }
163
164 /* Multiplication variants of the vr54xx. */
165 target_ulong helper_muls(CPUMIPSState *env, target_ulong arg1,
166 target_ulong arg2)
167 {
168 return set_HI_LOT0(env, 0 - ((int64_t)(int32_t)arg1 *
169 (int64_t)(int32_t)arg2));
170 }
171
172 target_ulong helper_mulsu(CPUMIPSState *env, target_ulong arg1,
173 target_ulong arg2)
174 {
175 return set_HI_LOT0(env, 0 - (uint64_t)(uint32_t)arg1 *
176 (uint64_t)(uint32_t)arg2);
177 }
178
179 target_ulong helper_macc(CPUMIPSState *env, target_ulong arg1,
180 target_ulong arg2)
181 {
182 return set_HI_LOT0(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
183 (int64_t)(int32_t)arg2);
184 }
185
186 target_ulong helper_macchi(CPUMIPSState *env, target_ulong arg1,
187 target_ulong arg2)
188 {
189 return set_HIT0_LO(env, (int64_t)get_HILO(env) + (int64_t)(int32_t)arg1 *
190 (int64_t)(int32_t)arg2);
191 }
192
193 target_ulong helper_maccu(CPUMIPSState *env, target_ulong arg1,
194 target_ulong arg2)
195 {
196 return set_HI_LOT0(env, (uint64_t)get_HILO(env) +
197 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
198 }
199
200 target_ulong helper_macchiu(CPUMIPSState *env, target_ulong arg1,
201 target_ulong arg2)
202 {
203 return set_HIT0_LO(env, (uint64_t)get_HILO(env) +
204 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
205 }
206
207 target_ulong helper_msac(CPUMIPSState *env, target_ulong arg1,
208 target_ulong arg2)
209 {
210 return set_HI_LOT0(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
211 (int64_t)(int32_t)arg2);
212 }
213
214 target_ulong helper_msachi(CPUMIPSState *env, target_ulong arg1,
215 target_ulong arg2)
216 {
217 return set_HIT0_LO(env, (int64_t)get_HILO(env) - (int64_t)(int32_t)arg1 *
218 (int64_t)(int32_t)arg2);
219 }
220
221 target_ulong helper_msacu(CPUMIPSState *env, target_ulong arg1,
222 target_ulong arg2)
223 {
224 return set_HI_LOT0(env, (uint64_t)get_HILO(env) -
225 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
226 }
227
228 target_ulong helper_msachiu(CPUMIPSState *env, target_ulong arg1,
229 target_ulong arg2)
230 {
231 return set_HIT0_LO(env, (uint64_t)get_HILO(env) -
232 (uint64_t)(uint32_t)arg1 * (uint64_t)(uint32_t)arg2);
233 }
234
235 target_ulong helper_mulhi(CPUMIPSState *env, target_ulong arg1,
236 target_ulong arg2)
237 {
238 return set_HIT0_LO(env, (int64_t)(int32_t)arg1 * (int64_t)(int32_t)arg2);
239 }
240
241 target_ulong helper_mulhiu(CPUMIPSState *env, target_ulong arg1,
242 target_ulong arg2)
243 {
244 return set_HIT0_LO(env, (uint64_t)(uint32_t)arg1 *
245 (uint64_t)(uint32_t)arg2);
246 }
247
248 target_ulong helper_mulshi(CPUMIPSState *env, target_ulong arg1,
249 target_ulong arg2)
250 {
251 return set_HIT0_LO(env, 0 - (int64_t)(int32_t)arg1 *
252 (int64_t)(int32_t)arg2);
253 }
254
255 target_ulong helper_mulshiu(CPUMIPSState *env, target_ulong arg1,
256 target_ulong arg2)
257 {
258 return set_HIT0_LO(env, 0 - (uint64_t)(uint32_t)arg1 *
259 (uint64_t)(uint32_t)arg2);
260 }
261
262 #ifdef TARGET_MIPS64
263 void helper_dmult(CPUMIPSState *env, target_ulong arg1, target_ulong arg2)
264 {
265 muls64(&(env->active_tc.LO[0]), &(env->active_tc.HI[0]), arg1, arg2);
266 }
267
268 void helper_dmultu(CPUMIPSState *env, target_ulong arg1, target_ulong arg2)
269 {
270 mulu64(&(env->active_tc.LO[0]), &(env->active_tc.HI[0]), arg1, arg2);
271 }
272 #endif
273
274 #ifndef CONFIG_USER_ONLY
275
276 static inline hwaddr do_translate_address(CPUMIPSState *env,
277 target_ulong address,
278 int rw)
279 {
280 hwaddr lladdr;
281
282 lladdr = cpu_mips_translate_address(env, address, rw);
283
284 if (lladdr == -1LL) {
285 cpu_loop_exit(env);
286 } else {
287 return lladdr;
288 }
289 }
290
291 #define HELPER_LD_ATOMIC(name, insn) \
292 target_ulong helper_##name(CPUMIPSState *env, target_ulong arg, int mem_idx) \
293 { \
294 env->lladdr = do_translate_address(env, arg, 0); \
295 env->llval = do_##insn(env, arg, mem_idx); \
296 return env->llval; \
297 }
298 HELPER_LD_ATOMIC(ll, lw)
299 #ifdef TARGET_MIPS64
300 HELPER_LD_ATOMIC(lld, ld)
301 #endif
302 #undef HELPER_LD_ATOMIC
303
304 #define HELPER_ST_ATOMIC(name, ld_insn, st_insn, almask) \
305 target_ulong helper_##name(CPUMIPSState *env, target_ulong arg1, \
306 target_ulong arg2, int mem_idx) \
307 { \
308 target_long tmp; \
309 \
310 if (arg2 & almask) { \
311 env->CP0_BadVAddr = arg2; \
312 helper_raise_exception(env, EXCP_AdES); \
313 } \
314 if (do_translate_address(env, arg2, 1) == env->lladdr) { \
315 tmp = do_##ld_insn(env, arg2, mem_idx); \
316 if (tmp == env->llval) { \
317 do_##st_insn(env, arg2, arg1, mem_idx); \
318 return 1; \
319 } \
320 } \
321 return 0; \
322 }
323 HELPER_ST_ATOMIC(sc, lw, sw, 0x3)
324 #ifdef TARGET_MIPS64
325 HELPER_ST_ATOMIC(scd, ld, sd, 0x7)
326 #endif
327 #undef HELPER_ST_ATOMIC
328 #endif
329
330 #ifdef TARGET_WORDS_BIGENDIAN
331 #define GET_LMASK(v) ((v) & 3)
332 #define GET_OFFSET(addr, offset) (addr + (offset))
333 #else
334 #define GET_LMASK(v) (((v) & 3) ^ 3)
335 #define GET_OFFSET(addr, offset) (addr - (offset))
336 #endif
337
338 target_ulong helper_lwl(CPUMIPSState *env, target_ulong arg1,
339 target_ulong arg2, int mem_idx)
340 {
341 target_ulong tmp;
342
343 tmp = do_lbu(env, arg2, mem_idx);
344 arg1 = (arg1 & 0x00FFFFFF) | (tmp << 24);
345
346 if (GET_LMASK(arg2) <= 2) {
347 tmp = do_lbu(env, GET_OFFSET(arg2, 1), mem_idx);
348 arg1 = (arg1 & 0xFF00FFFF) | (tmp << 16);
349 }
350
351 if (GET_LMASK(arg2) <= 1) {
352 tmp = do_lbu(env, GET_OFFSET(arg2, 2), mem_idx);
353 arg1 = (arg1 & 0xFFFF00FF) | (tmp << 8);
354 }
355
356 if (GET_LMASK(arg2) == 0) {
357 tmp = do_lbu(env, GET_OFFSET(arg2, 3), mem_idx);
358 arg1 = (arg1 & 0xFFFFFF00) | tmp;
359 }
360 return (int32_t)arg1;
361 }
362
363 target_ulong helper_lwr(CPUMIPSState *env, target_ulong arg1,
364 target_ulong arg2, int mem_idx)
365 {
366 target_ulong tmp;
367
368 tmp = do_lbu(env, arg2, mem_idx);
369 arg1 = (arg1 & 0xFFFFFF00) | tmp;
370
371 if (GET_LMASK(arg2) >= 1) {
372 tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx);
373 arg1 = (arg1 & 0xFFFF00FF) | (tmp << 8);
374 }
375
376 if (GET_LMASK(arg2) >= 2) {
377 tmp = do_lbu(env, GET_OFFSET(arg2, -2), mem_idx);
378 arg1 = (arg1 & 0xFF00FFFF) | (tmp << 16);
379 }
380
381 if (GET_LMASK(arg2) == 3) {
382 tmp = do_lbu(env, GET_OFFSET(arg2, -3), mem_idx);
383 arg1 = (arg1 & 0x00FFFFFF) | (tmp << 24);
384 }
385 return (int32_t)arg1;
386 }
387
388 void helper_swl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
389 int mem_idx)
390 {
391 do_sb(env, arg2, (uint8_t)(arg1 >> 24), mem_idx);
392
393 if (GET_LMASK(arg2) <= 2)
394 do_sb(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 16), mem_idx);
395
396 if (GET_LMASK(arg2) <= 1)
397 do_sb(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 8), mem_idx);
398
399 if (GET_LMASK(arg2) == 0)
400 do_sb(env, GET_OFFSET(arg2, 3), (uint8_t)arg1, mem_idx);
401 }
402
403 void helper_swr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
404 int mem_idx)
405 {
406 do_sb(env, arg2, (uint8_t)arg1, mem_idx);
407
408 if (GET_LMASK(arg2) >= 1)
409 do_sb(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8), mem_idx);
410
411 if (GET_LMASK(arg2) >= 2)
412 do_sb(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16), mem_idx);
413
414 if (GET_LMASK(arg2) == 3)
415 do_sb(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24), mem_idx);
416 }
417
418 #if defined(TARGET_MIPS64)
419 /* "half" load and stores. We must do the memory access inline,
420 or fault handling won't work. */
421
422 #ifdef TARGET_WORDS_BIGENDIAN
423 #define GET_LMASK64(v) ((v) & 7)
424 #else
425 #define GET_LMASK64(v) (((v) & 7) ^ 7)
426 #endif
427
428 target_ulong helper_ldl(CPUMIPSState *env, target_ulong arg1,
429 target_ulong arg2, int mem_idx)
430 {
431 uint64_t tmp;
432
433 tmp = do_lbu(env, arg2, mem_idx);
434 arg1 = (arg1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56);
435
436 if (GET_LMASK64(arg2) <= 6) {
437 tmp = do_lbu(env, GET_OFFSET(arg2, 1), mem_idx);
438 arg1 = (arg1 & 0xFF00FFFFFFFFFFFFULL) | (tmp << 48);
439 }
440
441 if (GET_LMASK64(arg2) <= 5) {
442 tmp = do_lbu(env, GET_OFFSET(arg2, 2), mem_idx);
443 arg1 = (arg1 & 0xFFFF00FFFFFFFFFFULL) | (tmp << 40);
444 }
445
446 if (GET_LMASK64(arg2) <= 4) {
447 tmp = do_lbu(env, GET_OFFSET(arg2, 3), mem_idx);
448 arg1 = (arg1 & 0xFFFFFF00FFFFFFFFULL) | (tmp << 32);
449 }
450
451 if (GET_LMASK64(arg2) <= 3) {
452 tmp = do_lbu(env, GET_OFFSET(arg2, 4), mem_idx);
453 arg1 = (arg1 & 0xFFFFFFFF00FFFFFFULL) | (tmp << 24);
454 }
455
456 if (GET_LMASK64(arg2) <= 2) {
457 tmp = do_lbu(env, GET_OFFSET(arg2, 5), mem_idx);
458 arg1 = (arg1 & 0xFFFFFFFFFF00FFFFULL) | (tmp << 16);
459 }
460
461 if (GET_LMASK64(arg2) <= 1) {
462 tmp = do_lbu(env, GET_OFFSET(arg2, 6), mem_idx);
463 arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp << 8);
464 }
465
466 if (GET_LMASK64(arg2) == 0) {
467 tmp = do_lbu(env, GET_OFFSET(arg2, 7), mem_idx);
468 arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp;
469 }
470
471 return arg1;
472 }
473
474 target_ulong helper_ldr(CPUMIPSState *env, target_ulong arg1,
475 target_ulong arg2, int mem_idx)
476 {
477 uint64_t tmp;
478
479 tmp = do_lbu(env, arg2, mem_idx);
480 arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp;
481
482 if (GET_LMASK64(arg2) >= 1) {
483 tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx);
484 arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp << 8);
485 }
486
487 if (GET_LMASK64(arg2) >= 2) {
488 tmp = do_lbu(env, GET_OFFSET(arg2, -2), mem_idx);
489 arg1 = (arg1 & 0xFFFFFFFFFF00FFFFULL) | (tmp << 16);
490 }
491
492 if (GET_LMASK64(arg2) >= 3) {
493 tmp = do_lbu(env, GET_OFFSET(arg2, -3), mem_idx);
494 arg1 = (arg1 & 0xFFFFFFFF00FFFFFFULL) | (tmp << 24);
495 }
496
497 if (GET_LMASK64(arg2) >= 4) {
498 tmp = do_lbu(env, GET_OFFSET(arg2, -4), mem_idx);
499 arg1 = (arg1 & 0xFFFFFF00FFFFFFFFULL) | (tmp << 32);
500 }
501
502 if (GET_LMASK64(arg2) >= 5) {
503 tmp = do_lbu(env, GET_OFFSET(arg2, -5), mem_idx);
504 arg1 = (arg1 & 0xFFFF00FFFFFFFFFFULL) | (tmp << 40);
505 }
506
507 if (GET_LMASK64(arg2) >= 6) {
508 tmp = do_lbu(env, GET_OFFSET(arg2, -6), mem_idx);
509 arg1 = (arg1 & 0xFF00FFFFFFFFFFFFULL) | (tmp << 48);
510 }
511
512 if (GET_LMASK64(arg2) == 7) {
513 tmp = do_lbu(env, GET_OFFSET(arg2, -7), mem_idx);
514 arg1 = (arg1 & 0x00FFFFFFFFFFFFFFULL) | (tmp << 56);
515 }
516
517 return arg1;
518 }
519
520 void helper_sdl(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
521 int mem_idx)
522 {
523 do_sb(env, arg2, (uint8_t)(arg1 >> 56), mem_idx);
524
525 if (GET_LMASK64(arg2) <= 6)
526 do_sb(env, GET_OFFSET(arg2, 1), (uint8_t)(arg1 >> 48), mem_idx);
527
528 if (GET_LMASK64(arg2) <= 5)
529 do_sb(env, GET_OFFSET(arg2, 2), (uint8_t)(arg1 >> 40), mem_idx);
530
531 if (GET_LMASK64(arg2) <= 4)
532 do_sb(env, GET_OFFSET(arg2, 3), (uint8_t)(arg1 >> 32), mem_idx);
533
534 if (GET_LMASK64(arg2) <= 3)
535 do_sb(env, GET_OFFSET(arg2, 4), (uint8_t)(arg1 >> 24), mem_idx);
536
537 if (GET_LMASK64(arg2) <= 2)
538 do_sb(env, GET_OFFSET(arg2, 5), (uint8_t)(arg1 >> 16), mem_idx);
539
540 if (GET_LMASK64(arg2) <= 1)
541 do_sb(env, GET_OFFSET(arg2, 6), (uint8_t)(arg1 >> 8), mem_idx);
542
543 if (GET_LMASK64(arg2) <= 0)
544 do_sb(env, GET_OFFSET(arg2, 7), (uint8_t)arg1, mem_idx);
545 }
546
547 void helper_sdr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2,
548 int mem_idx)
549 {
550 do_sb(env, arg2, (uint8_t)arg1, mem_idx);
551
552 if (GET_LMASK64(arg2) >= 1)
553 do_sb(env, GET_OFFSET(arg2, -1), (uint8_t)(arg1 >> 8), mem_idx);
554
555 if (GET_LMASK64(arg2) >= 2)
556 do_sb(env, GET_OFFSET(arg2, -2), (uint8_t)(arg1 >> 16), mem_idx);
557
558 if (GET_LMASK64(arg2) >= 3)
559 do_sb(env, GET_OFFSET(arg2, -3), (uint8_t)(arg1 >> 24), mem_idx);
560
561 if (GET_LMASK64(arg2) >= 4)
562 do_sb(env, GET_OFFSET(arg2, -4), (uint8_t)(arg1 >> 32), mem_idx);
563
564 if (GET_LMASK64(arg2) >= 5)
565 do_sb(env, GET_OFFSET(arg2, -5), (uint8_t)(arg1 >> 40), mem_idx);
566
567 if (GET_LMASK64(arg2) >= 6)
568 do_sb(env, GET_OFFSET(arg2, -6), (uint8_t)(arg1 >> 48), mem_idx);
569
570 if (GET_LMASK64(arg2) == 7)
571 do_sb(env, GET_OFFSET(arg2, -7), (uint8_t)(arg1 >> 56), mem_idx);
572 }
573 #endif /* TARGET_MIPS64 */
574
575 static const int multiple_regs[] = { 16, 17, 18, 19, 20, 21, 22, 23, 30 };
576
577 void helper_lwm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
578 uint32_t mem_idx)
579 {
580 target_ulong base_reglist = reglist & 0xf;
581 target_ulong do_r31 = reglist & 0x10;
582 #ifdef CONFIG_USER_ONLY
583 #undef ldfun
584 #define ldfun(env, addr) ldl_raw(addr)
585 #else
586 uint32_t (*ldfun)(CPUMIPSState *env, target_ulong);
587
588 switch (mem_idx)
589 {
590 case 0: ldfun = cpu_ldl_kernel; break;
591 case 1: ldfun = cpu_ldl_super; break;
592 default:
593 case 2: ldfun = cpu_ldl_user; break;
594 }
595 #endif
596
597 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
598 target_ulong i;
599
600 for (i = 0; i < base_reglist; i++) {
601 env->active_tc.gpr[multiple_regs[i]] = (target_long)ldfun(env, addr);
602 addr += 4;
603 }
604 }
605
606 if (do_r31) {
607 env->active_tc.gpr[31] = (target_long)ldfun(env, addr);
608 }
609 }
610
611 void helper_swm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
612 uint32_t mem_idx)
613 {
614 target_ulong base_reglist = reglist & 0xf;
615 target_ulong do_r31 = reglist & 0x10;
616 #ifdef CONFIG_USER_ONLY
617 #undef stfun
618 #define stfun(env, addr, val) stl_raw(addr, val)
619 #else
620 void (*stfun)(CPUMIPSState *env, target_ulong, uint32_t);
621
622 switch (mem_idx)
623 {
624 case 0: stfun = cpu_stl_kernel; break;
625 case 1: stfun = cpu_stl_super; break;
626 default:
627 case 2: stfun = cpu_stl_user; break;
628 }
629 #endif
630
631 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
632 target_ulong i;
633
634 for (i = 0; i < base_reglist; i++) {
635 stfun(env, addr, env->active_tc.gpr[multiple_regs[i]]);
636 addr += 4;
637 }
638 }
639
640 if (do_r31) {
641 stfun(env, addr, env->active_tc.gpr[31]);
642 }
643 }
644
645 #if defined(TARGET_MIPS64)
646 void helper_ldm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
647 uint32_t mem_idx)
648 {
649 target_ulong base_reglist = reglist & 0xf;
650 target_ulong do_r31 = reglist & 0x10;
651 #ifdef CONFIG_USER_ONLY
652 #undef ldfun
653 #define ldfun(env, addr) ldq_raw(addr)
654 #else
655 uint64_t (*ldfun)(CPUMIPSState *env, target_ulong);
656
657 switch (mem_idx)
658 {
659 case 0: ldfun = cpu_ldq_kernel; break;
660 case 1: ldfun = cpu_ldq_super; break;
661 default:
662 case 2: ldfun = cpu_ldq_user; break;
663 }
664 #endif
665
666 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
667 target_ulong i;
668
669 for (i = 0; i < base_reglist; i++) {
670 env->active_tc.gpr[multiple_regs[i]] = ldfun(env, addr);
671 addr += 8;
672 }
673 }
674
675 if (do_r31) {
676 env->active_tc.gpr[31] = ldfun(env, addr);
677 }
678 }
679
680 void helper_sdm(CPUMIPSState *env, target_ulong addr, target_ulong reglist,
681 uint32_t mem_idx)
682 {
683 target_ulong base_reglist = reglist & 0xf;
684 target_ulong do_r31 = reglist & 0x10;
685 #ifdef CONFIG_USER_ONLY
686 #undef stfun
687 #define stfun(env, addr, val) stq_raw(addr, val)
688 #else
689 void (*stfun)(CPUMIPSState *env, target_ulong, uint64_t);
690
691 switch (mem_idx)
692 {
693 case 0: stfun = cpu_stq_kernel; break;
694 case 1: stfun = cpu_stq_super; break;
695 default:
696 case 2: stfun = cpu_stq_user; break;
697 }
698 #endif
699
700 if (base_reglist > 0 && base_reglist <= ARRAY_SIZE (multiple_regs)) {
701 target_ulong i;
702
703 for (i = 0; i < base_reglist; i++) {
704 stfun(env, addr, env->active_tc.gpr[multiple_regs[i]]);
705 addr += 8;
706 }
707 }
708
709 if (do_r31) {
710 stfun(env, addr, env->active_tc.gpr[31]);
711 }
712 }
713 #endif
714
715 #ifndef CONFIG_USER_ONLY
716 /* SMP helpers. */
717 static bool mips_vpe_is_wfi(MIPSCPU *c)
718 {
719 CPUMIPSState *env = &c->env;
720
721 /* If the VPE is halted but otherwise active, it means it's waiting for
722 an interrupt. */
723 return env->halted && mips_vpe_active(env);
724 }
725
726 static inline void mips_vpe_wake(CPUMIPSState *c)
727 {
728 /* Dont set ->halted = 0 directly, let it be done via cpu_has_work
729 because there might be other conditions that state that c should
730 be sleeping. */
731 cpu_interrupt(c, CPU_INTERRUPT_WAKE);
732 }
733
734 static inline void mips_vpe_sleep(MIPSCPU *cpu)
735 {
736 CPUMIPSState *c = &cpu->env;
737
738 /* The VPE was shut off, really go to bed.
739 Reset any old _WAKE requests. */
740 c->halted = 1;
741 cpu_reset_interrupt(c, CPU_INTERRUPT_WAKE);
742 }
743
744 static inline void mips_tc_wake(MIPSCPU *cpu, int tc)
745 {
746 CPUMIPSState *c = &cpu->env;
747
748 /* FIXME: TC reschedule. */
749 if (mips_vpe_active(c) && !mips_vpe_is_wfi(cpu)) {
750 mips_vpe_wake(c);
751 }
752 }
753
754 static inline void mips_tc_sleep(MIPSCPU *cpu, int tc)
755 {
756 CPUMIPSState *c = &cpu->env;
757
758 /* FIXME: TC reschedule. */
759 if (!mips_vpe_active(c)) {
760 mips_vpe_sleep(cpu);
761 }
762 }
763
764 /* tc should point to an int with the value of the global TC index.
765 This function will transform it into a local index within the
766 returned CPUMIPSState.
767
768 FIXME: This code assumes that all VPEs have the same number of TCs,
769 which depends on runtime setup. Can probably be fixed by
770 walking the list of CPUMIPSStates. */
771 static CPUMIPSState *mips_cpu_map_tc(CPUMIPSState *env, int *tc)
772 {
773 CPUMIPSState *other;
774 int vpe_idx, nr_threads = env->nr_threads;
775 int tc_idx = *tc;
776
777 if (!(env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP))) {
778 /* Not allowed to address other CPUs. */
779 *tc = env->current_tc;
780 return env;
781 }
782
783 vpe_idx = tc_idx / nr_threads;
784 *tc = tc_idx % nr_threads;
785 other = qemu_get_cpu(vpe_idx);
786 return other ? other : env;
787 }
788
789 /* The per VPE CP0_Status register shares some fields with the per TC
790 CP0_TCStatus registers. These fields are wired to the same registers,
791 so changes to either of them should be reflected on both registers.
792
793 Also, EntryHi shares the bottom 8 bit ASID with TCStauts.
794
795 These helper call synchronizes the regs for a given cpu. */
796
797 /* Called for updates to CP0_Status. */
798 static void sync_c0_status(CPUMIPSState *env, CPUMIPSState *cpu, int tc)
799 {
800 int32_t tcstatus, *tcst;
801 uint32_t v = cpu->CP0_Status;
802 uint32_t cu, mx, asid, ksu;
803 uint32_t mask = ((1 << CP0TCSt_TCU3)
804 | (1 << CP0TCSt_TCU2)
805 | (1 << CP0TCSt_TCU1)
806 | (1 << CP0TCSt_TCU0)
807 | (1 << CP0TCSt_TMX)
808 | (3 << CP0TCSt_TKSU)
809 | (0xff << CP0TCSt_TASID));
810
811 cu = (v >> CP0St_CU0) & 0xf;
812 mx = (v >> CP0St_MX) & 0x1;
813 ksu = (v >> CP0St_KSU) & 0x3;
814 asid = env->CP0_EntryHi & 0xff;
815
816 tcstatus = cu << CP0TCSt_TCU0;
817 tcstatus |= mx << CP0TCSt_TMX;
818 tcstatus |= ksu << CP0TCSt_TKSU;
819 tcstatus |= asid;
820
821 if (tc == cpu->current_tc) {
822 tcst = &cpu->active_tc.CP0_TCStatus;
823 } else {
824 tcst = &cpu->tcs[tc].CP0_TCStatus;
825 }
826
827 *tcst &= ~mask;
828 *tcst |= tcstatus;
829 compute_hflags(cpu);
830 }
831
832 /* Called for updates to CP0_TCStatus. */
833 static void sync_c0_tcstatus(CPUMIPSState *cpu, int tc,
834 target_ulong v)
835 {
836 uint32_t status;
837 uint32_t tcu, tmx, tasid, tksu;
838 uint32_t mask = ((1 << CP0St_CU3)
839 | (1 << CP0St_CU2)
840 | (1 << CP0St_CU1)
841 | (1 << CP0St_CU0)
842 | (1 << CP0St_MX)
843 | (3 << CP0St_KSU));
844
845 tcu = (v >> CP0TCSt_TCU0) & 0xf;
846 tmx = (v >> CP0TCSt_TMX) & 0x1;
847 tasid = v & 0xff;
848 tksu = (v >> CP0TCSt_TKSU) & 0x3;
849
850 status = tcu << CP0St_CU0;
851 status |= tmx << CP0St_MX;
852 status |= tksu << CP0St_KSU;
853
854 cpu->CP0_Status &= ~mask;
855 cpu->CP0_Status |= status;
856
857 /* Sync the TASID with EntryHi. */
858 cpu->CP0_EntryHi &= ~0xff;
859 cpu->CP0_EntryHi = tasid;
860
861 compute_hflags(cpu);
862 }
863
864 /* Called for updates to CP0_EntryHi. */
865 static void sync_c0_entryhi(CPUMIPSState *cpu, int tc)
866 {
867 int32_t *tcst;
868 uint32_t asid, v = cpu->CP0_EntryHi;
869
870 asid = v & 0xff;
871
872 if (tc == cpu->current_tc) {
873 tcst = &cpu->active_tc.CP0_TCStatus;
874 } else {
875 tcst = &cpu->tcs[tc].CP0_TCStatus;
876 }
877
878 *tcst &= ~0xff;
879 *tcst |= asid;
880 }
881
882 /* CP0 helpers */
883 target_ulong helper_mfc0_mvpcontrol(CPUMIPSState *env)
884 {
885 return env->mvp->CP0_MVPControl;
886 }
887
888 target_ulong helper_mfc0_mvpconf0(CPUMIPSState *env)
889 {
890 return env->mvp->CP0_MVPConf0;
891 }
892
893 target_ulong helper_mfc0_mvpconf1(CPUMIPSState *env)
894 {
895 return env->mvp->CP0_MVPConf1;
896 }
897
898 target_ulong helper_mfc0_random(CPUMIPSState *env)
899 {
900 return (int32_t)cpu_mips_get_random(env);
901 }
902
903 target_ulong helper_mfc0_tcstatus(CPUMIPSState *env)
904 {
905 return env->active_tc.CP0_TCStatus;
906 }
907
908 target_ulong helper_mftc0_tcstatus(CPUMIPSState *env)
909 {
910 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
911 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
912
913 if (other_tc == other->current_tc)
914 return other->active_tc.CP0_TCStatus;
915 else
916 return other->tcs[other_tc].CP0_TCStatus;
917 }
918
919 target_ulong helper_mfc0_tcbind(CPUMIPSState *env)
920 {
921 return env->active_tc.CP0_TCBind;
922 }
923
924 target_ulong helper_mftc0_tcbind(CPUMIPSState *env)
925 {
926 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
927 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
928
929 if (other_tc == other->current_tc)
930 return other->active_tc.CP0_TCBind;
931 else
932 return other->tcs[other_tc].CP0_TCBind;
933 }
934
935 target_ulong helper_mfc0_tcrestart(CPUMIPSState *env)
936 {
937 return env->active_tc.PC;
938 }
939
940 target_ulong helper_mftc0_tcrestart(CPUMIPSState *env)
941 {
942 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
943 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
944
945 if (other_tc == other->current_tc)
946 return other->active_tc.PC;
947 else
948 return other->tcs[other_tc].PC;
949 }
950
951 target_ulong helper_mfc0_tchalt(CPUMIPSState *env)
952 {
953 return env->active_tc.CP0_TCHalt;
954 }
955
956 target_ulong helper_mftc0_tchalt(CPUMIPSState *env)
957 {
958 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
959 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
960
961 if (other_tc == other->current_tc)
962 return other->active_tc.CP0_TCHalt;
963 else
964 return other->tcs[other_tc].CP0_TCHalt;
965 }
966
967 target_ulong helper_mfc0_tccontext(CPUMIPSState *env)
968 {
969 return env->active_tc.CP0_TCContext;
970 }
971
972 target_ulong helper_mftc0_tccontext(CPUMIPSState *env)
973 {
974 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
975 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
976
977 if (other_tc == other->current_tc)
978 return other->active_tc.CP0_TCContext;
979 else
980 return other->tcs[other_tc].CP0_TCContext;
981 }
982
983 target_ulong helper_mfc0_tcschedule(CPUMIPSState *env)
984 {
985 return env->active_tc.CP0_TCSchedule;
986 }
987
988 target_ulong helper_mftc0_tcschedule(CPUMIPSState *env)
989 {
990 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
991 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
992
993 if (other_tc == other->current_tc)
994 return other->active_tc.CP0_TCSchedule;
995 else
996 return other->tcs[other_tc].CP0_TCSchedule;
997 }
998
999 target_ulong helper_mfc0_tcschefback(CPUMIPSState *env)
1000 {
1001 return env->active_tc.CP0_TCScheFBack;
1002 }
1003
1004 target_ulong helper_mftc0_tcschefback(CPUMIPSState *env)
1005 {
1006 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1007 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1008
1009 if (other_tc == other->current_tc)
1010 return other->active_tc.CP0_TCScheFBack;
1011 else
1012 return other->tcs[other_tc].CP0_TCScheFBack;
1013 }
1014
1015 target_ulong helper_mfc0_count(CPUMIPSState *env)
1016 {
1017 return (int32_t)cpu_mips_get_count(env);
1018 }
1019
1020 target_ulong helper_mftc0_entryhi(CPUMIPSState *env)
1021 {
1022 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1023 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1024
1025 return other->CP0_EntryHi;
1026 }
1027
1028 target_ulong helper_mftc0_cause(CPUMIPSState *env)
1029 {
1030 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1031 int32_t tccause;
1032 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1033
1034 if (other_tc == other->current_tc) {
1035 tccause = other->CP0_Cause;
1036 } else {
1037 tccause = other->CP0_Cause;
1038 }
1039
1040 return tccause;
1041 }
1042
1043 target_ulong helper_mftc0_status(CPUMIPSState *env)
1044 {
1045 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1046 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1047
1048 return other->CP0_Status;
1049 }
1050
1051 target_ulong helper_mfc0_lladdr(CPUMIPSState *env)
1052 {
1053 return (int32_t)(env->lladdr >> env->CP0_LLAddr_shift);
1054 }
1055
1056 target_ulong helper_mfc0_watchlo(CPUMIPSState *env, uint32_t sel)
1057 {
1058 return (int32_t)env->CP0_WatchLo[sel];
1059 }
1060
1061 target_ulong helper_mfc0_watchhi(CPUMIPSState *env, uint32_t sel)
1062 {
1063 return env->CP0_WatchHi[sel];
1064 }
1065
1066 target_ulong helper_mfc0_debug(CPUMIPSState *env)
1067 {
1068 target_ulong t0 = env->CP0_Debug;
1069 if (env->hflags & MIPS_HFLAG_DM)
1070 t0 |= 1 << CP0DB_DM;
1071
1072 return t0;
1073 }
1074
1075 target_ulong helper_mftc0_debug(CPUMIPSState *env)
1076 {
1077 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1078 int32_t tcstatus;
1079 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1080
1081 if (other_tc == other->current_tc)
1082 tcstatus = other->active_tc.CP0_Debug_tcstatus;
1083 else
1084 tcstatus = other->tcs[other_tc].CP0_Debug_tcstatus;
1085
1086 /* XXX: Might be wrong, check with EJTAG spec. */
1087 return (other->CP0_Debug & ~((1 << CP0DB_SSt) | (1 << CP0DB_Halt))) |
1088 (tcstatus & ((1 << CP0DB_SSt) | (1 << CP0DB_Halt)));
1089 }
1090
1091 #if defined(TARGET_MIPS64)
1092 target_ulong helper_dmfc0_tcrestart(CPUMIPSState *env)
1093 {
1094 return env->active_tc.PC;
1095 }
1096
1097 target_ulong helper_dmfc0_tchalt(CPUMIPSState *env)
1098 {
1099 return env->active_tc.CP0_TCHalt;
1100 }
1101
1102 target_ulong helper_dmfc0_tccontext(CPUMIPSState *env)
1103 {
1104 return env->active_tc.CP0_TCContext;
1105 }
1106
1107 target_ulong helper_dmfc0_tcschedule(CPUMIPSState *env)
1108 {
1109 return env->active_tc.CP0_TCSchedule;
1110 }
1111
1112 target_ulong helper_dmfc0_tcschefback(CPUMIPSState *env)
1113 {
1114 return env->active_tc.CP0_TCScheFBack;
1115 }
1116
1117 target_ulong helper_dmfc0_lladdr(CPUMIPSState *env)
1118 {
1119 return env->lladdr >> env->CP0_LLAddr_shift;
1120 }
1121
1122 target_ulong helper_dmfc0_watchlo(CPUMIPSState *env, uint32_t sel)
1123 {
1124 return env->CP0_WatchLo[sel];
1125 }
1126 #endif /* TARGET_MIPS64 */
1127
1128 void helper_mtc0_index(CPUMIPSState *env, target_ulong arg1)
1129 {
1130 int num = 1;
1131 unsigned int tmp = env->tlb->nb_tlb;
1132
1133 do {
1134 tmp >>= 1;
1135 num <<= 1;
1136 } while (tmp);
1137 env->CP0_Index = (env->CP0_Index & 0x80000000) | (arg1 & (num - 1));
1138 }
1139
1140 void helper_mtc0_mvpcontrol(CPUMIPSState *env, target_ulong arg1)
1141 {
1142 uint32_t mask = 0;
1143 uint32_t newval;
1144
1145 if (env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP))
1146 mask |= (1 << CP0MVPCo_CPA) | (1 << CP0MVPCo_VPC) |
1147 (1 << CP0MVPCo_EVP);
1148 if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1149 mask |= (1 << CP0MVPCo_STLB);
1150 newval = (env->mvp->CP0_MVPControl & ~mask) | (arg1 & mask);
1151
1152 // TODO: Enable/disable shared TLB, enable/disable VPEs.
1153
1154 env->mvp->CP0_MVPControl = newval;
1155 }
1156
1157 void helper_mtc0_vpecontrol(CPUMIPSState *env, target_ulong arg1)
1158 {
1159 uint32_t mask;
1160 uint32_t newval;
1161
1162 mask = (1 << CP0VPECo_YSI) | (1 << CP0VPECo_GSI) |
1163 (1 << CP0VPECo_TE) | (0xff << CP0VPECo_TargTC);
1164 newval = (env->CP0_VPEControl & ~mask) | (arg1 & mask);
1165
1166 /* Yield scheduler intercept not implemented. */
1167 /* Gating storage scheduler intercept not implemented. */
1168
1169 // TODO: Enable/disable TCs.
1170
1171 env->CP0_VPEControl = newval;
1172 }
1173
1174 void helper_mttc0_vpecontrol(CPUMIPSState *env, target_ulong arg1)
1175 {
1176 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1177 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1178 uint32_t mask;
1179 uint32_t newval;
1180
1181 mask = (1 << CP0VPECo_YSI) | (1 << CP0VPECo_GSI) |
1182 (1 << CP0VPECo_TE) | (0xff << CP0VPECo_TargTC);
1183 newval = (other->CP0_VPEControl & ~mask) | (arg1 & mask);
1184
1185 /* TODO: Enable/disable TCs. */
1186
1187 other->CP0_VPEControl = newval;
1188 }
1189
1190 target_ulong helper_mftc0_vpecontrol(CPUMIPSState *env)
1191 {
1192 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1193 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1194 /* FIXME: Mask away return zero on read bits. */
1195 return other->CP0_VPEControl;
1196 }
1197
1198 target_ulong helper_mftc0_vpeconf0(CPUMIPSState *env)
1199 {
1200 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1201 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1202
1203 return other->CP0_VPEConf0;
1204 }
1205
1206 void helper_mtc0_vpeconf0(CPUMIPSState *env, target_ulong arg1)
1207 {
1208 uint32_t mask = 0;
1209 uint32_t newval;
1210
1211 if (env->CP0_VPEConf0 & (1 << CP0VPEC0_MVP)) {
1212 if (env->CP0_VPEConf0 & (1 << CP0VPEC0_VPA))
1213 mask |= (0xff << CP0VPEC0_XTC);
1214 mask |= (1 << CP0VPEC0_MVP) | (1 << CP0VPEC0_VPA);
1215 }
1216 newval = (env->CP0_VPEConf0 & ~mask) | (arg1 & mask);
1217
1218 // TODO: TC exclusive handling due to ERL/EXL.
1219
1220 env->CP0_VPEConf0 = newval;
1221 }
1222
1223 void helper_mttc0_vpeconf0(CPUMIPSState *env, target_ulong arg1)
1224 {
1225 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1226 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1227 uint32_t mask = 0;
1228 uint32_t newval;
1229
1230 mask |= (1 << CP0VPEC0_MVP) | (1 << CP0VPEC0_VPA);
1231 newval = (other->CP0_VPEConf0 & ~mask) | (arg1 & mask);
1232
1233 /* TODO: TC exclusive handling due to ERL/EXL. */
1234 other->CP0_VPEConf0 = newval;
1235 }
1236
1237 void helper_mtc0_vpeconf1(CPUMIPSState *env, target_ulong arg1)
1238 {
1239 uint32_t mask = 0;
1240 uint32_t newval;
1241
1242 if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1243 mask |= (0xff << CP0VPEC1_NCX) | (0xff << CP0VPEC1_NCP2) |
1244 (0xff << CP0VPEC1_NCP1);
1245 newval = (env->CP0_VPEConf1 & ~mask) | (arg1 & mask);
1246
1247 /* UDI not implemented. */
1248 /* CP2 not implemented. */
1249
1250 // TODO: Handle FPU (CP1) binding.
1251
1252 env->CP0_VPEConf1 = newval;
1253 }
1254
1255 void helper_mtc0_yqmask(CPUMIPSState *env, target_ulong arg1)
1256 {
1257 /* Yield qualifier inputs not implemented. */
1258 env->CP0_YQMask = 0x00000000;
1259 }
1260
1261 void helper_mtc0_vpeopt(CPUMIPSState *env, target_ulong arg1)
1262 {
1263 env->CP0_VPEOpt = arg1 & 0x0000ffff;
1264 }
1265
1266 void helper_mtc0_entrylo0(CPUMIPSState *env, target_ulong arg1)
1267 {
1268 /* Large physaddr (PABITS) not implemented */
1269 /* 1k pages not implemented */
1270 env->CP0_EntryLo0 = arg1 & 0x3FFFFFFF;
1271 }
1272
1273 void helper_mtc0_tcstatus(CPUMIPSState *env, target_ulong arg1)
1274 {
1275 uint32_t mask = env->CP0_TCStatus_rw_bitmask;
1276 uint32_t newval;
1277
1278 newval = (env->active_tc.CP0_TCStatus & ~mask) | (arg1 & mask);
1279
1280 env->active_tc.CP0_TCStatus = newval;
1281 sync_c0_tcstatus(env, env->current_tc, newval);
1282 }
1283
1284 void helper_mttc0_tcstatus(CPUMIPSState *env, target_ulong arg1)
1285 {
1286 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1287 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1288
1289 if (other_tc == other->current_tc)
1290 other->active_tc.CP0_TCStatus = arg1;
1291 else
1292 other->tcs[other_tc].CP0_TCStatus = arg1;
1293 sync_c0_tcstatus(other, other_tc, arg1);
1294 }
1295
1296 void helper_mtc0_tcbind(CPUMIPSState *env, target_ulong arg1)
1297 {
1298 uint32_t mask = (1 << CP0TCBd_TBE);
1299 uint32_t newval;
1300
1301 if (env->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1302 mask |= (1 << CP0TCBd_CurVPE);
1303 newval = (env->active_tc.CP0_TCBind & ~mask) | (arg1 & mask);
1304 env->active_tc.CP0_TCBind = newval;
1305 }
1306
1307 void helper_mttc0_tcbind(CPUMIPSState *env, target_ulong arg1)
1308 {
1309 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1310 uint32_t mask = (1 << CP0TCBd_TBE);
1311 uint32_t newval;
1312 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1313
1314 if (other->mvp->CP0_MVPControl & (1 << CP0MVPCo_VPC))
1315 mask |= (1 << CP0TCBd_CurVPE);
1316 if (other_tc == other->current_tc) {
1317 newval = (other->active_tc.CP0_TCBind & ~mask) | (arg1 & mask);
1318 other->active_tc.CP0_TCBind = newval;
1319 } else {
1320 newval = (other->tcs[other_tc].CP0_TCBind & ~mask) | (arg1 & mask);
1321 other->tcs[other_tc].CP0_TCBind = newval;
1322 }
1323 }
1324
1325 void helper_mtc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
1326 {
1327 env->active_tc.PC = arg1;
1328 env->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1329 env->lladdr = 0ULL;
1330 /* MIPS16 not implemented. */
1331 }
1332
1333 void helper_mttc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
1334 {
1335 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1336 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1337
1338 if (other_tc == other->current_tc) {
1339 other->active_tc.PC = arg1;
1340 other->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1341 other->lladdr = 0ULL;
1342 /* MIPS16 not implemented. */
1343 } else {
1344 other->tcs[other_tc].PC = arg1;
1345 other->tcs[other_tc].CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
1346 other->lladdr = 0ULL;
1347 /* MIPS16 not implemented. */
1348 }
1349 }
1350
1351 void helper_mtc0_tchalt(CPUMIPSState *env, target_ulong arg1)
1352 {
1353 MIPSCPU *cpu = mips_env_get_cpu(env);
1354
1355 env->active_tc.CP0_TCHalt = arg1 & 0x1;
1356
1357 // TODO: Halt TC / Restart (if allocated+active) TC.
1358 if (env->active_tc.CP0_TCHalt & 1) {
1359 mips_tc_sleep(cpu, env->current_tc);
1360 } else {
1361 mips_tc_wake(cpu, env->current_tc);
1362 }
1363 }
1364
1365 void helper_mttc0_tchalt(CPUMIPSState *env, target_ulong arg1)
1366 {
1367 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1368 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1369 MIPSCPU *other_cpu = mips_env_get_cpu(other);
1370
1371 // TODO: Halt TC / Restart (if allocated+active) TC.
1372
1373 if (other_tc == other->current_tc)
1374 other->active_tc.CP0_TCHalt = arg1;
1375 else
1376 other->tcs[other_tc].CP0_TCHalt = arg1;
1377
1378 if (arg1 & 1) {
1379 mips_tc_sleep(other_cpu, other_tc);
1380 } else {
1381 mips_tc_wake(other_cpu, other_tc);
1382 }
1383 }
1384
1385 void helper_mtc0_tccontext(CPUMIPSState *env, target_ulong arg1)
1386 {
1387 env->active_tc.CP0_TCContext = arg1;
1388 }
1389
1390 void helper_mttc0_tccontext(CPUMIPSState *env, target_ulong arg1)
1391 {
1392 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1393 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1394
1395 if (other_tc == other->current_tc)
1396 other->active_tc.CP0_TCContext = arg1;
1397 else
1398 other->tcs[other_tc].CP0_TCContext = arg1;
1399 }
1400
1401 void helper_mtc0_tcschedule(CPUMIPSState *env, target_ulong arg1)
1402 {
1403 env->active_tc.CP0_TCSchedule = arg1;
1404 }
1405
1406 void helper_mttc0_tcschedule(CPUMIPSState *env, target_ulong arg1)
1407 {
1408 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1409 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1410
1411 if (other_tc == other->current_tc)
1412 other->active_tc.CP0_TCSchedule = arg1;
1413 else
1414 other->tcs[other_tc].CP0_TCSchedule = arg1;
1415 }
1416
1417 void helper_mtc0_tcschefback(CPUMIPSState *env, target_ulong arg1)
1418 {
1419 env->active_tc.CP0_TCScheFBack = arg1;
1420 }
1421
1422 void helper_mttc0_tcschefback(CPUMIPSState *env, target_ulong arg1)
1423 {
1424 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1425 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1426
1427 if (other_tc == other->current_tc)
1428 other->active_tc.CP0_TCScheFBack = arg1;
1429 else
1430 other->tcs[other_tc].CP0_TCScheFBack = arg1;
1431 }
1432
1433 void helper_mtc0_entrylo1(CPUMIPSState *env, target_ulong arg1)
1434 {
1435 /* Large physaddr (PABITS) not implemented */
1436 /* 1k pages not implemented */
1437 env->CP0_EntryLo1 = arg1 & 0x3FFFFFFF;
1438 }
1439
1440 void helper_mtc0_context(CPUMIPSState *env, target_ulong arg1)
1441 {
1442 env->CP0_Context = (env->CP0_Context & 0x007FFFFF) | (arg1 & ~0x007FFFFF);
1443 }
1444
1445 void helper_mtc0_pagemask(CPUMIPSState *env, target_ulong arg1)
1446 {
1447 /* 1k pages not implemented */
1448 env->CP0_PageMask = arg1 & (0x1FFFFFFF & (TARGET_PAGE_MASK << 1));
1449 }
1450
1451 void helper_mtc0_pagegrain(CPUMIPSState *env, target_ulong arg1)
1452 {
1453 /* SmartMIPS not implemented */
1454 /* Large physaddr (PABITS) not implemented */
1455 /* 1k pages not implemented */
1456 env->CP0_PageGrain = 0;
1457 }
1458
1459 void helper_mtc0_wired(CPUMIPSState *env, target_ulong arg1)
1460 {
1461 env->CP0_Wired = arg1 % env->tlb->nb_tlb;
1462 }
1463
1464 void helper_mtc0_srsconf0(CPUMIPSState *env, target_ulong arg1)
1465 {
1466 env->CP0_SRSConf0 |= arg1 & env->CP0_SRSConf0_rw_bitmask;
1467 }
1468
1469 void helper_mtc0_srsconf1(CPUMIPSState *env, target_ulong arg1)
1470 {
1471 env->CP0_SRSConf1 |= arg1 & env->CP0_SRSConf1_rw_bitmask;
1472 }
1473
1474 void helper_mtc0_srsconf2(CPUMIPSState *env, target_ulong arg1)
1475 {
1476 env->CP0_SRSConf2 |= arg1 & env->CP0_SRSConf2_rw_bitmask;
1477 }
1478
1479 void helper_mtc0_srsconf3(CPUMIPSState *env, target_ulong arg1)
1480 {
1481 env->CP0_SRSConf3 |= arg1 & env->CP0_SRSConf3_rw_bitmask;
1482 }
1483
1484 void helper_mtc0_srsconf4(CPUMIPSState *env, target_ulong arg1)
1485 {
1486 env->CP0_SRSConf4 |= arg1 & env->CP0_SRSConf4_rw_bitmask;
1487 }
1488
1489 void helper_mtc0_hwrena(CPUMIPSState *env, target_ulong arg1)
1490 {
1491 env->CP0_HWREna = arg1 & 0x0000000F;
1492 }
1493
1494 void helper_mtc0_count(CPUMIPSState *env, target_ulong arg1)
1495 {
1496 cpu_mips_store_count(env, arg1);
1497 }
1498
1499 void helper_mtc0_entryhi(CPUMIPSState *env, target_ulong arg1)
1500 {
1501 target_ulong old, val;
1502
1503 /* 1k pages not implemented */
1504 val = arg1 & ((TARGET_PAGE_MASK << 1) | 0xFF);
1505 #if defined(TARGET_MIPS64)
1506 val &= env->SEGMask;
1507 #endif
1508 old = env->CP0_EntryHi;
1509 env->CP0_EntryHi = val;
1510 if (env->CP0_Config3 & (1 << CP0C3_MT)) {
1511 sync_c0_entryhi(env, env->current_tc);
1512 }
1513 /* If the ASID changes, flush qemu's TLB. */
1514 if ((old & 0xFF) != (val & 0xFF))
1515 cpu_mips_tlb_flush(env, 1);
1516 }
1517
1518 void helper_mttc0_entryhi(CPUMIPSState *env, target_ulong arg1)
1519 {
1520 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1521 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1522
1523 other->CP0_EntryHi = arg1;
1524 sync_c0_entryhi(other, other_tc);
1525 }
1526
1527 void helper_mtc0_compare(CPUMIPSState *env, target_ulong arg1)
1528 {
1529 cpu_mips_store_compare(env, arg1);
1530 }
1531
1532 void helper_mtc0_status(CPUMIPSState *env, target_ulong arg1)
1533 {
1534 uint32_t val, old;
1535 uint32_t mask = env->CP0_Status_rw_bitmask;
1536
1537 val = arg1 & mask;
1538 old = env->CP0_Status;
1539 env->CP0_Status = (env->CP0_Status & ~mask) | val;
1540 if (env->CP0_Config3 & (1 << CP0C3_MT)) {
1541 sync_c0_status(env, env, env->current_tc);
1542 } else {
1543 compute_hflags(env);
1544 }
1545
1546 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
1547 qemu_log("Status %08x (%08x) => %08x (%08x) Cause %08x",
1548 old, old & env->CP0_Cause & CP0Ca_IP_mask,
1549 val, val & env->CP0_Cause & CP0Ca_IP_mask,
1550 env->CP0_Cause);
1551 switch (env->hflags & MIPS_HFLAG_KSU) {
1552 case MIPS_HFLAG_UM: qemu_log(", UM\n"); break;
1553 case MIPS_HFLAG_SM: qemu_log(", SM\n"); break;
1554 case MIPS_HFLAG_KM: qemu_log("\n"); break;
1555 default: cpu_abort(env, "Invalid MMU mode!\n"); break;
1556 }
1557 }
1558 }
1559
1560 void helper_mttc0_status(CPUMIPSState *env, target_ulong arg1)
1561 {
1562 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1563 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1564
1565 other->CP0_Status = arg1 & ~0xf1000018;
1566 sync_c0_status(env, other, other_tc);
1567 }
1568
1569 void helper_mtc0_intctl(CPUMIPSState *env, target_ulong arg1)
1570 {
1571 /* vectored interrupts not implemented, no performance counters. */
1572 env->CP0_IntCtl = (env->CP0_IntCtl & ~0x000003e0) | (arg1 & 0x000003e0);
1573 }
1574
1575 void helper_mtc0_srsctl(CPUMIPSState *env, target_ulong arg1)
1576 {
1577 uint32_t mask = (0xf << CP0SRSCtl_ESS) | (0xf << CP0SRSCtl_PSS);
1578 env->CP0_SRSCtl = (env->CP0_SRSCtl & ~mask) | (arg1 & mask);
1579 }
1580
1581 static void mtc0_cause(CPUMIPSState *cpu, target_ulong arg1)
1582 {
1583 uint32_t mask = 0x00C00300;
1584 uint32_t old = cpu->CP0_Cause;
1585 int i;
1586
1587 if (cpu->insn_flags & ISA_MIPS32R2) {
1588 mask |= 1 << CP0Ca_DC;
1589 }
1590
1591 cpu->CP0_Cause = (cpu->CP0_Cause & ~mask) | (arg1 & mask);
1592
1593 if ((old ^ cpu->CP0_Cause) & (1 << CP0Ca_DC)) {
1594 if (cpu->CP0_Cause & (1 << CP0Ca_DC)) {
1595 cpu_mips_stop_count(cpu);
1596 } else {
1597 cpu_mips_start_count(cpu);
1598 }
1599 }
1600
1601 /* Set/reset software interrupts */
1602 for (i = 0 ; i < 2 ; i++) {
1603 if ((old ^ cpu->CP0_Cause) & (1 << (CP0Ca_IP + i))) {
1604 cpu_mips_soft_irq(cpu, i, cpu->CP0_Cause & (1 << (CP0Ca_IP + i)));
1605 }
1606 }
1607 }
1608
1609 void helper_mtc0_cause(CPUMIPSState *env, target_ulong arg1)
1610 {
1611 mtc0_cause(env, arg1);
1612 }
1613
1614 void helper_mttc0_cause(CPUMIPSState *env, target_ulong arg1)
1615 {
1616 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1617 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1618
1619 mtc0_cause(other, arg1);
1620 }
1621
1622 target_ulong helper_mftc0_epc(CPUMIPSState *env)
1623 {
1624 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1625 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1626
1627 return other->CP0_EPC;
1628 }
1629
1630 target_ulong helper_mftc0_ebase(CPUMIPSState *env)
1631 {
1632 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1633 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1634
1635 return other->CP0_EBase;
1636 }
1637
1638 void helper_mtc0_ebase(CPUMIPSState *env, target_ulong arg1)
1639 {
1640 /* vectored interrupts not implemented */
1641 env->CP0_EBase = (env->CP0_EBase & ~0x3FFFF000) | (arg1 & 0x3FFFF000);
1642 }
1643
1644 void helper_mttc0_ebase(CPUMIPSState *env, target_ulong arg1)
1645 {
1646 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1647 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1648 other->CP0_EBase = (other->CP0_EBase & ~0x3FFFF000) | (arg1 & 0x3FFFF000);
1649 }
1650
1651 target_ulong helper_mftc0_configx(CPUMIPSState *env, target_ulong idx)
1652 {
1653 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1654 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1655
1656 switch (idx) {
1657 case 0: return other->CP0_Config0;
1658 case 1: return other->CP0_Config1;
1659 case 2: return other->CP0_Config2;
1660 case 3: return other->CP0_Config3;
1661 /* 4 and 5 are reserved. */
1662 case 6: return other->CP0_Config6;
1663 case 7: return other->CP0_Config7;
1664 default:
1665 break;
1666 }
1667 return 0;
1668 }
1669
1670 void helper_mtc0_config0(CPUMIPSState *env, target_ulong arg1)
1671 {
1672 env->CP0_Config0 = (env->CP0_Config0 & 0x81FFFFF8) | (arg1 & 0x00000007);
1673 }
1674
1675 void helper_mtc0_config2(CPUMIPSState *env, target_ulong arg1)
1676 {
1677 /* tertiary/secondary caches not implemented */
1678 env->CP0_Config2 = (env->CP0_Config2 & 0x8FFF0FFF);
1679 }
1680
1681 void helper_mtc0_lladdr(CPUMIPSState *env, target_ulong arg1)
1682 {
1683 target_long mask = env->CP0_LLAddr_rw_bitmask;
1684 arg1 = arg1 << env->CP0_LLAddr_shift;
1685 env->lladdr = (env->lladdr & ~mask) | (arg1 & mask);
1686 }
1687
1688 void helper_mtc0_watchlo(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1689 {
1690 /* Watch exceptions for instructions, data loads, data stores
1691 not implemented. */
1692 env->CP0_WatchLo[sel] = (arg1 & ~0x7);
1693 }
1694
1695 void helper_mtc0_watchhi(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1696 {
1697 env->CP0_WatchHi[sel] = (arg1 & 0x40FF0FF8);
1698 env->CP0_WatchHi[sel] &= ~(env->CP0_WatchHi[sel] & arg1 & 0x7);
1699 }
1700
1701 void helper_mtc0_xcontext(CPUMIPSState *env, target_ulong arg1)
1702 {
1703 target_ulong mask = (1ULL << (env->SEGBITS - 7)) - 1;
1704 env->CP0_XContext = (env->CP0_XContext & mask) | (arg1 & ~mask);
1705 }
1706
1707 void helper_mtc0_framemask(CPUMIPSState *env, target_ulong arg1)
1708 {
1709 env->CP0_Framemask = arg1; /* XXX */
1710 }
1711
1712 void helper_mtc0_debug(CPUMIPSState *env, target_ulong arg1)
1713 {
1714 env->CP0_Debug = (env->CP0_Debug & 0x8C03FC1F) | (arg1 & 0x13300120);
1715 if (arg1 & (1 << CP0DB_DM))
1716 env->hflags |= MIPS_HFLAG_DM;
1717 else
1718 env->hflags &= ~MIPS_HFLAG_DM;
1719 }
1720
1721 void helper_mttc0_debug(CPUMIPSState *env, target_ulong arg1)
1722 {
1723 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1724 uint32_t val = arg1 & ((1 << CP0DB_SSt) | (1 << CP0DB_Halt));
1725 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1726
1727 /* XXX: Might be wrong, check with EJTAG spec. */
1728 if (other_tc == other->current_tc)
1729 other->active_tc.CP0_Debug_tcstatus = val;
1730 else
1731 other->tcs[other_tc].CP0_Debug_tcstatus = val;
1732 other->CP0_Debug = (other->CP0_Debug &
1733 ((1 << CP0DB_SSt) | (1 << CP0DB_Halt))) |
1734 (arg1 & ~((1 << CP0DB_SSt) | (1 << CP0DB_Halt)));
1735 }
1736
1737 void helper_mtc0_performance0(CPUMIPSState *env, target_ulong arg1)
1738 {
1739 env->CP0_Performance0 = arg1 & 0x000007ff;
1740 }
1741
1742 void helper_mtc0_taglo(CPUMIPSState *env, target_ulong arg1)
1743 {
1744 env->CP0_TagLo = arg1 & 0xFFFFFCF6;
1745 }
1746
1747 void helper_mtc0_datalo(CPUMIPSState *env, target_ulong arg1)
1748 {
1749 env->CP0_DataLo = arg1; /* XXX */
1750 }
1751
1752 void helper_mtc0_taghi(CPUMIPSState *env, target_ulong arg1)
1753 {
1754 env->CP0_TagHi = arg1; /* XXX */
1755 }
1756
1757 void helper_mtc0_datahi(CPUMIPSState *env, target_ulong arg1)
1758 {
1759 env->CP0_DataHi = arg1; /* XXX */
1760 }
1761
1762 /* MIPS MT functions */
1763 target_ulong helper_mftgpr(CPUMIPSState *env, uint32_t sel)
1764 {
1765 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1766 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1767
1768 if (other_tc == other->current_tc)
1769 return other->active_tc.gpr[sel];
1770 else
1771 return other->tcs[other_tc].gpr[sel];
1772 }
1773
1774 target_ulong helper_mftlo(CPUMIPSState *env, uint32_t sel)
1775 {
1776 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1777 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1778
1779 if (other_tc == other->current_tc)
1780 return other->active_tc.LO[sel];
1781 else
1782 return other->tcs[other_tc].LO[sel];
1783 }
1784
1785 target_ulong helper_mfthi(CPUMIPSState *env, uint32_t sel)
1786 {
1787 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1788 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1789
1790 if (other_tc == other->current_tc)
1791 return other->active_tc.HI[sel];
1792 else
1793 return other->tcs[other_tc].HI[sel];
1794 }
1795
1796 target_ulong helper_mftacx(CPUMIPSState *env, uint32_t sel)
1797 {
1798 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1799 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1800
1801 if (other_tc == other->current_tc)
1802 return other->active_tc.ACX[sel];
1803 else
1804 return other->tcs[other_tc].ACX[sel];
1805 }
1806
1807 target_ulong helper_mftdsp(CPUMIPSState *env)
1808 {
1809 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1810 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1811
1812 if (other_tc == other->current_tc)
1813 return other->active_tc.DSPControl;
1814 else
1815 return other->tcs[other_tc].DSPControl;
1816 }
1817
1818 void helper_mttgpr(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1819 {
1820 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1821 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1822
1823 if (other_tc == other->current_tc)
1824 other->active_tc.gpr[sel] = arg1;
1825 else
1826 other->tcs[other_tc].gpr[sel] = arg1;
1827 }
1828
1829 void helper_mttlo(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1830 {
1831 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1832 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1833
1834 if (other_tc == other->current_tc)
1835 other->active_tc.LO[sel] = arg1;
1836 else
1837 other->tcs[other_tc].LO[sel] = arg1;
1838 }
1839
1840 void helper_mtthi(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1841 {
1842 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1843 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1844
1845 if (other_tc == other->current_tc)
1846 other->active_tc.HI[sel] = arg1;
1847 else
1848 other->tcs[other_tc].HI[sel] = arg1;
1849 }
1850
1851 void helper_mttacx(CPUMIPSState *env, target_ulong arg1, uint32_t sel)
1852 {
1853 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1854 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1855
1856 if (other_tc == other->current_tc)
1857 other->active_tc.ACX[sel] = arg1;
1858 else
1859 other->tcs[other_tc].ACX[sel] = arg1;
1860 }
1861
1862 void helper_mttdsp(CPUMIPSState *env, target_ulong arg1)
1863 {
1864 int other_tc = env->CP0_VPEControl & (0xff << CP0VPECo_TargTC);
1865 CPUMIPSState *other = mips_cpu_map_tc(env, &other_tc);
1866
1867 if (other_tc == other->current_tc)
1868 other->active_tc.DSPControl = arg1;
1869 else
1870 other->tcs[other_tc].DSPControl = arg1;
1871 }
1872
1873 /* MIPS MT functions */
1874 target_ulong helper_dmt(void)
1875 {
1876 // TODO
1877 return 0;
1878 }
1879
1880 target_ulong helper_emt(void)
1881 {
1882 // TODO
1883 return 0;
1884 }
1885
1886 target_ulong helper_dvpe(CPUMIPSState *env)
1887 {
1888 CPUMIPSState *other_cpu_env = first_cpu;
1889 target_ulong prev = env->mvp->CP0_MVPControl;
1890
1891 do {
1892 /* Turn off all VPEs except the one executing the dvpe. */
1893 if (other_cpu_env != env) {
1894 MIPSCPU *other_cpu = mips_env_get_cpu(other_cpu_env);
1895
1896 other_cpu_env->mvp->CP0_MVPControl &= ~(1 << CP0MVPCo_EVP);
1897 mips_vpe_sleep(other_cpu);
1898 }
1899 other_cpu_env = other_cpu_env->next_cpu;
1900 } while (other_cpu_env);
1901 return prev;
1902 }
1903
1904 target_ulong helper_evpe(CPUMIPSState *env)
1905 {
1906 CPUMIPSState *other_cpu_env = first_cpu;
1907 target_ulong prev = env->mvp->CP0_MVPControl;
1908
1909 do {
1910 MIPSCPU *other_cpu = mips_env_get_cpu(other_cpu_env);
1911
1912 if (other_cpu_env != env
1913 /* If the VPE is WFI, don't disturb its sleep. */
1914 && !mips_vpe_is_wfi(other_cpu)) {
1915 /* Enable the VPE. */
1916 other_cpu_env->mvp->CP0_MVPControl |= (1 << CP0MVPCo_EVP);
1917 mips_vpe_wake(other_cpu_env); /* And wake it up. */
1918 }
1919 other_cpu_env = other_cpu_env->next_cpu;
1920 } while (other_cpu_env);
1921 return prev;
1922 }
1923 #endif /* !CONFIG_USER_ONLY */
1924
1925 void helper_fork(target_ulong arg1, target_ulong arg2)
1926 {
1927 // arg1 = rt, arg2 = rs
1928 arg1 = 0;
1929 // TODO: store to TC register
1930 }
1931
1932 target_ulong helper_yield(CPUMIPSState *env, target_ulong arg)
1933 {
1934 target_long arg1 = arg;
1935
1936 if (arg1 < 0) {
1937 /* No scheduling policy implemented. */
1938 if (arg1 != -2) {
1939 if (env->CP0_VPEControl & (1 << CP0VPECo_YSI) &&
1940 env->active_tc.CP0_TCStatus & (1 << CP0TCSt_DT)) {
1941 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1942 env->CP0_VPEControl |= 4 << CP0VPECo_EXCPT;
1943 helper_raise_exception(env, EXCP_THREAD);
1944 }
1945 }
1946 } else if (arg1 == 0) {
1947 if (0 /* TODO: TC underflow */) {
1948 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1949 helper_raise_exception(env, EXCP_THREAD);
1950 } else {
1951 // TODO: Deallocate TC
1952 }
1953 } else if (arg1 > 0) {
1954 /* Yield qualifier inputs not implemented. */
1955 env->CP0_VPEControl &= ~(0x7 << CP0VPECo_EXCPT);
1956 env->CP0_VPEControl |= 2 << CP0VPECo_EXCPT;
1957 helper_raise_exception(env, EXCP_THREAD);
1958 }
1959 return env->CP0_YQMask;
1960 }
1961
1962 #ifndef CONFIG_USER_ONLY
1963 /* TLB management */
1964 static void cpu_mips_tlb_flush (CPUMIPSState *env, int flush_global)
1965 {
1966 /* Flush qemu's TLB and discard all shadowed entries. */
1967 tlb_flush (env, flush_global);
1968 env->tlb->tlb_in_use = env->tlb->nb_tlb;
1969 }
1970
1971 static void r4k_mips_tlb_flush_extra (CPUMIPSState *env, int first)
1972 {
1973 /* Discard entries from env->tlb[first] onwards. */
1974 while (env->tlb->tlb_in_use > first) {
1975 r4k_invalidate_tlb(env, --env->tlb->tlb_in_use, 0);
1976 }
1977 }
1978
1979 static void r4k_fill_tlb(CPUMIPSState *env, int idx)
1980 {
1981 r4k_tlb_t *tlb;
1982
1983 /* XXX: detect conflicting TLBs and raise a MCHECK exception when needed */
1984 tlb = &env->tlb->mmu.r4k.tlb[idx];
1985 tlb->VPN = env->CP0_EntryHi & (TARGET_PAGE_MASK << 1);
1986 #if defined(TARGET_MIPS64)
1987 tlb->VPN &= env->SEGMask;
1988 #endif
1989 tlb->ASID = env->CP0_EntryHi & 0xFF;
1990 tlb->PageMask = env->CP0_PageMask;
1991 tlb->G = env->CP0_EntryLo0 & env->CP0_EntryLo1 & 1;
1992 tlb->V0 = (env->CP0_EntryLo0 & 2) != 0;
1993 tlb->D0 = (env->CP0_EntryLo0 & 4) != 0;
1994 tlb->C0 = (env->CP0_EntryLo0 >> 3) & 0x7;
1995 tlb->PFN[0] = (env->CP0_EntryLo0 >> 6) << 12;
1996 tlb->V1 = (env->CP0_EntryLo1 & 2) != 0;
1997 tlb->D1 = (env->CP0_EntryLo1 & 4) != 0;
1998 tlb->C1 = (env->CP0_EntryLo1 >> 3) & 0x7;
1999 tlb->PFN[1] = (env->CP0_EntryLo1 >> 6) << 12;
2000 }
2001
2002 void r4k_helper_tlbwi(CPUMIPSState *env)
2003 {
2004 int idx;
2005
2006 idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
2007
2008 /* Discard cached TLB entries. We could avoid doing this if the
2009 tlbwi is just upgrading access permissions on the current entry;
2010 that might be a further win. */
2011 r4k_mips_tlb_flush_extra (env, env->tlb->nb_tlb);
2012
2013 r4k_invalidate_tlb(env, idx, 0);
2014 r4k_fill_tlb(env, idx);
2015 }
2016
2017 void r4k_helper_tlbwr(CPUMIPSState *env)
2018 {
2019 int r = cpu_mips_get_random(env);
2020
2021 r4k_invalidate_tlb(env, r, 1);
2022 r4k_fill_tlb(env, r);
2023 }
2024
2025 void r4k_helper_tlbp(CPUMIPSState *env)
2026 {
2027 r4k_tlb_t *tlb;
2028 target_ulong mask;
2029 target_ulong tag;
2030 target_ulong VPN;
2031 uint8_t ASID;
2032 int i;
2033
2034 ASID = env->CP0_EntryHi & 0xFF;
2035 for (i = 0; i < env->tlb->nb_tlb; i++) {
2036 tlb = &env->tlb->mmu.r4k.tlb[i];
2037 /* 1k pages are not supported. */
2038 mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
2039 tag = env->CP0_EntryHi & ~mask;
2040 VPN = tlb->VPN & ~mask;
2041 /* Check ASID, virtual page number & size */
2042 if ((tlb->G == 1 || tlb->ASID == ASID) && VPN == tag) {
2043 /* TLB match */
2044 env->CP0_Index = i;
2045 break;
2046 }
2047 }
2048 if (i == env->tlb->nb_tlb) {
2049 /* No match. Discard any shadow entries, if any of them match. */
2050 for (i = env->tlb->nb_tlb; i < env->tlb->tlb_in_use; i++) {
2051 tlb = &env->tlb->mmu.r4k.tlb[i];
2052 /* 1k pages are not supported. */
2053 mask = tlb->PageMask | ~(TARGET_PAGE_MASK << 1);
2054 tag = env->CP0_EntryHi & ~mask;
2055 VPN = tlb->VPN & ~mask;
2056 /* Check ASID, virtual page number & size */
2057 if ((tlb->G == 1 || tlb->ASID == ASID) && VPN == tag) {
2058 r4k_mips_tlb_flush_extra (env, i);
2059 break;
2060 }
2061 }
2062
2063 env->CP0_Index |= 0x80000000;
2064 }
2065 }
2066
2067 void r4k_helper_tlbr(CPUMIPSState *env)
2068 {
2069 r4k_tlb_t *tlb;
2070 uint8_t ASID;
2071 int idx;
2072
2073 ASID = env->CP0_EntryHi & 0xFF;
2074 idx = (env->CP0_Index & ~0x80000000) % env->tlb->nb_tlb;
2075 tlb = &env->tlb->mmu.r4k.tlb[idx];
2076
2077 /* If this will change the current ASID, flush qemu's TLB. */
2078 if (ASID != tlb->ASID)
2079 cpu_mips_tlb_flush (env, 1);
2080
2081 r4k_mips_tlb_flush_extra(env, env->tlb->nb_tlb);
2082
2083 env->CP0_EntryHi = tlb->VPN | tlb->ASID;
2084 env->CP0_PageMask = tlb->PageMask;
2085 env->CP0_EntryLo0 = tlb->G | (tlb->V0 << 1) | (tlb->D0 << 2) |
2086 (tlb->C0 << 3) | (tlb->PFN[0] >> 6);
2087 env->CP0_EntryLo1 = tlb->G | (tlb->V1 << 1) | (tlb->D1 << 2) |
2088 (tlb->C1 << 3) | (tlb->PFN[1] >> 6);
2089 }
2090
2091 void helper_tlbwi(CPUMIPSState *env)
2092 {
2093 env->tlb->helper_tlbwi(env);
2094 }
2095
2096 void helper_tlbwr(CPUMIPSState *env)
2097 {
2098 env->tlb->helper_tlbwr(env);
2099 }
2100
2101 void helper_tlbp(CPUMIPSState *env)
2102 {
2103 env->tlb->helper_tlbp(env);
2104 }
2105
2106 void helper_tlbr(CPUMIPSState *env)
2107 {
2108 env->tlb->helper_tlbr(env);
2109 }
2110
2111 /* Specials */
2112 target_ulong helper_di(CPUMIPSState *env)
2113 {
2114 target_ulong t0 = env->CP0_Status;
2115
2116 env->CP0_Status = t0 & ~(1 << CP0St_IE);
2117 return t0;
2118 }
2119
2120 target_ulong helper_ei(CPUMIPSState *env)
2121 {
2122 target_ulong t0 = env->CP0_Status;
2123
2124 env->CP0_Status = t0 | (1 << CP0St_IE);
2125 return t0;
2126 }
2127
2128 static void debug_pre_eret(CPUMIPSState *env)
2129 {
2130 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
2131 qemu_log("ERET: PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
2132 env->active_tc.PC, env->CP0_EPC);
2133 if (env->CP0_Status & (1 << CP0St_ERL))
2134 qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
2135 if (env->hflags & MIPS_HFLAG_DM)
2136 qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
2137 qemu_log("\n");
2138 }
2139 }
2140
2141 static void debug_post_eret(CPUMIPSState *env)
2142 {
2143 if (qemu_loglevel_mask(CPU_LOG_EXEC)) {
2144 qemu_log(" => PC " TARGET_FMT_lx " EPC " TARGET_FMT_lx,
2145 env->active_tc.PC, env->CP0_EPC);
2146 if (env->CP0_Status & (1 << CP0St_ERL))
2147 qemu_log(" ErrorEPC " TARGET_FMT_lx, env->CP0_ErrorEPC);
2148 if (env->hflags & MIPS_HFLAG_DM)
2149 qemu_log(" DEPC " TARGET_FMT_lx, env->CP0_DEPC);
2150 switch (env->hflags & MIPS_HFLAG_KSU) {
2151 case MIPS_HFLAG_UM: qemu_log(", UM\n"); break;
2152 case MIPS_HFLAG_SM: qemu_log(", SM\n"); break;
2153 case MIPS_HFLAG_KM: qemu_log("\n"); break;
2154 default: cpu_abort(env, "Invalid MMU mode!\n"); break;
2155 }
2156 }
2157 }
2158
2159 static void set_pc(CPUMIPSState *env, target_ulong error_pc)
2160 {
2161 env->active_tc.PC = error_pc & ~(target_ulong)1;
2162 if (error_pc & 1) {
2163 env->hflags |= MIPS_HFLAG_M16;
2164 } else {
2165 env->hflags &= ~(MIPS_HFLAG_M16);
2166 }
2167 }
2168
2169 void helper_eret(CPUMIPSState *env)
2170 {
2171 debug_pre_eret(env);
2172 if (env->CP0_Status & (1 << CP0St_ERL)) {
2173 set_pc(env, env->CP0_ErrorEPC);
2174 env->CP0_Status &= ~(1 << CP0St_ERL);
2175 } else {
2176 set_pc(env, env->CP0_EPC);
2177 env->CP0_Status &= ~(1 << CP0St_EXL);
2178 }
2179 compute_hflags(env);
2180 debug_post_eret(env);
2181 env->lladdr = 1;
2182 }
2183
2184 void helper_deret(CPUMIPSState *env)
2185 {
2186 debug_pre_eret(env);
2187 set_pc(env, env->CP0_DEPC);
2188
2189 env->hflags &= MIPS_HFLAG_DM;
2190 compute_hflags(env);
2191 debug_post_eret(env);
2192 env->lladdr = 1;
2193 }
2194 #endif /* !CONFIG_USER_ONLY */
2195
2196 target_ulong helper_rdhwr_cpunum(CPUMIPSState *env)
2197 {
2198 if ((env->hflags & MIPS_HFLAG_CP0) ||
2199 (env->CP0_HWREna & (1 << 0)))
2200 return env->CP0_EBase & 0x3ff;
2201 else
2202 helper_raise_exception(env, EXCP_RI);
2203
2204 return 0;
2205 }
2206
2207 target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
2208 {
2209 if ((env->hflags & MIPS_HFLAG_CP0) ||
2210 (env->CP0_HWREna & (1 << 1)))
2211 return env->SYNCI_Step;
2212 else
2213 helper_raise_exception(env, EXCP_RI);
2214
2215 return 0;
2216 }
2217
2218 target_ulong helper_rdhwr_cc(CPUMIPSState *env)
2219 {
2220 if ((env->hflags & MIPS_HFLAG_CP0) ||
2221 (env->CP0_HWREna & (1 << 2)))
2222 return env->CP0_Count;
2223 else
2224 helper_raise_exception(env, EXCP_RI);
2225
2226 return 0;
2227 }
2228
2229 target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
2230 {
2231 if ((env->hflags & MIPS_HFLAG_CP0) ||
2232 (env->CP0_HWREna & (1 << 3)))
2233 return env->CCRes;
2234 else
2235 helper_raise_exception(env, EXCP_RI);
2236
2237 return 0;
2238 }
2239
2240 void helper_pmon(CPUMIPSState *env, int function)
2241 {
2242 function /= 2;
2243 switch (function) {
2244 case 2: /* TODO: char inbyte(int waitflag); */
2245 if (env->active_tc.gpr[4] == 0)
2246 env->active_tc.gpr[2] = -1;
2247 /* Fall through */
2248 case 11: /* TODO: char inbyte (void); */
2249 env->active_tc.gpr[2] = -1;
2250 break;
2251 case 3:
2252 case 12:
2253 printf("%c", (char)(env->active_tc.gpr[4] & 0xFF));
2254 break;
2255 case 17:
2256 break;
2257 case 158:
2258 {
2259 unsigned char *fmt = (void *)(uintptr_t)env->active_tc.gpr[4];
2260 printf("%s", fmt);
2261 }
2262 break;
2263 }
2264 }
2265
2266 void helper_wait(CPUMIPSState *env)
2267 {
2268 env->halted = 1;
2269 cpu_reset_interrupt(env, CPU_INTERRUPT_WAKE);
2270 helper_raise_exception(env, EXCP_HLT);
2271 }
2272
2273 #if !defined(CONFIG_USER_ONLY)
2274
2275 static void QEMU_NORETURN do_unaligned_access(CPUMIPSState *env,
2276 target_ulong addr, int is_write,
2277 int is_user, uintptr_t retaddr);
2278
2279 #define MMUSUFFIX _mmu
2280 #define ALIGNED_ONLY
2281
2282 #define SHIFT 0
2283 #include "softmmu_template.h"
2284
2285 #define SHIFT 1
2286 #include "softmmu_template.h"
2287
2288 #define SHIFT 2
2289 #include "softmmu_template.h"
2290
2291 #define SHIFT 3
2292 #include "softmmu_template.h"
2293
2294 static void do_unaligned_access(CPUMIPSState *env, target_ulong addr,
2295 int is_write, int is_user, uintptr_t retaddr)
2296 {
2297 env->CP0_BadVAddr = addr;
2298 do_restore_state(env, retaddr);
2299 helper_raise_exception(env, (is_write == 1) ? EXCP_AdES : EXCP_AdEL);
2300 }
2301
2302 void tlb_fill(CPUMIPSState *env, target_ulong addr, int is_write, int mmu_idx,
2303 uintptr_t retaddr)
2304 {
2305 TranslationBlock *tb;
2306 int ret;
2307
2308 ret = cpu_mips_handle_mmu_fault(env, addr, is_write, mmu_idx);
2309 if (ret) {
2310 if (retaddr) {
2311 /* now we have a real cpu fault */
2312 tb = tb_find_pc(retaddr);
2313 if (tb) {
2314 /* the PC is inside the translated code. It means that we have
2315 a virtual CPU fault */
2316 cpu_restore_state(tb, env, retaddr);
2317 }
2318 }
2319 helper_raise_exception_err(env, env->exception_index, env->error_code);
2320 }
2321 }
2322
2323 void cpu_unassigned_access(CPUMIPSState *env, hwaddr addr,
2324 int is_write, int is_exec, int unused, int size)
2325 {
2326 if (is_exec)
2327 helper_raise_exception(env, EXCP_IBE);
2328 else
2329 helper_raise_exception(env, EXCP_DBE);
2330 }
2331 #endif /* !CONFIG_USER_ONLY */
2332
2333 /* Complex FPU operations which may need stack space. */
2334
2335 #define FLOAT_TWO32 make_float32(1 << 30)
2336 #define FLOAT_TWO64 make_float64(1ULL << 62)
2337 #define FP_TO_INT32_OVERFLOW 0x7fffffff
2338 #define FP_TO_INT64_OVERFLOW 0x7fffffffffffffffULL
2339
2340 /* convert MIPS rounding mode in FCR31 to IEEE library */
2341 static unsigned int ieee_rm[] = {
2342 float_round_nearest_even,
2343 float_round_to_zero,
2344 float_round_up,
2345 float_round_down
2346 };
2347
2348 #define RESTORE_ROUNDING_MODE \
2349 set_float_rounding_mode(ieee_rm[env->active_fpu.fcr31 & 3], &env->active_fpu.fp_status)
2350
2351 #define RESTORE_FLUSH_MODE \
2352 set_flush_to_zero((env->active_fpu.fcr31 & (1 << 24)) != 0, &env->active_fpu.fp_status);
2353
2354 target_ulong helper_cfc1(CPUMIPSState *env, uint32_t reg)
2355 {
2356 target_ulong arg1;
2357
2358 switch (reg) {
2359 case 0:
2360 arg1 = (int32_t)env->active_fpu.fcr0;
2361 break;
2362 case 25:
2363 arg1 = ((env->active_fpu.fcr31 >> 24) & 0xfe) | ((env->active_fpu.fcr31 >> 23) & 0x1);
2364 break;
2365 case 26:
2366 arg1 = env->active_fpu.fcr31 & 0x0003f07c;
2367 break;
2368 case 28:
2369 arg1 = (env->active_fpu.fcr31 & 0x00000f83) | ((env->active_fpu.fcr31 >> 22) & 0x4);
2370 break;
2371 default:
2372 arg1 = (int32_t)env->active_fpu.fcr31;
2373 break;
2374 }
2375
2376 return arg1;
2377 }
2378
2379 void helper_ctc1(CPUMIPSState *env, target_ulong arg1, uint32_t reg)
2380 {
2381 switch(reg) {
2382 case 25:
2383 if (arg1 & 0xffffff00)
2384 return;
2385 env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0x017fffff) | ((arg1 & 0xfe) << 24) |
2386 ((arg1 & 0x1) << 23);
2387 break;
2388 case 26:
2389 if (arg1 & 0x007c0000)
2390 return;
2391 env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0xfffc0f83) | (arg1 & 0x0003f07c);
2392 break;
2393 case 28:
2394 if (arg1 & 0x007c0000)
2395 return;
2396 env->active_fpu.fcr31 = (env->active_fpu.fcr31 & 0xfefff07c) | (arg1 & 0x00000f83) |
2397 ((arg1 & 0x4) << 22);
2398 break;
2399 case 31:
2400 if (arg1 & 0x007c0000)
2401 return;
2402 env->active_fpu.fcr31 = arg1;
2403 break;
2404 default:
2405 return;
2406 }
2407 /* set rounding mode */
2408 RESTORE_ROUNDING_MODE;
2409 /* set flush-to-zero mode */
2410 RESTORE_FLUSH_MODE;
2411 set_float_exception_flags(0, &env->active_fpu.fp_status);
2412 if ((GET_FP_ENABLE(env->active_fpu.fcr31) | 0x20) & GET_FP_CAUSE(env->active_fpu.fcr31))
2413 helper_raise_exception(env, EXCP_FPE);
2414 }
2415
2416 static inline int ieee_ex_to_mips(int xcpt)
2417 {
2418 int ret = 0;
2419 if (xcpt) {
2420 if (xcpt & float_flag_invalid) {
2421 ret |= FP_INVALID;
2422 }
2423 if (xcpt & float_flag_overflow) {
2424 ret |= FP_OVERFLOW;
2425 }
2426 if (xcpt & float_flag_underflow) {
2427 ret |= FP_UNDERFLOW;
2428 }
2429 if (xcpt & float_flag_divbyzero) {
2430 ret |= FP_DIV0;
2431 }
2432 if (xcpt & float_flag_inexact) {
2433 ret |= FP_INEXACT;
2434 }
2435 }
2436 return ret;
2437 }
2438
2439 static inline void update_fcr31(CPUMIPSState *env)
2440 {
2441 int tmp = ieee_ex_to_mips(get_float_exception_flags(&env->active_fpu.fp_status));
2442
2443 SET_FP_CAUSE(env->active_fpu.fcr31, tmp);
2444
2445 if (tmp) {
2446 set_float_exception_flags(0, &env->active_fpu.fp_status);
2447
2448 if (GET_FP_ENABLE(env->active_fpu.fcr31) & tmp) {
2449 helper_raise_exception(env, EXCP_FPE);
2450 } else {
2451 UPDATE_FP_FLAGS(env->active_fpu.fcr31, tmp);
2452 }
2453 }
2454 }
2455
2456 /* Float support.
2457 Single precition routines have a "s" suffix, double precision a
2458 "d" suffix, 32bit integer "w", 64bit integer "l", paired single "ps",
2459 paired single lower "pl", paired single upper "pu". */
2460
2461 /* unary operations, modifying fp status */
2462 uint64_t helper_float_sqrt_d(CPUMIPSState *env, uint64_t fdt0)
2463 {
2464 fdt0 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2465 update_fcr31(env);
2466 return fdt0;
2467 }
2468
2469 uint32_t helper_float_sqrt_s(CPUMIPSState *env, uint32_t fst0)
2470 {
2471 fst0 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2472 update_fcr31(env);
2473 return fst0;
2474 }
2475
2476 uint64_t helper_float_cvtd_s(CPUMIPSState *env, uint32_t fst0)
2477 {
2478 uint64_t fdt2;
2479
2480 fdt2 = float32_to_float64(fst0, &env->active_fpu.fp_status);
2481 update_fcr31(env);
2482 return fdt2;
2483 }
2484
2485 uint64_t helper_float_cvtd_w(CPUMIPSState *env, uint32_t wt0)
2486 {
2487 uint64_t fdt2;
2488
2489 fdt2 = int32_to_float64(wt0, &env->active_fpu.fp_status);
2490 update_fcr31(env);
2491 return fdt2;
2492 }
2493
2494 uint64_t helper_float_cvtd_l(CPUMIPSState *env, uint64_t dt0)
2495 {
2496 uint64_t fdt2;
2497
2498 fdt2 = int64_to_float64(dt0, &env->active_fpu.fp_status);
2499 update_fcr31(env);
2500 return fdt2;
2501 }
2502
2503 uint64_t helper_float_cvtl_d(CPUMIPSState *env, uint64_t fdt0)
2504 {
2505 uint64_t dt2;
2506
2507 dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2508 if (get_float_exception_flags(&env->active_fpu.fp_status)
2509 & (float_flag_invalid | float_flag_overflow)) {
2510 dt2 = FP_TO_INT64_OVERFLOW;
2511 }
2512 update_fcr31(env);
2513 return dt2;
2514 }
2515
2516 uint64_t helper_float_cvtl_s(CPUMIPSState *env, uint32_t fst0)
2517 {
2518 uint64_t dt2;
2519
2520 dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2521 if (get_float_exception_flags(&env->active_fpu.fp_status)
2522 & (float_flag_invalid | float_flag_overflow)) {
2523 dt2 = FP_TO_INT64_OVERFLOW;
2524 }
2525 update_fcr31(env);
2526 return dt2;
2527 }
2528
2529 uint64_t helper_float_cvtps_pw(CPUMIPSState *env, uint64_t dt0)
2530 {
2531 uint32_t fst2;
2532 uint32_t fsth2;
2533
2534 fst2 = int32_to_float32(dt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2535 fsth2 = int32_to_float32(dt0 >> 32, &env->active_fpu.fp_status);
2536 update_fcr31(env);
2537 return ((uint64_t)fsth2 << 32) | fst2;
2538 }
2539
2540 uint64_t helper_float_cvtpw_ps(CPUMIPSState *env, uint64_t fdt0)
2541 {
2542 uint32_t wt2;
2543 uint32_t wth2;
2544 int excp, excph;
2545
2546 wt2 = float32_to_int32(fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2547 excp = get_float_exception_flags(&env->active_fpu.fp_status);
2548 if (excp & (float_flag_overflow | float_flag_invalid)) {
2549 wt2 = FP_TO_INT32_OVERFLOW;
2550 }
2551
2552 set_float_exception_flags(0, &env->active_fpu.fp_status);
2553 wth2 = float32_to_int32(fdt0 >> 32, &env->active_fpu.fp_status);
2554 excph = get_float_exception_flags(&env->active_fpu.fp_status);
2555 if (excph & (float_flag_overflow | float_flag_invalid)) {
2556 wth2 = FP_TO_INT32_OVERFLOW;
2557 }
2558
2559 set_float_exception_flags(excp | excph, &env->active_fpu.fp_status);
2560 update_fcr31(env);
2561
2562 return ((uint64_t)wth2 << 32) | wt2;
2563 }
2564
2565 uint32_t helper_float_cvts_d(CPUMIPSState *env, uint64_t fdt0)
2566 {
2567 uint32_t fst2;
2568
2569 fst2 = float64_to_float32(fdt0, &env->active_fpu.fp_status);
2570 update_fcr31(env);
2571 return fst2;
2572 }
2573
2574 uint32_t helper_float_cvts_w(CPUMIPSState *env, uint32_t wt0)
2575 {
2576 uint32_t fst2;
2577
2578 fst2 = int32_to_float32(wt0, &env->active_fpu.fp_status);
2579 update_fcr31(env);
2580 return fst2;
2581 }
2582
2583 uint32_t helper_float_cvts_l(CPUMIPSState *env, uint64_t dt0)
2584 {
2585 uint32_t fst2;
2586
2587 fst2 = int64_to_float32(dt0, &env->active_fpu.fp_status);
2588 update_fcr31(env);
2589 return fst2;
2590 }
2591
2592 uint32_t helper_float_cvts_pl(CPUMIPSState *env, uint32_t wt0)
2593 {
2594 uint32_t wt2;
2595
2596 wt2 = wt0;
2597 update_fcr31(env);
2598 return wt2;
2599 }
2600
2601 uint32_t helper_float_cvts_pu(CPUMIPSState *env, uint32_t wth0)
2602 {
2603 uint32_t wt2;
2604
2605 wt2 = wth0;
2606 update_fcr31(env);
2607 return wt2;
2608 }
2609
2610 uint32_t helper_float_cvtw_s(CPUMIPSState *env, uint32_t fst0)
2611 {
2612 uint32_t wt2;
2613
2614 wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2615 update_fcr31(env);
2616 if (get_float_exception_flags(&env->active_fpu.fp_status)
2617 & (float_flag_invalid | float_flag_overflow)) {
2618 wt2 = FP_TO_INT32_OVERFLOW;
2619 }
2620 return wt2;
2621 }
2622
2623 uint32_t helper_float_cvtw_d(CPUMIPSState *env, uint64_t fdt0)
2624 {
2625 uint32_t wt2;
2626
2627 wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2628 if (get_float_exception_flags(&env->active_fpu.fp_status)
2629 & (float_flag_invalid | float_flag_overflow)) {
2630 wt2 = FP_TO_INT32_OVERFLOW;
2631 }
2632 update_fcr31(env);
2633 return wt2;
2634 }
2635
2636 uint64_t helper_float_roundl_d(CPUMIPSState *env, uint64_t fdt0)
2637 {
2638 uint64_t dt2;
2639
2640 set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2641 dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2642 RESTORE_ROUNDING_MODE;
2643 if (get_float_exception_flags(&env->active_fpu.fp_status)
2644 & (float_flag_invalid | float_flag_overflow)) {
2645 dt2 = FP_TO_INT64_OVERFLOW;
2646 }
2647 update_fcr31(env);
2648 return dt2;
2649 }
2650
2651 uint64_t helper_float_roundl_s(CPUMIPSState *env, uint32_t fst0)
2652 {
2653 uint64_t dt2;
2654
2655 set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2656 dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2657 RESTORE_ROUNDING_MODE;
2658 if (get_float_exception_flags(&env->active_fpu.fp_status)
2659 & (float_flag_invalid | float_flag_overflow)) {
2660 dt2 = FP_TO_INT64_OVERFLOW;
2661 }
2662 update_fcr31(env);
2663 return dt2;
2664 }
2665
2666 uint32_t helper_float_roundw_d(CPUMIPSState *env, uint64_t fdt0)
2667 {
2668 uint32_t wt2;
2669
2670 set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2671 wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2672 RESTORE_ROUNDING_MODE;
2673 if (get_float_exception_flags(&env->active_fpu.fp_status)
2674 & (float_flag_invalid | float_flag_overflow)) {
2675 wt2 = FP_TO_INT32_OVERFLOW;
2676 }
2677 update_fcr31(env);
2678 return wt2;
2679 }
2680
2681 uint32_t helper_float_roundw_s(CPUMIPSState *env, uint32_t fst0)
2682 {
2683 uint32_t wt2;
2684
2685 set_float_rounding_mode(float_round_nearest_even, &env->active_fpu.fp_status);
2686 wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2687 RESTORE_ROUNDING_MODE;
2688 if (get_float_exception_flags(&env->active_fpu.fp_status)
2689 & (float_flag_invalid | float_flag_overflow)) {
2690 wt2 = FP_TO_INT32_OVERFLOW;
2691 }
2692 update_fcr31(env);
2693 return wt2;
2694 }
2695
2696 uint64_t helper_float_truncl_d(CPUMIPSState *env, uint64_t fdt0)
2697 {
2698 uint64_t dt2;
2699
2700 dt2 = float64_to_int64_round_to_zero(fdt0, &env->active_fpu.fp_status);
2701 if (get_float_exception_flags(&env->active_fpu.fp_status)
2702 & (float_flag_invalid | float_flag_overflow)) {
2703 dt2 = FP_TO_INT64_OVERFLOW;
2704 }
2705 update_fcr31(env);
2706 return dt2;
2707 }
2708
2709 uint64_t helper_float_truncl_s(CPUMIPSState *env, uint32_t fst0)
2710 {
2711 uint64_t dt2;
2712
2713 dt2 = float32_to_int64_round_to_zero(fst0, &env->active_fpu.fp_status);
2714 if (get_float_exception_flags(&env->active_fpu.fp_status)
2715 & (float_flag_invalid | float_flag_overflow)) {
2716 dt2 = FP_TO_INT64_OVERFLOW;
2717 }
2718 update_fcr31(env);
2719 return dt2;
2720 }
2721
2722 uint32_t helper_float_truncw_d(CPUMIPSState *env, uint64_t fdt0)
2723 {
2724 uint32_t wt2;
2725
2726 wt2 = float64_to_int32_round_to_zero(fdt0, &env->active_fpu.fp_status);
2727 if (get_float_exception_flags(&env->active_fpu.fp_status)
2728 & (float_flag_invalid | float_flag_overflow)) {
2729 wt2 = FP_TO_INT32_OVERFLOW;
2730 }
2731 update_fcr31(env);
2732 return wt2;
2733 }
2734
2735 uint32_t helper_float_truncw_s(CPUMIPSState *env, uint32_t fst0)
2736 {
2737 uint32_t wt2;
2738
2739 wt2 = float32_to_int32_round_to_zero(fst0, &env->active_fpu.fp_status);
2740 if (get_float_exception_flags(&env->active_fpu.fp_status)
2741 & (float_flag_invalid | float_flag_overflow)) {
2742 wt2 = FP_TO_INT32_OVERFLOW;
2743 }
2744 update_fcr31(env);
2745 return wt2;
2746 }
2747
2748 uint64_t helper_float_ceill_d(CPUMIPSState *env, uint64_t fdt0)
2749 {
2750 uint64_t dt2;
2751
2752 set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2753 dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2754 RESTORE_ROUNDING_MODE;
2755 if (get_float_exception_flags(&env->active_fpu.fp_status)
2756 & (float_flag_invalid | float_flag_overflow)) {
2757 dt2 = FP_TO_INT64_OVERFLOW;
2758 }
2759 update_fcr31(env);
2760 return dt2;
2761 }
2762
2763 uint64_t helper_float_ceill_s(CPUMIPSState *env, uint32_t fst0)
2764 {
2765 uint64_t dt2;
2766
2767 set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2768 dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2769 RESTORE_ROUNDING_MODE;
2770 if (get_float_exception_flags(&env->active_fpu.fp_status)
2771 & (float_flag_invalid | float_flag_overflow)) {
2772 dt2 = FP_TO_INT64_OVERFLOW;
2773 }
2774 update_fcr31(env);
2775 return dt2;
2776 }
2777
2778 uint32_t helper_float_ceilw_d(CPUMIPSState *env, uint64_t fdt0)
2779 {
2780 uint32_t wt2;
2781
2782 set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2783 wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2784 RESTORE_ROUNDING_MODE;
2785 if (get_float_exception_flags(&env->active_fpu.fp_status)
2786 & (float_flag_invalid | float_flag_overflow)) {
2787 wt2 = FP_TO_INT32_OVERFLOW;
2788 }
2789 update_fcr31(env);
2790 return wt2;
2791 }
2792
2793 uint32_t helper_float_ceilw_s(CPUMIPSState *env, uint32_t fst0)
2794 {
2795 uint32_t wt2;
2796
2797 set_float_rounding_mode(float_round_up, &env->active_fpu.fp_status);
2798 wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2799 RESTORE_ROUNDING_MODE;
2800 if (get_float_exception_flags(&env->active_fpu.fp_status)
2801 & (float_flag_invalid | float_flag_overflow)) {
2802 wt2 = FP_TO_INT32_OVERFLOW;
2803 }
2804 update_fcr31(env);
2805 return wt2;
2806 }
2807
2808 uint64_t helper_float_floorl_d(CPUMIPSState *env, uint64_t fdt0)
2809 {
2810 uint64_t dt2;
2811
2812 set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2813 dt2 = float64_to_int64(fdt0, &env->active_fpu.fp_status);
2814 RESTORE_ROUNDING_MODE;
2815 if (get_float_exception_flags(&env->active_fpu.fp_status)
2816 & (float_flag_invalid | float_flag_overflow)) {
2817 dt2 = FP_TO_INT64_OVERFLOW;
2818 }
2819 update_fcr31(env);
2820 return dt2;
2821 }
2822
2823 uint64_t helper_float_floorl_s(CPUMIPSState *env, uint32_t fst0)
2824 {
2825 uint64_t dt2;
2826
2827 set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2828 dt2 = float32_to_int64(fst0, &env->active_fpu.fp_status);
2829 RESTORE_ROUNDING_MODE;
2830 if (get_float_exception_flags(&env->active_fpu.fp_status)
2831 & (float_flag_invalid | float_flag_overflow)) {
2832 dt2 = FP_TO_INT64_OVERFLOW;
2833 }
2834 update_fcr31(env);
2835 return dt2;
2836 }
2837
2838 uint32_t helper_float_floorw_d(CPUMIPSState *env, uint64_t fdt0)
2839 {
2840 uint32_t wt2;
2841
2842 set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2843 wt2 = float64_to_int32(fdt0, &env->active_fpu.fp_status);
2844 RESTORE_ROUNDING_MODE;
2845 if (get_float_exception_flags(&env->active_fpu.fp_status)
2846 & (float_flag_invalid | float_flag_overflow)) {
2847 wt2 = FP_TO_INT32_OVERFLOW;
2848 }
2849 update_fcr31(env);
2850 return wt2;
2851 }
2852
2853 uint32_t helper_float_floorw_s(CPUMIPSState *env, uint32_t fst0)
2854 {
2855 uint32_t wt2;
2856
2857 set_float_rounding_mode(float_round_down, &env->active_fpu.fp_status);
2858 wt2 = float32_to_int32(fst0, &env->active_fpu.fp_status);
2859 RESTORE_ROUNDING_MODE;
2860 if (get_float_exception_flags(&env->active_fpu.fp_status)
2861 & (float_flag_invalid | float_flag_overflow)) {
2862 wt2 = FP_TO_INT32_OVERFLOW;
2863 }
2864 update_fcr31(env);
2865 return wt2;
2866 }
2867
2868 /* unary operations, not modifying fp status */
2869 #define FLOAT_UNOP(name) \
2870 uint64_t helper_float_ ## name ## _d(uint64_t fdt0) \
2871 { \
2872 return float64_ ## name(fdt0); \
2873 } \
2874 uint32_t helper_float_ ## name ## _s(uint32_t fst0) \
2875 { \
2876 return float32_ ## name(fst0); \
2877 } \
2878 uint64_t helper_float_ ## name ## _ps(uint64_t fdt0) \
2879 { \
2880 uint32_t wt0; \
2881 uint32_t wth0; \
2882 \
2883 wt0 = float32_ ## name(fdt0 & 0XFFFFFFFF); \
2884 wth0 = float32_ ## name(fdt0 >> 32); \
2885 return ((uint64_t)wth0 << 32) | wt0; \
2886 }
2887 FLOAT_UNOP(abs)
2888 FLOAT_UNOP(chs)
2889 #undef FLOAT_UNOP
2890
2891 /* MIPS specific unary operations */
2892 uint64_t helper_float_recip_d(CPUMIPSState *env, uint64_t fdt0)
2893 {
2894 uint64_t fdt2;
2895
2896 fdt2 = float64_div(float64_one, fdt0, &env->active_fpu.fp_status);
2897 update_fcr31(env);
2898 return fdt2;
2899 }
2900
2901 uint32_t helper_float_recip_s(CPUMIPSState *env, uint32_t fst0)
2902 {
2903 uint32_t fst2;
2904
2905 fst2 = float32_div(float32_one, fst0, &env->active_fpu.fp_status);
2906 update_fcr31(env);
2907 return fst2;
2908 }
2909
2910 uint64_t helper_float_rsqrt_d(CPUMIPSState *env, uint64_t fdt0)
2911 {
2912 uint64_t fdt2;
2913
2914 fdt2 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2915 fdt2 = float64_div(float64_one, fdt2, &env->active_fpu.fp_status);
2916 update_fcr31(env);
2917 return fdt2;
2918 }
2919
2920 uint32_t helper_float_rsqrt_s(CPUMIPSState *env, uint32_t fst0)
2921 {
2922 uint32_t fst2;
2923
2924 fst2 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2925 fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2926 update_fcr31(env);
2927 return fst2;
2928 }
2929
2930 uint64_t helper_float_recip1_d(CPUMIPSState *env, uint64_t fdt0)
2931 {
2932 uint64_t fdt2;
2933
2934 fdt2 = float64_div(float64_one, fdt0, &env->active_fpu.fp_status);
2935 update_fcr31(env);
2936 return fdt2;
2937 }
2938
2939 uint32_t helper_float_recip1_s(CPUMIPSState *env, uint32_t fst0)
2940 {
2941 uint32_t fst2;
2942
2943 fst2 = float32_div(float32_one, fst0, &env->active_fpu.fp_status);
2944 update_fcr31(env);
2945 return fst2;
2946 }
2947
2948 uint64_t helper_float_recip1_ps(CPUMIPSState *env, uint64_t fdt0)
2949 {
2950 uint32_t fst2;
2951 uint32_t fsth2;
2952
2953 fst2 = float32_div(float32_one, fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2954 fsth2 = float32_div(float32_one, fdt0 >> 32, &env->active_fpu.fp_status);
2955 update_fcr31(env);
2956 return ((uint64_t)fsth2 << 32) | fst2;
2957 }
2958
2959 uint64_t helper_float_rsqrt1_d(CPUMIPSState *env, uint64_t fdt0)
2960 {
2961 uint64_t fdt2;
2962
2963 fdt2 = float64_sqrt(fdt0, &env->active_fpu.fp_status);
2964 fdt2 = float64_div(float64_one, fdt2, &env->active_fpu.fp_status);
2965 update_fcr31(env);
2966 return fdt2;
2967 }
2968
2969 uint32_t helper_float_rsqrt1_s(CPUMIPSState *env, uint32_t fst0)
2970 {
2971 uint32_t fst2;
2972
2973 fst2 = float32_sqrt(fst0, &env->active_fpu.fp_status);
2974 fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2975 update_fcr31(env);
2976 return fst2;
2977 }
2978
2979 uint64_t helper_float_rsqrt1_ps(CPUMIPSState *env, uint64_t fdt0)
2980 {
2981 uint32_t fst2;
2982 uint32_t fsth2;
2983
2984 fst2 = float32_sqrt(fdt0 & 0XFFFFFFFF, &env->active_fpu.fp_status);
2985 fsth2 = float32_sqrt(fdt0 >> 32, &env->active_fpu.fp_status);
2986 fst2 = float32_div(float32_one, fst2, &env->active_fpu.fp_status);
2987 fsth2 = float32_div(float32_one, fsth2, &env->active_fpu.fp_status);
2988 update_fcr31(env);
2989 return ((uint64_t)fsth2 << 32) | fst2;
2990 }
2991
2992 #define FLOAT_OP(name, p) void helper_float_##name##_##p(CPUMIPSState *env)
2993
2994 /* binary operations */
2995 #define FLOAT_BINOP(name) \
2996 uint64_t helper_float_ ## name ## _d(CPUMIPSState *env, \
2997 uint64_t fdt0, uint64_t fdt1) \
2998 { \
2999 uint64_t dt2; \
3000 \
3001 dt2 = float64_ ## name (fdt0, fdt1, &env->active_fpu.fp_status); \
3002 update_fcr31(env); \
3003 return dt2; \
3004 } \
3005 \
3006 uint32_t helper_float_ ## name ## _s(CPUMIPSState *env, \
3007 uint32_t fst0, uint32_t fst1) \
3008 { \
3009 uint32_t wt2; \
3010 \
3011 wt2 = float32_ ## name (fst0, fst1, &env->active_fpu.fp_status); \
3012 update_fcr31(env); \
3013 return wt2; \
3014 } \
3015 \
3016 uint64_t helper_float_ ## name ## _ps(CPUMIPSState *env, \
3017 uint64_t fdt0, \
3018 uint64_t fdt1) \
3019 { \
3020 uint32_t fst0 = fdt0 & 0XFFFFFFFF; \
3021 uint32_t fsth0 = fdt0 >> 32; \
3022 uint32_t fst1 = fdt1 & 0XFFFFFFFF; \
3023 uint32_t fsth1 = fdt1 >> 32; \
3024 uint32_t wt2; \
3025 uint32_t wth2; \
3026 \
3027 wt2 = float32_ ## name (fst0, fst1, &env->active_fpu.fp_status); \
3028 wth2 = float32_ ## name (fsth0, fsth1, &env->active_fpu.fp_status); \
3029 update_fcr31(env); \
3030 return ((uint64_t)wth2 << 32) | wt2; \
3031 }
3032
3033 FLOAT_BINOP(add)
3034 FLOAT_BINOP(sub)
3035 FLOAT_BINOP(mul)
3036 FLOAT_BINOP(div)
3037 #undef FLOAT_BINOP
3038
3039 /* FMA based operations */
3040 #define FLOAT_FMA(name, type) \
3041 uint64_t helper_float_ ## name ## _d(CPUMIPSState *env, \
3042 uint64_t fdt0, uint64_t fdt1, \
3043 uint64_t fdt2) \
3044 { \
3045 fdt0 = float64_muladd(fdt0, fdt1, fdt2, type, \
3046 &env->active_fpu.fp_status); \
3047 update_fcr31(env); \
3048 return fdt0; \
3049 } \
3050 \
3051 uint32_t helper_float_ ## name ## _s(CPUMIPSState *env, \
3052 uint32_t fst0, uint32_t fst1, \
3053 uint32_t fst2) \
3054 { \
3055 fst0 = float32_muladd(fst0, fst1, fst2, type, \
3056 &env->active_fpu.fp_status); \
3057 update_fcr31(env); \
3058 return fst0; \
3059 } \
3060 \
3061 uint64_t helper_float_ ## name ## _ps(CPUMIPSState *env, \
3062 uint64_t fdt0, uint64_t fdt1, \
3063 uint64_t fdt2) \
3064 { \
3065 uint32_t fst0 = fdt0 & 0XFFFFFFFF; \
3066 uint32_t fsth0 = fdt0 >> 32; \
3067 uint32_t fst1 = fdt1 & 0XFFFFFFFF; \
3068 uint32_t fsth1 = fdt1 >> 32; \
3069 uint32_t fst2 = fdt2 & 0XFFFFFFFF; \
3070 uint32_t fsth2 = fdt2 >> 32; \
3071 \
3072 fst0 = float32_muladd(fst0, fst1, fst2, type, \
3073 &env->active_fpu.fp_status); \
3074 fsth0 = float32_muladd(fsth0, fsth1, fsth2, type, \
3075 &env->active_fpu.fp_status); \
3076 update_fcr31(env); \
3077 return ((uint64_t)fsth0 << 32) | fst0; \
3078 }
3079 FLOAT_FMA(madd, 0)
3080 FLOAT_FMA(msub, float_muladd_negate_c)
3081 FLOAT_FMA(nmadd, float_muladd_negate_result)
3082 FLOAT_FMA(nmsub, float_muladd_negate_result | float_muladd_negate_c)
3083 #undef FLOAT_FMA
3084
3085 /* MIPS specific binary operations */
3086 uint64_t helper_float_recip2_d(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3087 {
3088 fdt2 = float64_mul(fdt0, fdt2, &env->active_fpu.fp_status);
3089 fdt2 = float64_chs(float64_sub(fdt2, float64_one, &env->active_fpu.fp_status));
3090 update_fcr31(env);
3091 return fdt2;
3092 }
3093
3094 uint32_t helper_float_recip2_s(CPUMIPSState *env, uint32_t fst0, uint32_t fst2)
3095 {
3096 fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3097 fst2 = float32_chs(float32_sub(fst2, float32_one, &env->active_fpu.fp_status));
3098 update_fcr31(env);
3099 return fst2;
3100 }
3101
3102 uint64_t helper_float_recip2_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3103 {
3104 uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3105 uint32_t fsth0 = fdt0 >> 32;
3106 uint32_t fst2 = fdt2 & 0XFFFFFFFF;
3107 uint32_t fsth2 = fdt2 >> 32;
3108
3109 fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3110 fsth2 = float32_mul(fsth0, fsth2, &env->active_fpu.fp_status);
3111 fst2 = float32_chs(float32_sub(fst2, float32_one, &env->active_fpu.fp_status));
3112 fsth2 = float32_chs(float32_sub(fsth2, float32_one, &env->active_fpu.fp_status));
3113 update_fcr31(env);
3114 return ((uint64_t)fsth2 << 32) | fst2;
3115 }
3116
3117 uint64_t helper_float_rsqrt2_d(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3118 {
3119 fdt2 = float64_mul(fdt0, fdt2, &env->active_fpu.fp_status);
3120 fdt2 = float64_sub(fdt2, float64_one, &env->active_fpu.fp_status);
3121 fdt2 = float64_chs(float64_div(fdt2, FLOAT_TWO64, &env->active_fpu.fp_status));
3122 update_fcr31(env);
3123 return fdt2;
3124 }
3125
3126 uint32_t helper_float_rsqrt2_s(CPUMIPSState *env, uint32_t fst0, uint32_t fst2)
3127 {
3128 fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3129 fst2 = float32_sub(fst2, float32_one, &env->active_fpu.fp_status);
3130 fst2 = float32_chs(float32_div(fst2, FLOAT_TWO32, &env->active_fpu.fp_status));
3131 update_fcr31(env);
3132 return fst2;
3133 }
3134
3135 uint64_t helper_float_rsqrt2_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt2)
3136 {
3137 uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3138 uint32_t fsth0 = fdt0 >> 32;
3139 uint32_t fst2 = fdt2 & 0XFFFFFFFF;
3140 uint32_t fsth2 = fdt2 >> 32;
3141
3142 fst2 = float32_mul(fst0, fst2, &env->active_fpu.fp_status);
3143 fsth2 = float32_mul(fsth0, fsth2, &env->active_fpu.fp_status);
3144 fst2 = float32_sub(fst2, float32_one, &env->active_fpu.fp_status);
3145 fsth2 = float32_sub(fsth2, float32_one, &env->active_fpu.fp_status);
3146 fst2 = float32_chs(float32_div(fst2, FLOAT_TWO32, &env->active_fpu.fp_status));
3147 fsth2 = float32_chs(float32_div(fsth2, FLOAT_TWO32, &env->active_fpu.fp_status));
3148 update_fcr31(env);
3149 return ((uint64_t)fsth2 << 32) | fst2;
3150 }
3151
3152 uint64_t helper_float_addr_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt1)
3153 {
3154 uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3155 uint32_t fsth0 = fdt0 >> 32;
3156 uint32_t fst1 = fdt1 & 0XFFFFFFFF;
3157 uint32_t fsth1 = fdt1 >> 32;
3158 uint32_t fst2;
3159 uint32_t fsth2;
3160
3161 fst2 = float32_add (fst0, fsth0, &env->active_fpu.fp_status);
3162 fsth2 = float32_add (fst1, fsth1, &env->active_fpu.fp_status);
3163 update_fcr31(env);
3164 return ((uint64_t)fsth2 << 32) | fst2;
3165 }
3166
3167 uint64_t helper_float_mulr_ps(CPUMIPSState *env, uint64_t fdt0, uint64_t fdt1)
3168 {
3169 uint32_t fst0 = fdt0 & 0XFFFFFFFF;
3170 uint32_t fsth0 = fdt0 >> 32;
3171 uint32_t fst1 = fdt1 & 0XFFFFFFFF;
3172 uint32_t fsth1 = fdt1 >> 32;
3173 uint32_t fst2;
3174 uint32_t fsth2;
3175
3176 fst2 = float32_mul (fst0, fsth0, &env->active_fpu.fp_status);
3177 fsth2 = float32_mul (fst1, fsth1, &env->active_fpu.fp_status);
3178 update_fcr31(env);
3179 return ((uint64_t)fsth2 << 32) | fst2;
3180 }
3181
3182 /* compare operations */
3183 #define FOP_COND_D(op, cond) \
3184 void helper_cmp_d_ ## op(CPUMIPSState *env, uint64_t fdt0, \
3185 uint64_t fdt1, int cc) \
3186 { \
3187 int c; \
3188 c = cond; \
3189 update_fcr31(env); \
3190 if (c) \
3191 SET_FP_COND(cc, env->active_fpu); \
3192 else \
3193 CLEAR_FP_COND(cc, env->active_fpu); \
3194 } \
3195 void helper_cmpabs_d_ ## op(CPUMIPSState *env, uint64_t fdt0, \
3196 uint64_t fdt1, int cc) \
3197 { \
3198 int c; \
3199 fdt0 = float64_abs(fdt0); \
3200 fdt1 = float64_abs(fdt1); \
3201 c = cond; \
3202 update_fcr31(env); \
3203 if (c) \
3204 SET_FP_COND(cc, env->active_fpu); \
3205 else \
3206 CLEAR_FP_COND(cc, env->active_fpu); \
3207 }
3208
3209 /* NOTE: the comma operator will make "cond" to eval to false,
3210 * but float64_unordered_quiet() is still called. */
3211 FOP_COND_D(f, (float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status), 0))
3212 FOP_COND_D(un, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status))
3213 FOP_COND_D(eq, float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3214 FOP_COND_D(ueq, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status) || float64_eq_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3215 FOP_COND_D(olt, float64_lt_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3216 FOP_COND_D(ult, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status) || float64_lt_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3217 FOP_COND_D(ole, float64_le_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3218 FOP_COND_D(ule, float64_unordered_quiet(fdt1, fdt0, &env->active_fpu.fp_status) || float64_le_quiet(fdt0, fdt1, &env->active_fpu.fp_status))
3219 /* NOTE: the comma operator will make "cond" to eval to false,
3220 * but float64_unordered() is still called. */
3221 FOP_COND_D(sf, (float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status), 0))
3222 FOP_COND_D(ngle,float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status))
3223 FOP_COND_D(seq, float64_eq(fdt0, fdt1, &env->active_fpu.fp_status))
3224 FOP_COND_D(ngl, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) || float64_eq(fdt0, fdt1, &env->active_fpu.fp_status))
3225 FOP_COND_D(lt, float64_lt(fdt0, fdt1, &env->active_fpu.fp_status))
3226 FOP_COND_D(nge, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) || float64_lt(fdt0, fdt1, &env->active_fpu.fp_status))
3227 FOP_COND_D(le, float64_le(fdt0, fdt1, &env->active_fpu.fp_status))
3228 FOP_COND_D(ngt, float64_unordered(fdt1, fdt0, &env->active_fpu.fp_status) || float64_le(fdt0, fdt1, &env->active_fpu.fp_status))
3229
3230 #define FOP_COND_S(op, cond) \
3231 void helper_cmp_s_ ## op(CPUMIPSState *env, uint32_t fst0, \
3232 uint32_t fst1, int cc) \
3233 { \
3234 int c; \
3235 c = cond; \
3236 update_fcr31(env); \
3237 if (c) \
3238 SET_FP_COND(cc, env->active_fpu); \
3239 else \
3240 CLEAR_FP_COND(cc, env->active_fpu); \
3241 } \
3242 void helper_cmpabs_s_ ## op(CPUMIPSState *env, uint32_t fst0, \
3243 uint32_t fst1, int cc) \
3244 { \
3245 int c; \
3246 fst0 = float32_abs(fst0); \
3247 fst1 = float32_abs(fst1); \
3248 c = cond; \
3249 update_fcr31(env); \
3250 if (c) \
3251 SET_FP_COND(cc, env->active_fpu); \
3252 else \
3253 CLEAR_FP_COND(cc, env->active_fpu); \
3254 }
3255
3256 /* NOTE: the comma operator will make "cond" to eval to false,
3257 * but float32_unordered_quiet() is still called. */
3258 FOP_COND_S(f, (float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status), 0))
3259 FOP_COND_S(un, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status))
3260 FOP_COND_S(eq, float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status))
3261 FOP_COND_S(ueq, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status))
3262 FOP_COND_S(olt, float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status))
3263 FOP_COND_S(ult, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status))
3264 FOP_COND_S(ole, float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status))
3265 FOP_COND_S(ule, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status))
3266 /* NOTE: the comma operator will make "cond" to eval to false,
3267 * but float32_unordered() is still called. */
3268 FOP_COND_S(sf, (float32_unordered(fst1, fst0, &env->active_fpu.fp_status), 0))
3269 FOP_COND_S(ngle,float32_unordered(fst1, fst0, &env->active_fpu.fp_status))
3270 FOP_COND_S(seq, float32_eq(fst0, fst1, &env->active_fpu.fp_status))
3271 FOP_COND_S(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_eq(fst0, fst1, &env->active_fpu.fp_status))
3272 FOP_COND_S(lt, float32_lt(fst0, fst1, &env->active_fpu.fp_status))
3273 FOP_COND_S(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_lt(fst0, fst1, &env->active_fpu.fp_status))
3274 FOP_COND_S(le, float32_le(fst0, fst1, &env->active_fpu.fp_status))
3275 FOP_COND_S(ngt, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_le(fst0, fst1, &env->active_fpu.fp_status))
3276
3277 #define FOP_COND_PS(op, condl, condh) \
3278 void helper_cmp_ps_ ## op(CPUMIPSState *env, uint64_t fdt0, \
3279 uint64_t fdt1, int cc) \
3280 { \
3281 uint32_t fst0, fsth0, fst1, fsth1; \
3282 int ch, cl; \
3283 fst0 = fdt0 & 0XFFFFFFFF; \
3284 fsth0 = fdt0 >> 32; \
3285 fst1 = fdt1 & 0XFFFFFFFF; \
3286 fsth1 = fdt1 >> 32; \
3287 cl = condl; \
3288 ch = condh; \
3289 update_fcr31(env); \
3290 if (cl) \
3291 SET_FP_COND(cc, env->active_fpu); \
3292 else \
3293 CLEAR_FP_COND(cc, env->active_fpu); \
3294 if (ch) \
3295 SET_FP_COND(cc + 1, env->active_fpu); \
3296 else \
3297 CLEAR_FP_COND(cc + 1, env->active_fpu); \
3298 } \
3299 void helper_cmpabs_ps_ ## op(CPUMIPSState *env, uint64_t fdt0, \
3300 uint64_t fdt1, int cc) \
3301 { \
3302 uint32_t fst0, fsth0, fst1, fsth1; \
3303 int ch, cl; \
3304 fst0 = float32_abs(fdt0 & 0XFFFFFFFF); \
3305 fsth0 = float32_abs(fdt0 >> 32); \
3306 fst1 = float32_abs(fdt1 & 0XFFFFFFFF); \
3307 fsth1 = float32_abs(fdt1 >> 32); \
3308 cl = condl; \
3309 ch = condh; \
3310 update_fcr31(env); \
3311 if (cl) \
3312 SET_FP_COND(cc, env->active_fpu); \
3313 else \
3314 CLEAR_FP_COND(cc, env->active_fpu); \
3315 if (ch) \
3316 SET_FP_COND(cc + 1, env->active_fpu); \
3317 else \
3318 CLEAR_FP_COND(cc + 1, env->active_fpu); \
3319 }
3320
3321 /* NOTE: the comma operator will make "cond" to eval to false,
3322 * but float32_unordered_quiet() is still called. */
3323 FOP_COND_PS(f, (float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status), 0),
3324 (float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status), 0))
3325 FOP_COND_PS(un, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status),
3326 float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status))
3327 FOP_COND_PS(eq, float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status),
3328 float32_eq_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3329 FOP_COND_PS(ueq, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_eq_quiet(fst0, fst1, &env->active_fpu.fp_status),
3330 float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status) || float32_eq_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3331 FOP_COND_PS(olt, float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status),
3332 float32_lt_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3333 FOP_COND_PS(ult, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_lt_quiet(fst0, fst1, &env->active_fpu.fp_status),
3334 float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status) || float32_lt_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3335 FOP_COND_PS(ole, float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status),
3336 float32_le_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3337 FOP_COND_PS(ule, float32_unordered_quiet(fst1, fst0, &env->active_fpu.fp_status) || float32_le_quiet(fst0, fst1, &env->active_fpu.fp_status),
3338 float32_unordered_quiet(fsth1, fsth0, &env->active_fpu.fp_status) || float32_le_quiet(fsth0, fsth1, &env->active_fpu.fp_status))
3339 /* NOTE: the comma operator will make "cond" to eval to false,
3340 * but float32_unordered() is still called. */
3341 FOP_COND_PS(sf, (float32_unordered(fst1, fst0, &env->active_fpu.fp_status), 0),
3342 (float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status), 0))
3343 FOP_COND_PS(ngle,float32_unordered(fst1, fst0, &env->active_fpu.fp_status),
3344 float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status))
3345 FOP_COND_PS(seq, float32_eq(fst0, fst1, &env->active_fpu.fp_status),
3346 float32_eq(fsth0, fsth1, &env->active_fpu.fp_status))
3347 FOP_COND_PS(ngl, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_eq(fst0, fst1, &env->active_fpu.fp_status),
3348 float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status) || float32_eq(fsth0, fsth1, &env->active_fpu.fp_status))
3349 FOP_COND_PS(lt, float32_lt(fst0, fst1, &env->active_fpu.fp_status),
3350 float32_lt(fsth0, fsth1, &env->active_fpu.fp_status))
3351 FOP_COND_PS(nge, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_lt(fst0, fst1, &env->active_fpu.fp_status),
3352 float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status) || float32_lt(fsth0, fsth1, &env->active_fpu.fp_status))
3353 FOP_COND_PS(le, float32_le(fst0, fst1, &env->active_fpu.fp_status),
3354 float32_le(fsth0, fsth1, &env->active_fpu.fp_status))
3355 FOP_COND_PS(ngt, float32_unordered(fst1, fst0, &env->active_fpu.fp_status) || float32_le(fst0, fst1, &env->active_fpu.fp_status),
3356 float32_unordered(fsth1, fsth0, &env->active_fpu.fp_status) || float32_le(fsth0, fsth1, &env->active_fpu.fp_status))
QEMU mirror