]> git.proxmox.com Git - qemu.git/blob - target-ppc/op_helper.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
target-ppc: convert lscbx instruction to TCG
[qemu.git] / target-ppc / op_helper.c
1 /*
2 * PowerPC emulation helpers for qemu.
3 *
4 * Copyright (c) 2003-2007 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, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20 #include "exec.h"
21 #include "host-utils.h"
22 #include "helper.h"
23
24 #include "helper_regs.h"
25 #include "op_helper.h"
26
27 //#define DEBUG_OP
28 //#define DEBUG_EXCEPTIONS
29 //#define DEBUG_SOFTWARE_TLB
30
31 /*****************************************************************************/
32 /* Exceptions processing helpers */
33
34 void helper_raise_exception_err (uint32_t exception, uint32_t error_code)
35 {
36 raise_exception_err(env, exception, error_code);
37 }
38
39 void helper_raise_debug (void)
40 {
41 raise_exception(env, EXCP_DEBUG);
42 }
43
44 /*****************************************************************************/
45 /* Registers load and stores */
46 target_ulong helper_load_cr (void)
47 {
48 return (env->crf[0] << 28) |
49 (env->crf[1] << 24) |
50 (env->crf[2] << 20) |
51 (env->crf[3] << 16) |
52 (env->crf[4] << 12) |
53 (env->crf[5] << 8) |
54 (env->crf[6] << 4) |
55 (env->crf[7] << 0);
56 }
57
58 void helper_store_cr (target_ulong val, uint32_t mask)
59 {
60 int i, sh;
61
62 for (i = 0, sh = 7; i < 8; i++, sh--) {
63 if (mask & (1 << sh))
64 env->crf[i] = (val >> (sh * 4)) & 0xFUL;
65 }
66 }
67
68 #if defined(TARGET_PPC64)
69 void do_store_pri (int prio)
70 {
71 env->spr[SPR_PPR] &= ~0x001C000000000000ULL;
72 env->spr[SPR_PPR] |= ((uint64_t)prio & 0x7) << 50;
73 }
74 #endif
75
76 target_ulong ppc_load_dump_spr (int sprn)
77 {
78 if (loglevel != 0) {
79 fprintf(logfile, "Read SPR %d %03x => " ADDRX "\n",
80 sprn, sprn, env->spr[sprn]);
81 }
82
83 return env->spr[sprn];
84 }
85
86 void ppc_store_dump_spr (int sprn, target_ulong val)
87 {
88 if (loglevel != 0) {
89 fprintf(logfile, "Write SPR %d %03x => " ADDRX " <= " ADDRX "\n",
90 sprn, sprn, env->spr[sprn], val);
91 }
92 env->spr[sprn] = val;
93 }
94
95 /*****************************************************************************/
96 /* Memory load and stores */
97
98 static always_inline target_ulong get_addr(target_ulong addr)
99 {
100 #if defined(TARGET_PPC64)
101 if (msr_sf)
102 return addr;
103 else
104 #endif
105 return (uint32_t)addr;
106 }
107
108 void helper_lmw (target_ulong addr, uint32_t reg)
109 {
110 #ifdef CONFIG_USER_ONLY
111 #define ldfun ldl_raw
112 #else
113 int (*ldfun)(target_ulong);
114
115 switch (env->mmu_idx) {
116 default:
117 case 0: ldfun = ldl_user;
118 break;
119 case 1: ldfun = ldl_kernel;
120 break;
121 case 2: ldfun = ldl_hypv;
122 break;
123 }
124 #endif
125 for (; reg < 32; reg++, addr += 4) {
126 if (msr_le)
127 env->gpr[reg] = bswap32(ldfun(get_addr(addr)));
128 else
129 env->gpr[reg] = ldfun(get_addr(addr));
130 }
131 }
132
133 void helper_stmw (target_ulong addr, uint32_t reg)
134 {
135 #ifdef CONFIG_USER_ONLY
136 #define stfun stl_raw
137 #else
138 void (*stfun)(target_ulong, int);
139
140 switch (env->mmu_idx) {
141 default:
142 case 0: stfun = stl_user;
143 break;
144 case 1: stfun = stl_kernel;
145 break;
146 case 2: stfun = stl_hypv;
147 break;
148 }
149 #endif
150 for (; reg < 32; reg++, addr += 4) {
151 if (msr_le)
152 stfun(get_addr(addr), bswap32((uint32_t)env->gpr[reg]));
153 else
154 stfun(get_addr(addr), (uint32_t)env->gpr[reg]);
155 }
156 }
157
158 void helper_lsw(target_ulong addr, uint32_t nb, uint32_t reg)
159 {
160 int sh;
161 #ifdef CONFIG_USER_ONLY
162 #define ldfunl ldl_raw
163 #define ldfunb ldub_raw
164 #else
165 int (*ldfunl)(target_ulong);
166 int (*ldfunb)(target_ulong);
167
168 switch (env->mmu_idx) {
169 default:
170 case 0:
171 ldfunl = ldl_user;
172 ldfunb = ldub_user;
173 break;
174 case 1:
175 ldfunl = ldl_kernel;
176 ldfunb = ldub_kernel;
177 break;
178 case 2:
179 ldfunl = ldl_hypv;
180 ldfunb = ldub_hypv;
181 break;
182 }
183 #endif
184 for (; nb > 3; nb -= 4, addr += 4) {
185 env->gpr[reg] = ldfunl(get_addr(addr));
186 reg = (reg + 1) % 32;
187 }
188 if (unlikely(nb > 0)) {
189 env->gpr[reg] = 0;
190 for (sh = 24; nb > 0; nb--, addr++, sh -= 8) {
191 env->gpr[reg] |= ldfunb(get_addr(addr)) << sh;
192 }
193 }
194 }
195 /* PPC32 specification says we must generate an exception if
196 * rA is in the range of registers to be loaded.
197 * In an other hand, IBM says this is valid, but rA won't be loaded.
198 * For now, I'll follow the spec...
199 */
200 void helper_lswx(target_ulong addr, uint32_t reg, uint32_t ra, uint32_t rb)
201 {
202 if (likely(xer_bc != 0)) {
203 if (unlikely((ra != 0 && reg < ra && (reg + xer_bc) > ra) ||
204 (reg < rb && (reg + xer_bc) > rb))) {
205 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
206 POWERPC_EXCP_INVAL |
207 POWERPC_EXCP_INVAL_LSWX);
208 } else {
209 helper_lsw(addr, xer_bc, reg);
210 }
211 }
212 }
213
214 void helper_stsw(target_ulong addr, uint32_t nb, uint32_t reg)
215 {
216 int sh;
217 #ifdef CONFIG_USER_ONLY
218 #define stfunl stl_raw
219 #define stfunb stb_raw
220 #else
221 void (*stfunl)(target_ulong, int);
222 void (*stfunb)(target_ulong, int);
223
224 switch (env->mmu_idx) {
225 default:
226 case 0:
227 stfunl = stl_user;
228 stfunb = stb_user;
229 break;
230 case 1:
231 stfunl = stl_kernel;
232 stfunb = stb_kernel;
233 break;
234 case 2:
235 stfunl = stl_hypv;
236 stfunb = stb_hypv;
237 break;
238 }
239 #endif
240
241 for (; nb > 3; nb -= 4, addr += 4) {
242 stfunl(get_addr(addr), env->gpr[reg]);
243 reg = (reg + 1) % 32;
244 }
245 if (unlikely(nb > 0)) {
246 for (sh = 24; nb > 0; nb--, addr++, sh -= 8)
247 stfunb(get_addr(addr), (env->gpr[reg] >> sh) & 0xFF);
248 }
249 }
250
251 static void do_dcbz(target_ulong addr, int dcache_line_size)
252 {
253 target_long mask = get_addr(~(dcache_line_size - 1));
254 int i;
255 #ifdef CONFIG_USER_ONLY
256 #define stfun stl_raw
257 #else
258 void (*stfun)(target_ulong, int);
259
260 switch (env->mmu_idx) {
261 default:
262 case 0: stfun = stl_user;
263 break;
264 case 1: stfun = stl_kernel;
265 break;
266 case 2: stfun = stl_hypv;
267 break;
268 }
269 #endif
270 addr &= mask;
271 for (i = 0 ; i < dcache_line_size ; i += 4) {
272 stfun(addr + i , 0);
273 }
274 if ((env->reserve & mask) == addr)
275 env->reserve = (target_ulong)-1ULL;
276 }
277
278 void helper_dcbz(target_ulong addr)
279 {
280 do_dcbz(addr, env->dcache_line_size);
281 }
282
283 void helper_dcbz_970(target_ulong addr)
284 {
285 if (((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1)
286 do_dcbz(addr, 32);
287 else
288 do_dcbz(addr, env->dcache_line_size);
289 }
290
291 void helper_icbi(target_ulong addr)
292 {
293 uint32_t tmp;
294
295 addr = get_addr(addr & ~(env->dcache_line_size - 1));
296 /* Invalidate one cache line :
297 * PowerPC specification says this is to be treated like a load
298 * (not a fetch) by the MMU. To be sure it will be so,
299 * do the load "by hand".
300 */
301 #ifdef CONFIG_USER_ONLY
302 tmp = ldl_raw(addr);
303 #else
304 switch (env->mmu_idx) {
305 default:
306 case 0: tmp = ldl_user(addr);
307 break;
308 case 1: tmp = ldl_kernel(addr);
309 break;
310 case 2: tmp = ldl_hypv(addr);
311 break;
312 }
313 #endif
314 tb_invalidate_page_range(addr, addr + env->icache_line_size);
315 }
316
317 // XXX: to be tested
318 target_ulong helper_lscbx (target_ulong addr, uint32_t reg, uint32_t ra, uint32_t rb)
319 {
320 int i, c, d;
321 #ifdef CONFIG_USER_ONLY
322 #define ldfun ldub_raw
323 #else
324 int (*ldfun)(target_ulong);
325
326 switch (env->mmu_idx) {
327 default:
328 case 0: ldfun = ldub_user;
329 break;
330 case 1: ldfun = ldub_kernel;
331 break;
332 case 2: ldfun = ldub_hypv;
333 break;
334 }
335 #endif
336 d = 24;
337 for (i = 0; i < xer_bc; i++) {
338 c = ldfun((uint32_t)addr++);
339 /* ra (if not 0) and rb are never modified */
340 if (likely(reg != rb && (ra == 0 || reg != ra))) {
341 env->gpr[reg] = (env->gpr[reg] & ~(0xFF << d)) | (c << d);
342 }
343 if (unlikely(c == xer_cmp))
344 break;
345 if (likely(d != 0)) {
346 d -= 8;
347 } else {
348 d = 24;
349 reg++;
350 reg = reg & 0x1F;
351 }
352 }
353 return i;
354 }
355
356 /*****************************************************************************/
357 /* Fixed point operations helpers */
358 #if defined(TARGET_PPC64)
359
360 /* multiply high word */
361 uint64_t helper_mulhd (uint64_t arg1, uint64_t arg2)
362 {
363 uint64_t tl, th;
364
365 muls64(&tl, &th, arg1, arg2);
366 return th;
367 }
368
369 /* multiply high word unsigned */
370 uint64_t helper_mulhdu (uint64_t arg1, uint64_t arg2)
371 {
372 uint64_t tl, th;
373
374 mulu64(&tl, &th, arg1, arg2);
375 return th;
376 }
377
378 uint64_t helper_mulldo (uint64_t arg1, uint64_t arg2)
379 {
380 int64_t th;
381 uint64_t tl;
382
383 muls64(&tl, (uint64_t *)&th, arg1, arg2);
384 /* If th != 0 && th != -1, then we had an overflow */
385 if (likely((uint64_t)(th + 1) <= 1)) {
386 env->xer &= ~(1 << XER_OV);
387 } else {
388 env->xer |= (1 << XER_OV) | (1 << XER_SO);
389 }
390 return (int64_t)tl;
391 }
392 #endif
393
394 target_ulong helper_cntlzw (target_ulong t)
395 {
396 return clz32(t);
397 }
398
399 #if defined(TARGET_PPC64)
400 target_ulong helper_cntlzd (target_ulong t)
401 {
402 return clz64(t);
403 }
404 #endif
405
406 /* shift right arithmetic helper */
407 target_ulong helper_sraw (target_ulong value, target_ulong shift)
408 {
409 int32_t ret;
410
411 if (likely(!(shift & 0x20))) {
412 if (likely((uint32_t)shift != 0)) {
413 shift &= 0x1f;
414 ret = (int32_t)value >> shift;
415 if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
416 env->xer &= ~(1 << XER_CA);
417 } else {
418 env->xer |= (1 << XER_CA);
419 }
420 } else {
421 ret = (int32_t)value;
422 env->xer &= ~(1 << XER_CA);
423 }
424 } else {
425 ret = (int32_t)value >> 31;
426 if (ret) {
427 env->xer |= (1 << XER_CA);
428 } else {
429 env->xer &= ~(1 << XER_CA);
430 }
431 }
432 return (target_long)ret;
433 }
434
435 #if defined(TARGET_PPC64)
436 target_ulong helper_srad (target_ulong value, target_ulong shift)
437 {
438 int64_t ret;
439
440 if (likely(!(shift & 0x40))) {
441 if (likely((uint64_t)shift != 0)) {
442 shift &= 0x3f;
443 ret = (int64_t)value >> shift;
444 if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
445 env->xer &= ~(1 << XER_CA);
446 } else {
447 env->xer |= (1 << XER_CA);
448 }
449 } else {
450 ret = (int64_t)value;
451 env->xer &= ~(1 << XER_CA);
452 }
453 } else {
454 ret = (int64_t)value >> 63;
455 if (ret) {
456 env->xer |= (1 << XER_CA);
457 } else {
458 env->xer &= ~(1 << XER_CA);
459 }
460 }
461 return ret;
462 }
463 #endif
464
465 target_ulong helper_popcntb (target_ulong val)
466 {
467 val = (val & 0x55555555) + ((val >> 1) & 0x55555555);
468 val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
469 val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f);
470 return val;
471 }
472
473 #if defined(TARGET_PPC64)
474 target_ulong helper_popcntb_64 (target_ulong val)
475 {
476 val = (val & 0x5555555555555555ULL) + ((val >> 1) & 0x5555555555555555ULL);
477 val = (val & 0x3333333333333333ULL) + ((val >> 2) & 0x3333333333333333ULL);
478 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 0x0f0f0f0f0f0f0f0fULL);
479 return val;
480 }
481 #endif
482
483 /*****************************************************************************/
484 /* Floating point operations helpers */
485 uint64_t helper_float32_to_float64(uint32_t arg)
486 {
487 CPU_FloatU f;
488 CPU_DoubleU d;
489 f.l = arg;
490 d.d = float32_to_float64(f.f, &env->fp_status);
491 return d.ll;
492 }
493
494 uint32_t helper_float64_to_float32(uint64_t arg)
495 {
496 CPU_FloatU f;
497 CPU_DoubleU d;
498 d.ll = arg;
499 f.f = float64_to_float32(d.d, &env->fp_status);
500 return f.l;
501 }
502
503 static always_inline int fpisneg (float64 d)
504 {
505 CPU_DoubleU u;
506
507 u.d = d;
508
509 return u.ll >> 63 != 0;
510 }
511
512 static always_inline int isden (float64 d)
513 {
514 CPU_DoubleU u;
515
516 u.d = d;
517
518 return ((u.ll >> 52) & 0x7FF) == 0;
519 }
520
521 static always_inline int iszero (float64 d)
522 {
523 CPU_DoubleU u;
524
525 u.d = d;
526
527 return (u.ll & ~0x8000000000000000ULL) == 0;
528 }
529
530 static always_inline int isinfinity (float64 d)
531 {
532 CPU_DoubleU u;
533
534 u.d = d;
535
536 return ((u.ll >> 52) & 0x7FF) == 0x7FF &&
537 (u.ll & 0x000FFFFFFFFFFFFFULL) == 0;
538 }
539
540 #ifdef CONFIG_SOFTFLOAT
541 static always_inline int isfinite (float64 d)
542 {
543 CPU_DoubleU u;
544
545 u.d = d;
546
547 return (((u.ll >> 52) & 0x7FF) != 0x7FF);
548 }
549
550 static always_inline int isnormal (float64 d)
551 {
552 CPU_DoubleU u;
553
554 u.d = d;
555
556 uint32_t exp = (u.ll >> 52) & 0x7FF;
557 return ((0 < exp) && (exp < 0x7FF));
558 }
559 #endif
560
561 uint32_t helper_compute_fprf (uint64_t arg, uint32_t set_fprf)
562 {
563 CPU_DoubleU farg;
564 int isneg;
565 int ret;
566 farg.ll = arg;
567 isneg = fpisneg(farg.d);
568 if (unlikely(float64_is_nan(farg.d))) {
569 if (float64_is_signaling_nan(farg.d)) {
570 /* Signaling NaN: flags are undefined */
571 ret = 0x00;
572 } else {
573 /* Quiet NaN */
574 ret = 0x11;
575 }
576 } else if (unlikely(isinfinity(farg.d))) {
577 /* +/- infinity */
578 if (isneg)
579 ret = 0x09;
580 else
581 ret = 0x05;
582 } else {
583 if (iszero(farg.d)) {
584 /* +/- zero */
585 if (isneg)
586 ret = 0x12;
587 else
588 ret = 0x02;
589 } else {
590 if (isden(farg.d)) {
591 /* Denormalized numbers */
592 ret = 0x10;
593 } else {
594 /* Normalized numbers */
595 ret = 0x00;
596 }
597 if (isneg) {
598 ret |= 0x08;
599 } else {
600 ret |= 0x04;
601 }
602 }
603 }
604 if (set_fprf) {
605 /* We update FPSCR_FPRF */
606 env->fpscr &= ~(0x1F << FPSCR_FPRF);
607 env->fpscr |= ret << FPSCR_FPRF;
608 }
609 /* We just need fpcc to update Rc1 */
610 return ret & 0xF;
611 }
612
613 /* Floating-point invalid operations exception */
614 static always_inline uint64_t fload_invalid_op_excp (int op)
615 {
616 uint64_t ret = 0;
617 int ve;
618
619 ve = fpscr_ve;
620 if (op & POWERPC_EXCP_FP_VXSNAN) {
621 /* Operation on signaling NaN */
622 env->fpscr |= 1 << FPSCR_VXSNAN;
623 }
624 if (op & POWERPC_EXCP_FP_VXSOFT) {
625 /* Software-defined condition */
626 env->fpscr |= 1 << FPSCR_VXSOFT;
627 }
628 switch (op & ~(POWERPC_EXCP_FP_VXSOFT | POWERPC_EXCP_FP_VXSNAN)) {
629 case POWERPC_EXCP_FP_VXISI:
630 /* Magnitude subtraction of infinities */
631 env->fpscr |= 1 << FPSCR_VXISI;
632 goto update_arith;
633 case POWERPC_EXCP_FP_VXIDI:
634 /* Division of infinity by infinity */
635 env->fpscr |= 1 << FPSCR_VXIDI;
636 goto update_arith;
637 case POWERPC_EXCP_FP_VXZDZ:
638 /* Division of zero by zero */
639 env->fpscr |= 1 << FPSCR_VXZDZ;
640 goto update_arith;
641 case POWERPC_EXCP_FP_VXIMZ:
642 /* Multiplication of zero by infinity */
643 env->fpscr |= 1 << FPSCR_VXIMZ;
644 goto update_arith;
645 case POWERPC_EXCP_FP_VXVC:
646 /* Ordered comparison of NaN */
647 env->fpscr |= 1 << FPSCR_VXVC;
648 env->fpscr &= ~(0xF << FPSCR_FPCC);
649 env->fpscr |= 0x11 << FPSCR_FPCC;
650 /* We must update the target FPR before raising the exception */
651 if (ve != 0) {
652 env->exception_index = POWERPC_EXCP_PROGRAM;
653 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_VXVC;
654 /* Update the floating-point enabled exception summary */
655 env->fpscr |= 1 << FPSCR_FEX;
656 /* Exception is differed */
657 ve = 0;
658 }
659 break;
660 case POWERPC_EXCP_FP_VXSQRT:
661 /* Square root of a negative number */
662 env->fpscr |= 1 << FPSCR_VXSQRT;
663 update_arith:
664 env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
665 if (ve == 0) {
666 /* Set the result to quiet NaN */
667 ret = UINT64_MAX;
668 env->fpscr &= ~(0xF << FPSCR_FPCC);
669 env->fpscr |= 0x11 << FPSCR_FPCC;
670 }
671 break;
672 case POWERPC_EXCP_FP_VXCVI:
673 /* Invalid conversion */
674 env->fpscr |= 1 << FPSCR_VXCVI;
675 env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
676 if (ve == 0) {
677 /* Set the result to quiet NaN */
678 ret = UINT64_MAX;
679 env->fpscr &= ~(0xF << FPSCR_FPCC);
680 env->fpscr |= 0x11 << FPSCR_FPCC;
681 }
682 break;
683 }
684 /* Update the floating-point invalid operation summary */
685 env->fpscr |= 1 << FPSCR_VX;
686 /* Update the floating-point exception summary */
687 env->fpscr |= 1 << FPSCR_FX;
688 if (ve != 0) {
689 /* Update the floating-point enabled exception summary */
690 env->fpscr |= 1 << FPSCR_FEX;
691 if (msr_fe0 != 0 || msr_fe1 != 0)
692 raise_exception_err(env, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_FP | op);
693 }
694 return ret;
695 }
696
697 static always_inline uint64_t float_zero_divide_excp (uint64_t arg1, uint64_t arg2)
698 {
699 env->fpscr |= 1 << FPSCR_ZX;
700 env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
701 /* Update the floating-point exception summary */
702 env->fpscr |= 1 << FPSCR_FX;
703 if (fpscr_ze != 0) {
704 /* Update the floating-point enabled exception summary */
705 env->fpscr |= 1 << FPSCR_FEX;
706 if (msr_fe0 != 0 || msr_fe1 != 0) {
707 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
708 POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX);
709 }
710 } else {
711 /* Set the result to infinity */
712 arg1 = ((arg1 ^ arg2) & 0x8000000000000000ULL);
713 arg1 |= 0x7FFULL << 52;
714 }
715 return arg1;
716 }
717
718 static always_inline void float_overflow_excp (void)
719 {
720 env->fpscr |= 1 << FPSCR_OX;
721 /* Update the floating-point exception summary */
722 env->fpscr |= 1 << FPSCR_FX;
723 if (fpscr_oe != 0) {
724 /* XXX: should adjust the result */
725 /* Update the floating-point enabled exception summary */
726 env->fpscr |= 1 << FPSCR_FEX;
727 /* We must update the target FPR before raising the exception */
728 env->exception_index = POWERPC_EXCP_PROGRAM;
729 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_OX;
730 } else {
731 env->fpscr |= 1 << FPSCR_XX;
732 env->fpscr |= 1 << FPSCR_FI;
733 }
734 }
735
736 static always_inline void float_underflow_excp (void)
737 {
738 env->fpscr |= 1 << FPSCR_UX;
739 /* Update the floating-point exception summary */
740 env->fpscr |= 1 << FPSCR_FX;
741 if (fpscr_ue != 0) {
742 /* XXX: should adjust the result */
743 /* Update the floating-point enabled exception summary */
744 env->fpscr |= 1 << FPSCR_FEX;
745 /* We must update the target FPR before raising the exception */
746 env->exception_index = POWERPC_EXCP_PROGRAM;
747 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_UX;
748 }
749 }
750
751 static always_inline void float_inexact_excp (void)
752 {
753 env->fpscr |= 1 << FPSCR_XX;
754 /* Update the floating-point exception summary */
755 env->fpscr |= 1 << FPSCR_FX;
756 if (fpscr_xe != 0) {
757 /* Update the floating-point enabled exception summary */
758 env->fpscr |= 1 << FPSCR_FEX;
759 /* We must update the target FPR before raising the exception */
760 env->exception_index = POWERPC_EXCP_PROGRAM;
761 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_XX;
762 }
763 }
764
765 static always_inline void fpscr_set_rounding_mode (void)
766 {
767 int rnd_type;
768
769 /* Set rounding mode */
770 switch (fpscr_rn) {
771 case 0:
772 /* Best approximation (round to nearest) */
773 rnd_type = float_round_nearest_even;
774 break;
775 case 1:
776 /* Smaller magnitude (round toward zero) */
777 rnd_type = float_round_to_zero;
778 break;
779 case 2:
780 /* Round toward +infinite */
781 rnd_type = float_round_up;
782 break;
783 default:
784 case 3:
785 /* Round toward -infinite */
786 rnd_type = float_round_down;
787 break;
788 }
789 set_float_rounding_mode(rnd_type, &env->fp_status);
790 }
791
792 void helper_fpscr_setbit (uint32_t bit)
793 {
794 int prev;
795
796 prev = (env->fpscr >> bit) & 1;
797 env->fpscr |= 1 << bit;
798 if (prev == 0) {
799 switch (bit) {
800 case FPSCR_VX:
801 env->fpscr |= 1 << FPSCR_FX;
802 if (fpscr_ve)
803 goto raise_ve;
804 case FPSCR_OX:
805 env->fpscr |= 1 << FPSCR_FX;
806 if (fpscr_oe)
807 goto raise_oe;
808 break;
809 case FPSCR_UX:
810 env->fpscr |= 1 << FPSCR_FX;
811 if (fpscr_ue)
812 goto raise_ue;
813 break;
814 case FPSCR_ZX:
815 env->fpscr |= 1 << FPSCR_FX;
816 if (fpscr_ze)
817 goto raise_ze;
818 break;
819 case FPSCR_XX:
820 env->fpscr |= 1 << FPSCR_FX;
821 if (fpscr_xe)
822 goto raise_xe;
823 break;
824 case FPSCR_VXSNAN:
825 case FPSCR_VXISI:
826 case FPSCR_VXIDI:
827 case FPSCR_VXZDZ:
828 case FPSCR_VXIMZ:
829 case FPSCR_VXVC:
830 case FPSCR_VXSOFT:
831 case FPSCR_VXSQRT:
832 case FPSCR_VXCVI:
833 env->fpscr |= 1 << FPSCR_VX;
834 env->fpscr |= 1 << FPSCR_FX;
835 if (fpscr_ve != 0)
836 goto raise_ve;
837 break;
838 case FPSCR_VE:
839 if (fpscr_vx != 0) {
840 raise_ve:
841 env->error_code = POWERPC_EXCP_FP;
842 if (fpscr_vxsnan)
843 env->error_code |= POWERPC_EXCP_FP_VXSNAN;
844 if (fpscr_vxisi)
845 env->error_code |= POWERPC_EXCP_FP_VXISI;
846 if (fpscr_vxidi)
847 env->error_code |= POWERPC_EXCP_FP_VXIDI;
848 if (fpscr_vxzdz)
849 env->error_code |= POWERPC_EXCP_FP_VXZDZ;
850 if (fpscr_vximz)
851 env->error_code |= POWERPC_EXCP_FP_VXIMZ;
852 if (fpscr_vxvc)
853 env->error_code |= POWERPC_EXCP_FP_VXVC;
854 if (fpscr_vxsoft)
855 env->error_code |= POWERPC_EXCP_FP_VXSOFT;
856 if (fpscr_vxsqrt)
857 env->error_code |= POWERPC_EXCP_FP_VXSQRT;
858 if (fpscr_vxcvi)
859 env->error_code |= POWERPC_EXCP_FP_VXCVI;
860 goto raise_excp;
861 }
862 break;
863 case FPSCR_OE:
864 if (fpscr_ox != 0) {
865 raise_oe:
866 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_OX;
867 goto raise_excp;
868 }
869 break;
870 case FPSCR_UE:
871 if (fpscr_ux != 0) {
872 raise_ue:
873 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_UX;
874 goto raise_excp;
875 }
876 break;
877 case FPSCR_ZE:
878 if (fpscr_zx != 0) {
879 raise_ze:
880 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX;
881 goto raise_excp;
882 }
883 break;
884 case FPSCR_XE:
885 if (fpscr_xx != 0) {
886 raise_xe:
887 env->error_code = POWERPC_EXCP_FP | POWERPC_EXCP_FP_XX;
888 goto raise_excp;
889 }
890 break;
891 case FPSCR_RN1:
892 case FPSCR_RN:
893 fpscr_set_rounding_mode();
894 break;
895 default:
896 break;
897 raise_excp:
898 /* Update the floating-point enabled exception summary */
899 env->fpscr |= 1 << FPSCR_FEX;
900 /* We have to update Rc1 before raising the exception */
901 env->exception_index = POWERPC_EXCP_PROGRAM;
902 break;
903 }
904 }
905 }
906
907 void helper_store_fpscr (uint64_t arg, uint32_t mask)
908 {
909 /*
910 * We use only the 32 LSB of the incoming fpr
911 */
912 uint32_t prev, new;
913 int i;
914
915 prev = env->fpscr;
916 new = (uint32_t)arg;
917 new &= ~0x90000000;
918 new |= prev & 0x90000000;
919 for (i = 0; i < 7; i++) {
920 if (mask & (1 << i)) {
921 env->fpscr &= ~(0xF << (4 * i));
922 env->fpscr |= new & (0xF << (4 * i));
923 }
924 }
925 /* Update VX and FEX */
926 if (fpscr_ix != 0)
927 env->fpscr |= 1 << FPSCR_VX;
928 else
929 env->fpscr &= ~(1 << FPSCR_VX);
930 if ((fpscr_ex & fpscr_eex) != 0) {
931 env->fpscr |= 1 << FPSCR_FEX;
932 env->exception_index = POWERPC_EXCP_PROGRAM;
933 /* XXX: we should compute it properly */
934 env->error_code = POWERPC_EXCP_FP;
935 }
936 else
937 env->fpscr &= ~(1 << FPSCR_FEX);
938 fpscr_set_rounding_mode();
939 }
940
941 void helper_float_check_status (void)
942 {
943 #ifdef CONFIG_SOFTFLOAT
944 if (env->exception_index == POWERPC_EXCP_PROGRAM &&
945 (env->error_code & POWERPC_EXCP_FP)) {
946 /* Differred floating-point exception after target FPR update */
947 if (msr_fe0 != 0 || msr_fe1 != 0)
948 raise_exception_err(env, env->exception_index, env->error_code);
949 } else if (env->fp_status.float_exception_flags & float_flag_overflow) {
950 float_overflow_excp();
951 } else if (env->fp_status.float_exception_flags & float_flag_underflow) {
952 float_underflow_excp();
953 } else if (env->fp_status.float_exception_flags & float_flag_inexact) {
954 float_inexact_excp();
955 }
956 #else
957 if (env->exception_index == POWERPC_EXCP_PROGRAM &&
958 (env->error_code & POWERPC_EXCP_FP)) {
959 /* Differred floating-point exception after target FPR update */
960 if (msr_fe0 != 0 || msr_fe1 != 0)
961 raise_exception_err(env, env->exception_index, env->error_code);
962 }
963 RETURN();
964 #endif
965 }
966
967 #ifdef CONFIG_SOFTFLOAT
968 void helper_reset_fpstatus (void)
969 {
970 env->fp_status.float_exception_flags = 0;
971 }
972 #endif
973
974 /* fadd - fadd. */
975 uint64_t helper_fadd (uint64_t arg1, uint64_t arg2)
976 {
977 CPU_DoubleU farg1, farg2;
978
979 farg1.ll = arg1;
980 farg2.ll = arg2;
981 #if USE_PRECISE_EMULATION
982 if (unlikely(float64_is_signaling_nan(farg1.d) ||
983 float64_is_signaling_nan(farg2.d))) {
984 /* sNaN addition */
985 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
986 } else if (likely(isfinite(farg1.d) || isfinite(farg2.d) ||
987 fpisneg(farg1.d) == fpisneg(farg2.d))) {
988 farg1.d = float64_add(farg1.d, farg2.d, &env->fp_status);
989 } else {
990 /* Magnitude subtraction of infinities */
991 farg1.ll == fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
992 }
993 #else
994 farg1.d = float64_add(farg1.d, farg2.d, &env->fp_status);
995 #endif
996 return farg1.ll;
997 }
998
999 /* fsub - fsub. */
1000 uint64_t helper_fsub (uint64_t arg1, uint64_t arg2)
1001 {
1002 CPU_DoubleU farg1, farg2;
1003
1004 farg1.ll = arg1;
1005 farg2.ll = arg2;
1006 #if USE_PRECISE_EMULATION
1007 {
1008 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1009 float64_is_signaling_nan(farg2.d))) {
1010 /* sNaN subtraction */
1011 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1012 } else if (likely(isfinite(farg1.d) || isfinite(farg2.d) ||
1013 fpisneg(farg1.d) != fpisneg(farg2.d))) {
1014 farg1.d = float64_sub(farg1.d, farg2.d, &env->fp_status);
1015 } else {
1016 /* Magnitude subtraction of infinities */
1017 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXISI);
1018 }
1019 }
1020 #else
1021 farg1.d = float64_sub(farg1.d, farg2.d, &env->fp_status);
1022 #endif
1023 return farg1.ll;
1024 }
1025
1026 /* fmul - fmul. */
1027 uint64_t helper_fmul (uint64_t arg1, uint64_t arg2)
1028 {
1029 CPU_DoubleU farg1, farg2;
1030
1031 farg1.ll = arg1;
1032 farg2.ll = arg2;
1033 #if USE_PRECISE_EMULATION
1034 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1035 float64_is_signaling_nan(farg2.d))) {
1036 /* sNaN multiplication */
1037 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1038 } else if (unlikely((isinfinity(farg1.d) && iszero(farg2.d)) ||
1039 (iszero(farg1.d) && isinfinity(farg2.d)))) {
1040 /* Multiplication of zero by infinity */
1041 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIMZ);
1042 } else {
1043 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1044 }
1045 }
1046 #else
1047 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1048 #endif
1049 return farg1.ll;
1050 }
1051
1052 /* fdiv - fdiv. */
1053 uint64_t helper_fdiv (uint64_t arg1, uint64_t arg2)
1054 {
1055 CPU_DoubleU farg1, farg2;
1056
1057 farg1.ll = arg1;
1058 farg2.ll = arg2;
1059 #if USE_PRECISE_EMULATION
1060 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1061 float64_is_signaling_nan(farg2.d))) {
1062 /* sNaN division */
1063 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1064 } else if (unlikely(isinfinity(farg1.d) && isinfinity(farg2.d))) {
1065 /* Division of infinity by infinity */
1066 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXIDI);
1067 } else if (unlikely(iszero(farg2.d))) {
1068 if (iszero(farg1.d)) {
1069 /* Division of zero by zero */
1070 farg1.ll fload_invalid_op_excp(POWERPC_EXCP_FP_VXZDZ);
1071 } else {
1072 /* Division by zero */
1073 farg1.ll = float_zero_divide_excp(farg1.d, farg2.d);
1074 }
1075 } else {
1076 farg1.d = float64_div(farg1.d, farg2.d, &env->fp_status);
1077 }
1078 #else
1079 farg1.d = float64_div(farg1.d, farg2.d, &env->fp_status);
1080 #endif
1081 return farg1.ll;
1082 }
1083
1084 /* fabs */
1085 uint64_t helper_fabs (uint64_t arg)
1086 {
1087 CPU_DoubleU farg;
1088
1089 farg.ll = arg;
1090 farg.d = float64_abs(farg.d);
1091 return farg.ll;
1092 }
1093
1094 /* fnabs */
1095 uint64_t helper_fnabs (uint64_t arg)
1096 {
1097 CPU_DoubleU farg;
1098
1099 farg.ll = arg;
1100 farg.d = float64_abs(farg.d);
1101 farg.d = float64_chs(farg.d);
1102 return farg.ll;
1103 }
1104
1105 /* fneg */
1106 uint64_t helper_fneg (uint64_t arg)
1107 {
1108 CPU_DoubleU farg;
1109
1110 farg.ll = arg;
1111 farg.d = float64_chs(farg.d);
1112 return farg.ll;
1113 }
1114
1115 /* fctiw - fctiw. */
1116 uint64_t helper_fctiw (uint64_t arg)
1117 {
1118 CPU_DoubleU farg;
1119 farg.ll = arg;
1120
1121 if (unlikely(float64_is_signaling_nan(farg.d))) {
1122 /* sNaN conversion */
1123 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1124 } else if (unlikely(float64_is_nan(farg.d) || isinfinity(farg.d))) {
1125 /* qNan / infinity conversion */
1126 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1127 } else {
1128 farg.ll = float64_to_int32(farg.d, &env->fp_status);
1129 #if USE_PRECISE_EMULATION
1130 /* XXX: higher bits are not supposed to be significant.
1131 * to make tests easier, return the same as a real PowerPC 750
1132 */
1133 farg.ll |= 0xFFF80000ULL << 32;
1134 #endif
1135 }
1136 return farg.ll;
1137 }
1138
1139 /* fctiwz - fctiwz. */
1140 uint64_t helper_fctiwz (uint64_t arg)
1141 {
1142 CPU_DoubleU farg;
1143 farg.ll = arg;
1144
1145 if (unlikely(float64_is_signaling_nan(farg.d))) {
1146 /* sNaN conversion */
1147 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1148 } else if (unlikely(float64_is_nan(farg.d) || isinfinity(farg.d))) {
1149 /* qNan / infinity conversion */
1150 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1151 } else {
1152 farg.ll = float64_to_int32_round_to_zero(farg.d, &env->fp_status);
1153 #if USE_PRECISE_EMULATION
1154 /* XXX: higher bits are not supposed to be significant.
1155 * to make tests easier, return the same as a real PowerPC 750
1156 */
1157 farg.ll |= 0xFFF80000ULL << 32;
1158 #endif
1159 }
1160 return farg.ll;
1161 }
1162
1163 #if defined(TARGET_PPC64)
1164 /* fcfid - fcfid. */
1165 uint64_t helper_fcfid (uint64_t arg)
1166 {
1167 CPU_DoubleU farg;
1168 farg.d = int64_to_float64(arg, &env->fp_status);
1169 return farg.ll;
1170 }
1171
1172 /* fctid - fctid. */
1173 uint64_t helper_fctid (uint64_t arg)
1174 {
1175 CPU_DoubleU farg;
1176 farg.ll = arg;
1177
1178 if (unlikely(float64_is_signaling_nan(farg.d))) {
1179 /* sNaN conversion */
1180 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1181 } else if (unlikely(float64_is_nan(farg.d) || isinfinity(farg.d))) {
1182 /* qNan / infinity conversion */
1183 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1184 } else {
1185 farg.ll = float64_to_int64(farg.d, &env->fp_status);
1186 }
1187 return farg.ll;
1188 }
1189
1190 /* fctidz - fctidz. */
1191 uint64_t helper_fctidz (uint64_t arg)
1192 {
1193 CPU_DoubleU farg;
1194 farg.ll = arg;
1195
1196 if (unlikely(float64_is_signaling_nan(farg.d))) {
1197 /* sNaN conversion */
1198 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1199 } else if (unlikely(float64_is_nan(farg.d) || isinfinity(farg.d))) {
1200 /* qNan / infinity conversion */
1201 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1202 } else {
1203 farg.ll = float64_to_int64_round_to_zero(farg.d, &env->fp_status);
1204 }
1205 return farg.ll;
1206 }
1207
1208 #endif
1209
1210 static always_inline uint64_t do_fri (uint64_t arg, int rounding_mode)
1211 {
1212 CPU_DoubleU farg;
1213 farg.ll = arg;
1214
1215 if (unlikely(float64_is_signaling_nan(farg.d))) {
1216 /* sNaN round */
1217 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI);
1218 } else if (unlikely(float64_is_nan(farg.d) || isinfinity(farg.d))) {
1219 /* qNan / infinity round */
1220 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXCVI);
1221 } else {
1222 set_float_rounding_mode(rounding_mode, &env->fp_status);
1223 farg.ll = float64_round_to_int(farg.d, &env->fp_status);
1224 /* Restore rounding mode from FPSCR */
1225 fpscr_set_rounding_mode();
1226 }
1227 return farg.ll;
1228 }
1229
1230 uint64_t helper_frin (uint64_t arg)
1231 {
1232 return do_fri(arg, float_round_nearest_even);
1233 }
1234
1235 uint64_t helper_friz (uint64_t arg)
1236 {
1237 return do_fri(arg, float_round_to_zero);
1238 }
1239
1240 uint64_t helper_frip (uint64_t arg)
1241 {
1242 return do_fri(arg, float_round_up);
1243 }
1244
1245 uint64_t helper_frim (uint64_t arg)
1246 {
1247 return do_fri(arg, float_round_down);
1248 }
1249
1250 /* fmadd - fmadd. */
1251 uint64_t helper_fmadd (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1252 {
1253 CPU_DoubleU farg1, farg2, farg3;
1254
1255 farg1.ll = arg1;
1256 farg2.ll = arg2;
1257 farg3.ll = arg3;
1258 #if USE_PRECISE_EMULATION
1259 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1260 float64_is_signaling_nan(farg2.d) ||
1261 float64_is_signaling_nan(farg3.d))) {
1262 /* sNaN operation */
1263 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1264 } else {
1265 #ifdef FLOAT128
1266 /* This is the way the PowerPC specification defines it */
1267 float128 ft0_128, ft1_128;
1268
1269 ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1270 ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1271 ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1272 ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1273 ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
1274 farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1275 #else
1276 /* This is OK on x86 hosts */
1277 farg1.d = (farg1.d * farg2.d) + farg3.d;
1278 #endif
1279 }
1280 #else
1281 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1282 farg1.d = float64_add(farg1.d, farg3.d, &env->fp_status);
1283 #endif
1284 return farg1.ll;
1285 }
1286
1287 /* fmsub - fmsub. */
1288 uint64_t helper_fmsub (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1289 {
1290 CPU_DoubleU farg1, farg2, farg3;
1291
1292 farg1.ll = arg1;
1293 farg2.ll = arg2;
1294 farg3.ll = arg3;
1295 #if USE_PRECISE_EMULATION
1296 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1297 float64_is_signaling_nan(farg2.d) ||
1298 float64_is_signaling_nan(farg3.d))) {
1299 /* sNaN operation */
1300 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1301 } else {
1302 #ifdef FLOAT128
1303 /* This is the way the PowerPC specification defines it */
1304 float128 ft0_128, ft1_128;
1305
1306 ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1307 ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1308 ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1309 ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1310 ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
1311 farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1312 #else
1313 /* This is OK on x86 hosts */
1314 farg1.d = (farg1.d * farg2.d) - farg3.d;
1315 #endif
1316 }
1317 #else
1318 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1319 farg1.d = float64_sub(farg1.d, farg3.d, &env->fp_status);
1320 #endif
1321 return farg1.ll;
1322 }
1323
1324 /* fnmadd - fnmadd. */
1325 uint64_t helper_fnmadd (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1326 {
1327 CPU_DoubleU farg1, farg2, farg3;
1328
1329 farg1.ll = arg1;
1330 farg2.ll = arg2;
1331 farg3.ll = arg3;
1332
1333 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1334 float64_is_signaling_nan(farg2.d) ||
1335 float64_is_signaling_nan(farg3.d))) {
1336 /* sNaN operation */
1337 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1338 } else {
1339 #if USE_PRECISE_EMULATION
1340 #ifdef FLOAT128
1341 /* This is the way the PowerPC specification defines it */
1342 float128 ft0_128, ft1_128;
1343
1344 ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1345 ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1346 ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1347 ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1348 ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
1349 farg1.d= float128_to_float64(ft0_128, &env->fp_status);
1350 #else
1351 /* This is OK on x86 hosts */
1352 farg1.d = (farg1.d * farg2.d) + farg3.d;
1353 #endif
1354 #else
1355 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1356 farg1.d = float64_add(farg1.d, farg3.d, &env->fp_status);
1357 #endif
1358 if (likely(!isnan(farg1.d)))
1359 farg1.d = float64_chs(farg1.d);
1360 }
1361 return farg1.ll;
1362 }
1363
1364 /* fnmsub - fnmsub. */
1365 uint64_t helper_fnmsub (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1366 {
1367 CPU_DoubleU farg1, farg2, farg3;
1368
1369 farg1.ll = arg1;
1370 farg2.ll = arg2;
1371 farg3.ll = arg3;
1372
1373 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1374 float64_is_signaling_nan(farg2.d) ||
1375 float64_is_signaling_nan(farg3.d))) {
1376 /* sNaN operation */
1377 farg1.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1378 } else {
1379 #if USE_PRECISE_EMULATION
1380 #ifdef FLOAT128
1381 /* This is the way the PowerPC specification defines it */
1382 float128 ft0_128, ft1_128;
1383
1384 ft0_128 = float64_to_float128(farg1.d, &env->fp_status);
1385 ft1_128 = float64_to_float128(farg2.d, &env->fp_status);
1386 ft0_128 = float128_mul(ft0_128, ft1_128, &env->fp_status);
1387 ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
1388 ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
1389 farg1.d = float128_to_float64(ft0_128, &env->fp_status);
1390 #else
1391 /* This is OK on x86 hosts */
1392 farg1.d = (farg1.d * farg2.d) - farg3.d;
1393 #endif
1394 #else
1395 farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
1396 farg1.d = float64_sub(farg1.d, farg3.d, &env->fp_status);
1397 #endif
1398 if (likely(!isnan(farg1.d)))
1399 farg1.d = float64_chs(farg1.d);
1400 }
1401 return farg1.ll;
1402 }
1403
1404 /* frsp - frsp. */
1405 uint64_t helper_frsp (uint64_t arg)
1406 {
1407 CPU_DoubleU farg;
1408 farg.ll = arg;
1409
1410 #if USE_PRECISE_EMULATION
1411 if (unlikely(float64_is_signaling_nan(farg.d))) {
1412 /* sNaN square root */
1413 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1414 } else {
1415 fard.d = float64_to_float32(farg.d, &env->fp_status);
1416 }
1417 #else
1418 farg.d = float64_to_float32(farg.d, &env->fp_status);
1419 #endif
1420 return farg.ll;
1421 }
1422
1423 /* fsqrt - fsqrt. */
1424 uint64_t helper_fsqrt (uint64_t arg)
1425 {
1426 CPU_DoubleU farg;
1427 farg.ll = arg;
1428
1429 if (unlikely(float64_is_signaling_nan(farg.d))) {
1430 /* sNaN square root */
1431 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1432 } else if (unlikely(fpisneg(farg.d) && !iszero(farg.d))) {
1433 /* Square root of a negative nonzero number */
1434 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSQRT);
1435 } else {
1436 farg.d = float64_sqrt(farg.d, &env->fp_status);
1437 }
1438 return farg.ll;
1439 }
1440
1441 /* fre - fre. */
1442 uint64_t helper_fre (uint64_t arg)
1443 {
1444 CPU_DoubleU farg;
1445 farg.ll = arg;
1446
1447 if (unlikely(float64_is_signaling_nan(farg.d))) {
1448 /* sNaN reciprocal */
1449 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1450 } else if (unlikely(iszero(farg.d))) {
1451 /* Zero reciprocal */
1452 farg.ll = float_zero_divide_excp(1.0, farg.d);
1453 } else if (likely(isnormal(farg.d))) {
1454 farg.d = float64_div(1.0, farg.d, &env->fp_status);
1455 } else {
1456 if (farg.ll == 0x8000000000000000ULL) {
1457 farg.ll = 0xFFF0000000000000ULL;
1458 } else if (farg.ll == 0x0000000000000000ULL) {
1459 farg.ll = 0x7FF0000000000000ULL;
1460 } else if (isnan(farg.d)) {
1461 farg.ll = 0x7FF8000000000000ULL;
1462 } else if (fpisneg(farg.d)) {
1463 farg.ll = 0x8000000000000000ULL;
1464 } else {
1465 farg.ll = 0x0000000000000000ULL;
1466 }
1467 }
1468 return farg.d;
1469 }
1470
1471 /* fres - fres. */
1472 uint64_t helper_fres (uint64_t arg)
1473 {
1474 CPU_DoubleU farg;
1475 farg.ll = arg;
1476
1477 if (unlikely(float64_is_signaling_nan(farg.d))) {
1478 /* sNaN reciprocal */
1479 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1480 } else if (unlikely(iszero(farg.d))) {
1481 /* Zero reciprocal */
1482 farg.ll = float_zero_divide_excp(1.0, farg.d);
1483 } else if (likely(isnormal(farg.d))) {
1484 #if USE_PRECISE_EMULATION
1485 farg.d = float64_div(1.0, farg.d, &env->fp_status);
1486 farg.d = float64_to_float32(farg.d, &env->fp_status);
1487 #else
1488 farg.d = float32_div(1.0, farg.d, &env->fp_status);
1489 #endif
1490 } else {
1491 if (farg.ll == 0x8000000000000000ULL) {
1492 farg.ll = 0xFFF0000000000000ULL;
1493 } else if (farg.ll == 0x0000000000000000ULL) {
1494 farg.ll = 0x7FF0000000000000ULL;
1495 } else if (isnan(farg.d)) {
1496 farg.ll = 0x7FF8000000000000ULL;
1497 } else if (fpisneg(farg.d)) {
1498 farg.ll = 0x8000000000000000ULL;
1499 } else {
1500 farg.ll = 0x0000000000000000ULL;
1501 }
1502 }
1503 return farg.ll;
1504 }
1505
1506 /* frsqrte - frsqrte. */
1507 uint64_t helper_frsqrte (uint64_t arg)
1508 {
1509 CPU_DoubleU farg;
1510 farg.ll = arg;
1511
1512 if (unlikely(float64_is_signaling_nan(farg.d))) {
1513 /* sNaN reciprocal square root */
1514 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1515 } else if (unlikely(fpisneg(farg.d) && !iszero(farg.d))) {
1516 /* Reciprocal square root of a negative nonzero number */
1517 farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSQRT);
1518 } else if (likely(isnormal(farg.d))) {
1519 farg.d = float64_sqrt(farg.d, &env->fp_status);
1520 farg.d = float32_div(1.0, farg.d, &env->fp_status);
1521 } else {
1522 if (farg.ll == 0x8000000000000000ULL) {
1523 farg.ll = 0xFFF0000000000000ULL;
1524 } else if (farg.ll == 0x0000000000000000ULL) {
1525 farg.ll = 0x7FF0000000000000ULL;
1526 } else if (isnan(farg.d)) {
1527 farg.ll |= 0x000FFFFFFFFFFFFFULL;
1528 } else if (fpisneg(farg.d)) {
1529 farg.ll = 0x7FF8000000000000ULL;
1530 } else {
1531 farg.ll = 0x0000000000000000ULL;
1532 }
1533 }
1534 return farg.ll;
1535 }
1536
1537 /* fsel - fsel. */
1538 uint64_t helper_fsel (uint64_t arg1, uint64_t arg2, uint64_t arg3)
1539 {
1540 CPU_DoubleU farg1, farg2, farg3;
1541
1542 farg1.ll = arg1;
1543 farg2.ll = arg2;
1544 farg3.ll = arg3;
1545
1546 if (!fpisneg(farg1.d) || iszero(farg1.d))
1547 return farg2.ll;
1548 else
1549 return farg2.ll;
1550 }
1551
1552 uint32_t helper_fcmpu (uint64_t arg1, uint64_t arg2)
1553 {
1554 CPU_DoubleU farg1, farg2;
1555 uint32_t ret = 0;
1556 farg1.ll = arg1;
1557 farg2.ll = arg2;
1558
1559 if (unlikely(float64_is_signaling_nan(farg1.d) ||
1560 float64_is_signaling_nan(farg2.d))) {
1561 /* sNaN comparison */
1562 fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
1563 } else {
1564 if (float64_lt(farg1.d, farg2.d, &env->fp_status)) {
1565 ret = 0x08UL;
1566 } else if (!float64_le(farg1.d, farg2.d, &env->fp_status)) {
1567 ret = 0x04UL;
1568 } else {
1569 ret = 0x02UL;
1570 }
1571 }
1572 env->fpscr &= ~(0x0F << FPSCR_FPRF);
1573 env->fpscr |= ret << FPSCR_FPRF;
1574 return ret;
1575 }
1576
1577 uint32_t helper_fcmpo (uint64_t arg1, uint64_t arg2)
1578 {
1579 CPU_DoubleU farg1, farg2;
1580 uint32_t ret = 0;
1581 farg1.ll = arg1;
1582 farg2.ll = arg2;
1583
1584 if (unlikely(float64_is_nan(farg1.d) ||
1585 float64_is_nan(farg2.d))) {
1586 if (float64_is_signaling_nan(farg1.d) ||
1587 float64_is_signaling_nan(farg2.d)) {
1588 /* sNaN comparison */
1589 fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN |
1590 POWERPC_EXCP_FP_VXVC);
1591 } else {
1592 /* qNaN comparison */
1593 fload_invalid_op_excp(POWERPC_EXCP_FP_VXVC);
1594 }
1595 } else {
1596 if (float64_lt(farg1.d, farg2.d, &env->fp_status)) {
1597 ret = 0x08UL;
1598 } else if (!float64_le(farg1.d, farg2.d, &env->fp_status)) {
1599 ret = 0x04UL;
1600 } else {
1601 ret = 0x02UL;
1602 }
1603 }
1604 env->fpscr &= ~(0x0F << FPSCR_FPRF);
1605 env->fpscr |= ret << FPSCR_FPRF;
1606 return ret;
1607 }
1608
1609 #if !defined (CONFIG_USER_ONLY)
1610 void cpu_dump_rfi (target_ulong RA, target_ulong msr);
1611
1612 void do_store_msr (void)
1613 {
1614 T0 = hreg_store_msr(env, T0, 0);
1615 if (T0 != 0) {
1616 env->interrupt_request |= CPU_INTERRUPT_EXITTB;
1617 raise_exception(env, T0);
1618 }
1619 }
1620
1621 static always_inline void __do_rfi (target_ulong nip, target_ulong msr,
1622 target_ulong msrm, int keep_msrh)
1623 {
1624 #if defined(TARGET_PPC64)
1625 if (msr & (1ULL << MSR_SF)) {
1626 nip = (uint64_t)nip;
1627 msr &= (uint64_t)msrm;
1628 } else {
1629 nip = (uint32_t)nip;
1630 msr = (uint32_t)(msr & msrm);
1631 if (keep_msrh)
1632 msr |= env->msr & ~((uint64_t)0xFFFFFFFF);
1633 }
1634 #else
1635 nip = (uint32_t)nip;
1636 msr &= (uint32_t)msrm;
1637 #endif
1638 /* XXX: beware: this is false if VLE is supported */
1639 env->nip = nip & ~((target_ulong)0x00000003);
1640 hreg_store_msr(env, msr, 1);
1641 #if defined (DEBUG_OP)
1642 cpu_dump_rfi(env->nip, env->msr);
1643 #endif
1644 /* No need to raise an exception here,
1645 * as rfi is always the last insn of a TB
1646 */
1647 env->interrupt_request |= CPU_INTERRUPT_EXITTB;
1648 }
1649
1650 void do_rfi (void)
1651 {
1652 __do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1],
1653 ~((target_ulong)0xFFFF0000), 1);
1654 }
1655
1656 #if defined(TARGET_PPC64)
1657 void do_rfid (void)
1658 {
1659 __do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1],
1660 ~((target_ulong)0xFFFF0000), 0);
1661 }
1662
1663 void do_hrfid (void)
1664 {
1665 __do_rfi(env->spr[SPR_HSRR0], env->spr[SPR_HSRR1],
1666 ~((target_ulong)0xFFFF0000), 0);
1667 }
1668 #endif
1669 #endif
1670
1671 void helper_tw (target_ulong arg1, target_ulong arg2, uint32_t flags)
1672 {
1673 if (!likely(!(((int32_t)arg1 < (int32_t)arg2 && (flags & 0x10)) ||
1674 ((int32_t)arg1 > (int32_t)arg2 && (flags & 0x08)) ||
1675 ((int32_t)arg1 == (int32_t)arg2 && (flags & 0x04)) ||
1676 ((uint32_t)arg1 < (uint32_t)arg2 && (flags & 0x02)) ||
1677 ((uint32_t)arg1 > (uint32_t)arg2 && (flags & 0x01))))) {
1678 raise_exception_err(env, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_TRAP);
1679 }
1680 }
1681
1682 #if defined(TARGET_PPC64)
1683 void helper_td (target_ulong arg1, target_ulong arg2, uint32_t flags)
1684 {
1685 if (!likely(!(((int64_t)arg1 < (int64_t)arg2 && (flags & 0x10)) ||
1686 ((int64_t)arg1 > (int64_t)arg2 && (flags & 0x08)) ||
1687 ((int64_t)arg1 == (int64_t)arg2 && (flags & 0x04)) ||
1688 ((uint64_t)arg1 < (uint64_t)arg2 && (flags & 0x02)) ||
1689 ((uint64_t)arg1 > (uint64_t)arg2 && (flags & 0x01)))))
1690 raise_exception_err(env, POWERPC_EXCP_PROGRAM, POWERPC_EXCP_TRAP);
1691 }
1692 #endif
1693
1694 /*****************************************************************************/
1695 /* PowerPC 601 specific instructions (POWER bridge) */
1696 void do_POWER_abso (void)
1697 {
1698 if ((int32_t)T0 == INT32_MIN) {
1699 T0 = INT32_MAX;
1700 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1701 } else if ((int32_t)T0 < 0) {
1702 T0 = -T0;
1703 env->xer &= ~(1 << XER_OV);
1704 } else {
1705 env->xer &= ~(1 << XER_OV);
1706 }
1707 }
1708
1709 void do_POWER_clcs (void)
1710 {
1711 switch (T0) {
1712 case 0x0CUL:
1713 /* Instruction cache line size */
1714 T0 = env->icache_line_size;
1715 break;
1716 case 0x0DUL:
1717 /* Data cache line size */
1718 T0 = env->dcache_line_size;
1719 break;
1720 case 0x0EUL:
1721 /* Minimum cache line size */
1722 T0 = env->icache_line_size < env->dcache_line_size ?
1723 env->icache_line_size : env->dcache_line_size;
1724 break;
1725 case 0x0FUL:
1726 /* Maximum cache line size */
1727 T0 = env->icache_line_size > env->dcache_line_size ?
1728 env->icache_line_size : env->dcache_line_size;
1729 break;
1730 default:
1731 /* Undefined */
1732 break;
1733 }
1734 }
1735
1736 void do_POWER_div (void)
1737 {
1738 uint64_t tmp;
1739
1740 if (((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
1741 (int32_t)T1 == 0) {
1742 T0 = UINT32_MAX * ((uint32_t)T0 >> 31);
1743 env->spr[SPR_MQ] = 0;
1744 } else {
1745 tmp = ((uint64_t)T0 << 32) | env->spr[SPR_MQ];
1746 env->spr[SPR_MQ] = tmp % T1;
1747 T0 = tmp / (int32_t)T1;
1748 }
1749 }
1750
1751 void do_POWER_divo (void)
1752 {
1753 int64_t tmp;
1754
1755 if (((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
1756 (int32_t)T1 == 0) {
1757 T0 = UINT32_MAX * ((uint32_t)T0 >> 31);
1758 env->spr[SPR_MQ] = 0;
1759 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1760 } else {
1761 tmp = ((uint64_t)T0 << 32) | env->spr[SPR_MQ];
1762 env->spr[SPR_MQ] = tmp % T1;
1763 tmp /= (int32_t)T1;
1764 if (tmp > (int64_t)INT32_MAX || tmp < (int64_t)INT32_MIN) {
1765 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1766 } else {
1767 env->xer &= ~(1 << XER_OV);
1768 }
1769 T0 = tmp;
1770 }
1771 }
1772
1773 void do_POWER_divs (void)
1774 {
1775 if (((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
1776 (int32_t)T1 == 0) {
1777 T0 = UINT32_MAX * ((uint32_t)T0 >> 31);
1778 env->spr[SPR_MQ] = 0;
1779 } else {
1780 env->spr[SPR_MQ] = T0 % T1;
1781 T0 = (int32_t)T0 / (int32_t)T1;
1782 }
1783 }
1784
1785 void do_POWER_divso (void)
1786 {
1787 if (((int32_t)T0 == INT32_MIN && (int32_t)T1 == (int32_t)-1) ||
1788 (int32_t)T1 == 0) {
1789 T0 = UINT32_MAX * ((uint32_t)T0 >> 31);
1790 env->spr[SPR_MQ] = 0;
1791 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1792 } else {
1793 T0 = (int32_t)T0 / (int32_t)T1;
1794 env->spr[SPR_MQ] = (int32_t)T0 % (int32_t)T1;
1795 env->xer &= ~(1 << XER_OV);
1796 }
1797 }
1798
1799 void do_POWER_dozo (void)
1800 {
1801 if ((int32_t)T1 > (int32_t)T0) {
1802 T2 = T0;
1803 T0 = T1 - T0;
1804 if (((uint32_t)(~T2) ^ (uint32_t)T1 ^ UINT32_MAX) &
1805 ((uint32_t)(~T2) ^ (uint32_t)T0) & (1UL << 31)) {
1806 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1807 } else {
1808 env->xer &= ~(1 << XER_OV);
1809 }
1810 } else {
1811 T0 = 0;
1812 env->xer &= ~(1 << XER_OV);
1813 }
1814 }
1815
1816 void do_POWER_maskg (void)
1817 {
1818 uint32_t ret;
1819
1820 if ((uint32_t)T0 == (uint32_t)(T1 + 1)) {
1821 ret = UINT32_MAX;
1822 } else {
1823 ret = (UINT32_MAX >> ((uint32_t)T0)) ^
1824 ((UINT32_MAX >> ((uint32_t)T1)) >> 1);
1825 if ((uint32_t)T0 > (uint32_t)T1)
1826 ret = ~ret;
1827 }
1828 T0 = ret;
1829 }
1830
1831 void do_POWER_mulo (void)
1832 {
1833 uint64_t tmp;
1834
1835 tmp = (uint64_t)T0 * (uint64_t)T1;
1836 env->spr[SPR_MQ] = tmp >> 32;
1837 T0 = tmp;
1838 if (tmp >> 32 != ((uint64_t)T0 >> 16) * ((uint64_t)T1 >> 16)) {
1839 env->xer |= (1 << XER_OV) | (1 << XER_SO);
1840 } else {
1841 env->xer &= ~(1 << XER_OV);
1842 }
1843 }
1844
1845 #if !defined (CONFIG_USER_ONLY)
1846 void do_POWER_rac (void)
1847 {
1848 mmu_ctx_t ctx;
1849 int nb_BATs;
1850
1851 /* We don't have to generate many instances of this instruction,
1852 * as rac is supervisor only.
1853 */
1854 /* XXX: FIX THIS: Pretend we have no BAT */
1855 nb_BATs = env->nb_BATs;
1856 env->nb_BATs = 0;
1857 if (get_physical_address(env, &ctx, T0, 0, ACCESS_INT) == 0)
1858 T0 = ctx.raddr;
1859 env->nb_BATs = nb_BATs;
1860 }
1861
1862 void do_POWER_rfsvc (void)
1863 {
1864 __do_rfi(env->lr, env->ctr, 0x0000FFFF, 0);
1865 }
1866
1867 void do_store_hid0_601 (void)
1868 {
1869 uint32_t hid0;
1870
1871 hid0 = env->spr[SPR_HID0];
1872 if ((T0 ^ hid0) & 0x00000008) {
1873 /* Change current endianness */
1874 env->hflags &= ~(1 << MSR_LE);
1875 env->hflags_nmsr &= ~(1 << MSR_LE);
1876 env->hflags_nmsr |= (1 << MSR_LE) & (((T0 >> 3) & 1) << MSR_LE);
1877 env->hflags |= env->hflags_nmsr;
1878 if (loglevel != 0) {
1879 fprintf(logfile, "%s: set endianness to %c => " ADDRX "\n",
1880 __func__, T0 & 0x8 ? 'l' : 'b', env->hflags);
1881 }
1882 }
1883 env->spr[SPR_HID0] = T0;
1884 }
1885 #endif
1886
1887 /*****************************************************************************/
1888 /* 602 specific instructions */
1889 /* mfrom is the most crazy instruction ever seen, imho ! */
1890 /* Real implementation uses a ROM table. Do the same */
1891 #define USE_MFROM_ROM_TABLE
1892 target_ulong helper_602_mfrom (target_ulong arg)
1893 {
1894 if (likely(arg < 602)) {
1895 #if defined(USE_MFROM_ROM_TABLE)
1896 #include "mfrom_table.c"
1897 return mfrom_ROM_table[T0];
1898 #else
1899 double d;
1900 /* Extremly decomposed:
1901 * -arg / 256
1902 * return 256 * log10(10 + 1.0) + 0.5
1903 */
1904 d = arg;
1905 d = float64_div(d, 256, &env->fp_status);
1906 d = float64_chs(d);
1907 d = exp10(d); // XXX: use float emulation function
1908 d = float64_add(d, 1.0, &env->fp_status);
1909 d = log10(d); // XXX: use float emulation function
1910 d = float64_mul(d, 256, &env->fp_status);
1911 d = float64_add(d, 0.5, &env->fp_status);
1912 return float64_round_to_int(d, &env->fp_status);
1913 #endif
1914 } else {
1915 return 0;
1916 }
1917 }
1918
1919 /*****************************************************************************/
1920 /* Embedded PowerPC specific helpers */
1921
1922 /* XXX: to be improved to check access rights when in user-mode */
1923 void do_load_dcr (void)
1924 {
1925 target_ulong val;
1926
1927 if (unlikely(env->dcr_env == NULL)) {
1928 if (loglevel != 0) {
1929 fprintf(logfile, "No DCR environment\n");
1930 }
1931 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
1932 POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL);
1933 } else if (unlikely(ppc_dcr_read(env->dcr_env, T0, &val) != 0)) {
1934 if (loglevel != 0) {
1935 fprintf(logfile, "DCR read error %d %03x\n", (int)T0, (int)T0);
1936 }
1937 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
1938 POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
1939 } else {
1940 T0 = val;
1941 }
1942 }
1943
1944 void do_store_dcr (void)
1945 {
1946 if (unlikely(env->dcr_env == NULL)) {
1947 if (loglevel != 0) {
1948 fprintf(logfile, "No DCR environment\n");
1949 }
1950 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
1951 POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL);
1952 } else if (unlikely(ppc_dcr_write(env->dcr_env, T0, T1) != 0)) {
1953 if (loglevel != 0) {
1954 fprintf(logfile, "DCR write error %d %03x\n", (int)T0, (int)T0);
1955 }
1956 raise_exception_err(env, POWERPC_EXCP_PROGRAM,
1957 POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
1958 }
1959 }
1960
1961 #if !defined(CONFIG_USER_ONLY)
1962 void do_40x_rfci (void)
1963 {
1964 __do_rfi(env->spr[SPR_40x_SRR2], env->spr[SPR_40x_SRR3],
1965 ~((target_ulong)0xFFFF0000), 0);
1966 }
1967
1968 void do_rfci (void)
1969 {
1970 __do_rfi(env->spr[SPR_BOOKE_CSRR0], SPR_BOOKE_CSRR1,
1971 ~((target_ulong)0x3FFF0000), 0);
1972 }
1973
1974 void do_rfdi (void)
1975 {
1976 __do_rfi(env->spr[SPR_BOOKE_DSRR0], SPR_BOOKE_DSRR1,
1977 ~((target_ulong)0x3FFF0000), 0);
1978 }
1979
1980 void do_rfmci (void)
1981 {
1982 __do_rfi(env->spr[SPR_BOOKE_MCSRR0], SPR_BOOKE_MCSRR1,
1983 ~((target_ulong)0x3FFF0000), 0);
1984 }
1985
1986 void do_load_403_pb (int num)
1987 {
1988 T0 = env->pb[num];
1989 }
1990
1991 void do_store_403_pb (int num)
1992 {
1993 if (likely(env->pb[num] != T0)) {
1994 env->pb[num] = T0;
1995 /* Should be optimized */
1996 tlb_flush(env, 1);
1997 }
1998 }
1999 #endif
2000
2001 /* 440 specific */
2002 void do_440_dlmzb (void)
2003 {
2004 target_ulong mask;
2005 int i;
2006
2007 i = 1;
2008 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2009 if ((T0 & mask) == 0)
2010 goto done;
2011 i++;
2012 }
2013 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2014 if ((T1 & mask) == 0)
2015 break;
2016 i++;
2017 }
2018 done:
2019 T0 = i;
2020 }
2021
2022 /*****************************************************************************/
2023 /* SPE extension helpers */
2024 /* Use a table to make this quicker */
2025 static uint8_t hbrev[16] = {
2026 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
2027 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
2028 };
2029
2030 static always_inline uint8_t byte_reverse (uint8_t val)
2031 {
2032 return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
2033 }
2034
2035 static always_inline uint32_t word_reverse (uint32_t val)
2036 {
2037 return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
2038 (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
2039 }
2040
2041 #define MASKBITS 16 // Random value - to be fixed (implementation dependant)
2042 target_ulong helper_brinc (target_ulong arg1, target_ulong arg2)
2043 {
2044 uint32_t a, b, d, mask;
2045
2046 mask = UINT32_MAX >> (32 - MASKBITS);
2047 a = arg1 & mask;
2048 b = arg2 & mask;
2049 d = word_reverse(1 + word_reverse(a | ~b));
2050 return (arg1 & ~mask) | (d & b);
2051 }
2052
2053 uint32_t helper_cntlsw32 (uint32_t val)
2054 {
2055 if (val & 0x80000000)
2056 return clz32(~val);
2057 else
2058 return clz32(val);
2059 }
2060
2061 uint32_t helper_cntlzw32 (uint32_t val)
2062 {
2063 return clz32(val);
2064 }
2065
2066 /* Single-precision floating-point conversions */
2067 static always_inline uint32_t efscfsi (uint32_t val)
2068 {
2069 CPU_FloatU u;
2070
2071 u.f = int32_to_float32(val, &env->spe_status);
2072
2073 return u.l;
2074 }
2075
2076 static always_inline uint32_t efscfui (uint32_t val)
2077 {
2078 CPU_FloatU u;
2079
2080 u.f = uint32_to_float32(val, &env->spe_status);
2081
2082 return u.l;
2083 }
2084
2085 static always_inline int32_t efsctsi (uint32_t val)
2086 {
2087 CPU_FloatU u;
2088
2089 u.l = val;
2090 /* NaN are not treated the same way IEEE 754 does */
2091 if (unlikely(isnan(u.f)))
2092 return 0;
2093
2094 return float32_to_int32(u.f, &env->spe_status);
2095 }
2096
2097 static always_inline uint32_t efsctui (uint32_t val)
2098 {
2099 CPU_FloatU u;
2100
2101 u.l = val;
2102 /* NaN are not treated the same way IEEE 754 does */
2103 if (unlikely(isnan(u.f)))
2104 return 0;
2105
2106 return float32_to_uint32(u.f, &env->spe_status);
2107 }
2108
2109 static always_inline uint32_t efsctsiz (uint32_t val)
2110 {
2111 CPU_FloatU u;
2112
2113 u.l = val;
2114 /* NaN are not treated the same way IEEE 754 does */
2115 if (unlikely(isnan(u.f)))
2116 return 0;
2117
2118 return float32_to_int32_round_to_zero(u.f, &env->spe_status);
2119 }
2120
2121 static always_inline uint32_t efsctuiz (uint32_t val)
2122 {
2123 CPU_FloatU u;
2124
2125 u.l = val;
2126 /* NaN are not treated the same way IEEE 754 does */
2127 if (unlikely(isnan(u.f)))
2128 return 0;
2129
2130 return float32_to_uint32_round_to_zero(u.f, &env->spe_status);
2131 }
2132
2133 static always_inline uint32_t efscfsf (uint32_t val)
2134 {
2135 CPU_FloatU u;
2136 float32 tmp;
2137
2138 u.f = int32_to_float32(val, &env->spe_status);
2139 tmp = int64_to_float32(1ULL << 32, &env->spe_status);
2140 u.f = float32_div(u.f, tmp, &env->spe_status);
2141
2142 return u.l;
2143 }
2144
2145 static always_inline uint32_t efscfuf (uint32_t val)
2146 {
2147 CPU_FloatU u;
2148 float32 tmp;
2149
2150 u.f = uint32_to_float32(val, &env->spe_status);
2151 tmp = uint64_to_float32(1ULL << 32, &env->spe_status);
2152 u.f = float32_div(u.f, tmp, &env->spe_status);
2153
2154 return u.l;
2155 }
2156
2157 static always_inline uint32_t efsctsf (uint32_t val)
2158 {
2159 CPU_FloatU u;
2160 float32 tmp;
2161
2162 u.l = val;
2163 /* NaN are not treated the same way IEEE 754 does */
2164 if (unlikely(isnan(u.f)))
2165 return 0;
2166 tmp = uint64_to_float32(1ULL << 32, &env->spe_status);
2167 u.f = float32_mul(u.f, tmp, &env->spe_status);
2168
2169 return float32_to_int32(u.f, &env->spe_status);
2170 }
2171
2172 static always_inline uint32_t efsctuf (uint32_t val)
2173 {
2174 CPU_FloatU u;
2175 float32 tmp;
2176
2177 u.l = val;
2178 /* NaN are not treated the same way IEEE 754 does */
2179 if (unlikely(isnan(u.f)))
2180 return 0;
2181 tmp = uint64_to_float32(1ULL << 32, &env->spe_status);
2182 u.f = float32_mul(u.f, tmp, &env->spe_status);
2183
2184 return float32_to_uint32(u.f, &env->spe_status);
2185 }
2186
2187 #define HELPER_SPE_SINGLE_CONV(name) \
2188 uint32_t helper_e##name (uint32_t val) \
2189 { \
2190 return e##name(val); \
2191 }
2192 /* efscfsi */
2193 HELPER_SPE_SINGLE_CONV(fscfsi);
2194 /* efscfui */
2195 HELPER_SPE_SINGLE_CONV(fscfui);
2196 /* efscfuf */
2197 HELPER_SPE_SINGLE_CONV(fscfuf);
2198 /* efscfsf */
2199 HELPER_SPE_SINGLE_CONV(fscfsf);
2200 /* efsctsi */
2201 HELPER_SPE_SINGLE_CONV(fsctsi);
2202 /* efsctui */
2203 HELPER_SPE_SINGLE_CONV(fsctui);
2204 /* efsctsiz */
2205 HELPER_SPE_SINGLE_CONV(fsctsiz);
2206 /* efsctuiz */
2207 HELPER_SPE_SINGLE_CONV(fsctuiz);
2208 /* efsctsf */
2209 HELPER_SPE_SINGLE_CONV(fsctsf);
2210 /* efsctuf */
2211 HELPER_SPE_SINGLE_CONV(fsctuf);
2212
2213 #define HELPER_SPE_VECTOR_CONV(name) \
2214 uint64_t helper_ev##name (uint64_t val) \
2215 { \
2216 return ((uint64_t)e##name(val >> 32) << 32) | \
2217 (uint64_t)e##name(val); \
2218 }
2219 /* evfscfsi */
2220 HELPER_SPE_VECTOR_CONV(fscfsi);
2221 /* evfscfui */
2222 HELPER_SPE_VECTOR_CONV(fscfui);
2223 /* evfscfuf */
2224 HELPER_SPE_VECTOR_CONV(fscfuf);
2225 /* evfscfsf */
2226 HELPER_SPE_VECTOR_CONV(fscfsf);
2227 /* evfsctsi */
2228 HELPER_SPE_VECTOR_CONV(fsctsi);
2229 /* evfsctui */
2230 HELPER_SPE_VECTOR_CONV(fsctui);
2231 /* evfsctsiz */
2232 HELPER_SPE_VECTOR_CONV(fsctsiz);
2233 /* evfsctuiz */
2234 HELPER_SPE_VECTOR_CONV(fsctuiz);
2235 /* evfsctsf */
2236 HELPER_SPE_VECTOR_CONV(fsctsf);
2237 /* evfsctuf */
2238 HELPER_SPE_VECTOR_CONV(fsctuf);
2239
2240 /* Single-precision floating-point arithmetic */
2241 static always_inline uint32_t efsadd (uint32_t op1, uint32_t op2)
2242 {
2243 CPU_FloatU u1, u2;
2244 u1.l = op1;
2245 u2.l = op2;
2246 u1.f = float32_add(u1.f, u2.f, &env->spe_status);
2247 return u1.l;
2248 }
2249
2250 static always_inline uint32_t efssub (uint32_t op1, uint32_t op2)
2251 {
2252 CPU_FloatU u1, u2;
2253 u1.l = op1;
2254 u2.l = op2;
2255 u1.f = float32_sub(u1.f, u2.f, &env->spe_status);
2256 return u1.l;
2257 }
2258
2259 static always_inline uint32_t efsmul (uint32_t op1, uint32_t op2)
2260 {
2261 CPU_FloatU u1, u2;
2262 u1.l = op1;
2263 u2.l = op2;
2264 u1.f = float32_mul(u1.f, u2.f, &env->spe_status);
2265 return u1.l;
2266 }
2267
2268 static always_inline uint32_t efsdiv (uint32_t op1, uint32_t op2)
2269 {
2270 CPU_FloatU u1, u2;
2271 u1.l = op1;
2272 u2.l = op2;
2273 u1.f = float32_div(u1.f, u2.f, &env->spe_status);
2274 return u1.l;
2275 }
2276
2277 #define HELPER_SPE_SINGLE_ARITH(name) \
2278 uint32_t helper_e##name (uint32_t op1, uint32_t op2) \
2279 { \
2280 return e##name(op1, op2); \
2281 }
2282 /* efsadd */
2283 HELPER_SPE_SINGLE_ARITH(fsadd);
2284 /* efssub */
2285 HELPER_SPE_SINGLE_ARITH(fssub);
2286 /* efsmul */
2287 HELPER_SPE_SINGLE_ARITH(fsmul);
2288 /* efsdiv */
2289 HELPER_SPE_SINGLE_ARITH(fsdiv);
2290
2291 #define HELPER_SPE_VECTOR_ARITH(name) \
2292 uint64_t helper_ev##name (uint64_t op1, uint64_t op2) \
2293 { \
2294 return ((uint64_t)e##name(op1 >> 32, op2 >> 32) << 32) | \
2295 (uint64_t)e##name(op1, op2); \
2296 }
2297 /* evfsadd */
2298 HELPER_SPE_VECTOR_ARITH(fsadd);
2299 /* evfssub */
2300 HELPER_SPE_VECTOR_ARITH(fssub);
2301 /* evfsmul */
2302 HELPER_SPE_VECTOR_ARITH(fsmul);
2303 /* evfsdiv */
2304 HELPER_SPE_VECTOR_ARITH(fsdiv);
2305
2306 /* Single-precision floating-point comparisons */
2307 static always_inline uint32_t efststlt (uint32_t op1, uint32_t op2)
2308 {
2309 CPU_FloatU u1, u2;
2310 u1.l = op1;
2311 u2.l = op2;
2312 return float32_lt(u1.f, u2.f, &env->spe_status) ? 4 : 0;
2313 }
2314
2315 static always_inline uint32_t efststgt (uint32_t op1, uint32_t op2)
2316 {
2317 CPU_FloatU u1, u2;
2318 u1.l = op1;
2319 u2.l = op2;
2320 return float32_le(u1.f, u2.f, &env->spe_status) ? 0 : 4;
2321 }
2322
2323 static always_inline uint32_t efststeq (uint32_t op1, uint32_t op2)
2324 {
2325 CPU_FloatU u1, u2;
2326 u1.l = op1;
2327 u2.l = op2;
2328 return float32_eq(u1.f, u2.f, &env->spe_status) ? 4 : 0;
2329 }
2330
2331 static always_inline uint32_t efscmplt (uint32_t op1, uint32_t op2)
2332 {
2333 /* XXX: TODO: test special values (NaN, infinites, ...) */
2334 return efststlt(op1, op2);
2335 }
2336
2337 static always_inline uint32_t efscmpgt (uint32_t op1, uint32_t op2)
2338 {
2339 /* XXX: TODO: test special values (NaN, infinites, ...) */
2340 return efststgt(op1, op2);
2341 }
2342
2343 static always_inline uint32_t efscmpeq (uint32_t op1, uint32_t op2)
2344 {
2345 /* XXX: TODO: test special values (NaN, infinites, ...) */
2346 return efststeq(op1, op2);
2347 }
2348
2349 #define HELPER_SINGLE_SPE_CMP(name) \
2350 uint32_t helper_e##name (uint32_t op1, uint32_t op2) \
2351 { \
2352 return e##name(op1, op2) << 2; \
2353 }
2354 /* efststlt */
2355 HELPER_SINGLE_SPE_CMP(fststlt);
2356 /* efststgt */
2357 HELPER_SINGLE_SPE_CMP(fststgt);
2358 /* efststeq */
2359 HELPER_SINGLE_SPE_CMP(fststeq);
2360 /* efscmplt */
2361 HELPER_SINGLE_SPE_CMP(fscmplt);
2362 /* efscmpgt */
2363 HELPER_SINGLE_SPE_CMP(fscmpgt);
2364 /* efscmpeq */
2365 HELPER_SINGLE_SPE_CMP(fscmpeq);
2366
2367 static always_inline uint32_t evcmp_merge (int t0, int t1)
2368 {
2369 return (t0 << 3) | (t1 << 2) | ((t0 | t1) << 1) | (t0 & t1);
2370 }
2371
2372 #define HELPER_VECTOR_SPE_CMP(name) \
2373 uint32_t helper_ev##name (uint64_t op1, uint64_t op2) \
2374 { \
2375 return evcmp_merge(e##name(op1 >> 32, op2 >> 32), e##name(op1, op2)); \
2376 }
2377 /* evfststlt */
2378 HELPER_VECTOR_SPE_CMP(fststlt);
2379 /* evfststgt */
2380 HELPER_VECTOR_SPE_CMP(fststgt);
2381 /* evfststeq */
2382 HELPER_VECTOR_SPE_CMP(fststeq);
2383 /* evfscmplt */
2384 HELPER_VECTOR_SPE_CMP(fscmplt);
2385 /* evfscmpgt */
2386 HELPER_VECTOR_SPE_CMP(fscmpgt);
2387 /* evfscmpeq */
2388 HELPER_VECTOR_SPE_CMP(fscmpeq);
2389
2390 /* Double-precision floating-point conversion */
2391 uint64_t helper_efdcfsi (uint32_t val)
2392 {
2393 CPU_DoubleU u;
2394
2395 u.d = int32_to_float64(val, &env->spe_status);
2396
2397 return u.ll;
2398 }
2399
2400 uint64_t helper_efdcfsid (uint64_t val)
2401 {
2402 CPU_DoubleU u;
2403
2404 u.d = int64_to_float64(val, &env->spe_status);
2405
2406 return u.ll;
2407 }
2408
2409 uint64_t helper_efdcfui (uint32_t val)
2410 {
2411 CPU_DoubleU u;
2412
2413 u.d = uint32_to_float64(val, &env->spe_status);
2414
2415 return u.ll;
2416 }
2417
2418 uint64_t helper_efdcfuid (uint64_t val)
2419 {
2420 CPU_DoubleU u;
2421
2422 u.d = uint64_to_float64(val, &env->spe_status);
2423
2424 return u.ll;
2425 }
2426
2427 uint32_t helper_efdctsi (uint64_t val)
2428 {
2429 CPU_DoubleU u;
2430
2431 u.ll = val;
2432 /* NaN are not treated the same way IEEE 754 does */
2433 if (unlikely(isnan(u.d)))
2434 return 0;
2435
2436 return float64_to_int32(u.d, &env->spe_status);
2437 }
2438
2439 uint32_t helper_efdctui (uint64_t val)
2440 {
2441 CPU_DoubleU u;
2442
2443 u.ll = val;
2444 /* NaN are not treated the same way IEEE 754 does */
2445 if (unlikely(isnan(u.d)))
2446 return 0;
2447
2448 return float64_to_uint32(u.d, &env->spe_status);
2449 }
2450
2451 uint32_t helper_efdctsiz (uint64_t val)
2452 {
2453 CPU_DoubleU u;
2454
2455 u.ll = val;
2456 /* NaN are not treated the same way IEEE 754 does */
2457 if (unlikely(isnan(u.d)))
2458 return 0;
2459
2460 return float64_to_int32_round_to_zero(u.d, &env->spe_status);
2461 }
2462
2463 uint64_t helper_efdctsidz (uint64_t val)
2464 {
2465 CPU_DoubleU u;
2466
2467 u.ll = val;
2468 /* NaN are not treated the same way IEEE 754 does */
2469 if (unlikely(isnan(u.d)))
2470 return 0;
2471
2472 return float64_to_int64_round_to_zero(u.d, &env->spe_status);
2473 }
2474
2475 uint32_t helper_efdctuiz (uint64_t val)
2476 {
2477 CPU_DoubleU u;
2478
2479 u.ll = val;
2480 /* NaN are not treated the same way IEEE 754 does */
2481 if (unlikely(isnan(u.d)))
2482 return 0;
2483
2484 return float64_to_uint32_round_to_zero(u.d, &env->spe_status);
2485 }
2486
2487 uint64_t helper_efdctuidz (uint64_t val)
2488 {
2489 CPU_DoubleU u;
2490
2491 u.ll = val;
2492 /* NaN are not treated the same way IEEE 754 does */
2493 if (unlikely(isnan(u.d)))
2494 return 0;
2495
2496 return float64_to_uint64_round_to_zero(u.d, &env->spe_status);
2497 }
2498
2499 uint64_t helper_efdcfsf (uint32_t val)
2500 {
2501 CPU_DoubleU u;
2502 float64 tmp;
2503
2504 u.d = int32_to_float64(val, &env->spe_status);
2505 tmp = int64_to_float64(1ULL << 32, &env->spe_status);
2506 u.d = float64_div(u.d, tmp, &env->spe_status);
2507
2508 return u.ll;
2509 }
2510
2511 uint64_t helper_efdcfuf (uint32_t val)
2512 {
2513 CPU_DoubleU u;
2514 float64 tmp;
2515
2516 u.d = uint32_to_float64(val, &env->spe_status);
2517 tmp = int64_to_float64(1ULL << 32, &env->spe_status);
2518 u.d = float64_div(u.d, tmp, &env->spe_status);
2519
2520 return u.ll;
2521 }
2522
2523 uint32_t helper_efdctsf (uint64_t val)
2524 {
2525 CPU_DoubleU u;
2526 float64 tmp;
2527
2528 u.ll = val;
2529 /* NaN are not treated the same way IEEE 754 does */
2530 if (unlikely(isnan(u.d)))
2531 return 0;
2532 tmp = uint64_to_float64(1ULL << 32, &env->spe_status);
2533 u.d = float64_mul(u.d, tmp, &env->spe_status);
2534
2535 return float64_to_int32(u.d, &env->spe_status);
2536 }
2537
2538 uint32_t helper_efdctuf (uint64_t val)
2539 {
2540 CPU_DoubleU u;
2541 float64 tmp;
2542
2543 u.ll = val;
2544 /* NaN are not treated the same way IEEE 754 does */
2545 if (unlikely(isnan(u.d)))
2546 return 0;
2547 tmp = uint64_to_float64(1ULL << 32, &env->spe_status);
2548 u.d = float64_mul(u.d, tmp, &env->spe_status);
2549
2550 return float64_to_uint32(u.d, &env->spe_status);
2551 }
2552
2553 uint32_t helper_efscfd (uint64_t val)
2554 {
2555 CPU_DoubleU u1;
2556 CPU_FloatU u2;
2557
2558 u1.ll = val;
2559 u2.f = float64_to_float32(u1.d, &env->spe_status);
2560
2561 return u2.l;
2562 }
2563
2564 uint64_t helper_efdcfs (uint32_t val)
2565 {
2566 CPU_DoubleU u2;
2567 CPU_FloatU u1;
2568
2569 u1.l = val;
2570 u2.d = float32_to_float64(u1.f, &env->spe_status);
2571
2572 return u2.ll;
2573 }
2574
2575 /* Double precision fixed-point arithmetic */
2576 uint64_t helper_efdadd (uint64_t op1, uint64_t op2)
2577 {
2578 CPU_DoubleU u1, u2;
2579 u1.ll = op1;
2580 u2.ll = op2;
2581 u1.d = float64_add(u1.d, u2.d, &env->spe_status);
2582 return u1.ll;
2583 }
2584
2585 uint64_t helper_efdsub (uint64_t op1, uint64_t op2)
2586 {
2587 CPU_DoubleU u1, u2;
2588 u1.ll = op1;
2589 u2.ll = op2;
2590 u1.d = float64_sub(u1.d, u2.d, &env->spe_status);
2591 return u1.ll;
2592 }
2593
2594 uint64_t helper_efdmul (uint64_t op1, uint64_t op2)
2595 {
2596 CPU_DoubleU u1, u2;
2597 u1.ll = op1;
2598 u2.ll = op2;
2599 u1.d = float64_mul(u1.d, u2.d, &env->spe_status);
2600 return u1.ll;
2601 }
2602
2603 uint64_t helper_efddiv (uint64_t op1, uint64_t op2)
2604 {
2605 CPU_DoubleU u1, u2;
2606 u1.ll = op1;
2607 u2.ll = op2;
2608 u1.d = float64_div(u1.d, u2.d, &env->spe_status);
2609 return u1.ll;
2610 }
2611
2612 /* Double precision floating point helpers */
2613 uint32_t helper_efdtstlt (uint64_t op1, uint64_t op2)
2614 {
2615 CPU_DoubleU u1, u2;
2616 u1.ll = op1;
2617 u2.ll = op2;
2618 return float64_lt(u1.d, u2.d, &env->spe_status) ? 4 : 0;
2619 }
2620
2621 uint32_t helper_efdtstgt (uint64_t op1, uint64_t op2)
2622 {
2623 CPU_DoubleU u1, u2;
2624 u1.ll = op1;
2625 u2.ll = op2;
2626 return float64_le(u1.d, u2.d, &env->spe_status) ? 0 : 4;
2627 }
2628
2629 uint32_t helper_efdtsteq (uint64_t op1, uint64_t op2)
2630 {
2631 CPU_DoubleU u1, u2;
2632 u1.ll = op1;
2633 u2.ll = op2;
2634 return float64_eq(u1.d, u2.d, &env->spe_status) ? 4 : 0;
2635 }
2636
2637 uint32_t helper_efdcmplt (uint64_t op1, uint64_t op2)
2638 {
2639 /* XXX: TODO: test special values (NaN, infinites, ...) */
2640 return helper_efdtstlt(op1, op2);
2641 }
2642
2643 uint32_t helper_efdcmpgt (uint64_t op1, uint64_t op2)
2644 {
2645 /* XXX: TODO: test special values (NaN, infinites, ...) */
2646 return helper_efdtstgt(op1, op2);
2647 }
2648
2649 uint32_t helper_efdcmpeq (uint64_t op1, uint64_t op2)
2650 {
2651 /* XXX: TODO: test special values (NaN, infinites, ...) */
2652 return helper_efdtsteq(op1, op2);
2653 }
2654
2655 /*****************************************************************************/
2656 /* Softmmu support */
2657 #if !defined (CONFIG_USER_ONLY)
2658
2659 #define MMUSUFFIX _mmu
2660
2661 #define SHIFT 0
2662 #include "softmmu_template.h"
2663
2664 #define SHIFT 1
2665 #include "softmmu_template.h"
2666
2667 #define SHIFT 2
2668 #include "softmmu_template.h"
2669
2670 #define SHIFT 3
2671 #include "softmmu_template.h"
2672
2673 /* try to fill the TLB and return an exception if error. If retaddr is
2674 NULL, it means that the function was called in C code (i.e. not
2675 from generated code or from helper.c) */
2676 /* XXX: fix it to restore all registers */
2677 void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
2678 {
2679 TranslationBlock *tb;
2680 CPUState *saved_env;
2681 unsigned long pc;
2682 int ret;
2683
2684 /* XXX: hack to restore env in all cases, even if not called from
2685 generated code */
2686 saved_env = env;
2687 env = cpu_single_env;
2688 ret = cpu_ppc_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
2689 if (unlikely(ret != 0)) {
2690 if (likely(retaddr)) {
2691 /* now we have a real cpu fault */
2692 pc = (unsigned long)retaddr;
2693 tb = tb_find_pc(pc);
2694 if (likely(tb)) {
2695 /* the PC is inside the translated code. It means that we have
2696 a virtual CPU fault */
2697 cpu_restore_state(tb, env, pc, NULL);
2698 }
2699 }
2700 raise_exception_err(env, env->exception_index, env->error_code);
2701 }
2702 env = saved_env;
2703 }
2704
2705 /* Software driven TLBs management */
2706 /* PowerPC 602/603 software TLB load instructions helpers */
2707 static void helper_load_6xx_tlb (target_ulong new_EPN, int is_code)
2708 {
2709 target_ulong RPN, CMP, EPN;
2710 int way;
2711
2712 RPN = env->spr[SPR_RPA];
2713 if (is_code) {
2714 CMP = env->spr[SPR_ICMP];
2715 EPN = env->spr[SPR_IMISS];
2716 } else {
2717 CMP = env->spr[SPR_DCMP];
2718 EPN = env->spr[SPR_DMISS];
2719 }
2720 way = (env->spr[SPR_SRR1] >> 17) & 1;
2721 #if defined (DEBUG_SOFTWARE_TLB)
2722 if (loglevel != 0) {
2723 fprintf(logfile, "%s: EPN " TDX " " ADDRX " PTE0 " ADDRX
2724 " PTE1 " ADDRX " way %d\n",
2725 __func__, T0, EPN, CMP, RPN, way);
2726 }
2727 #endif
2728 /* Store this TLB */
2729 ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
2730 way, is_code, CMP, RPN);
2731 }
2732
2733 void helper_load_6xx_tlbd (target_ulong EPN)
2734 {
2735 helper_load_6xx_tlb(EPN, 0);
2736 }
2737
2738 void helper_load_6xx_tlbi (target_ulong EPN)
2739 {
2740 helper_load_6xx_tlb(EPN, 1);
2741 }
2742
2743 /* PowerPC 74xx software TLB load instructions helpers */
2744 static void helper_load_74xx_tlb (target_ulong new_EPN, int is_code)
2745 {
2746 target_ulong RPN, CMP, EPN;
2747 int way;
2748
2749 RPN = env->spr[SPR_PTELO];
2750 CMP = env->spr[SPR_PTEHI];
2751 EPN = env->spr[SPR_TLBMISS] & ~0x3;
2752 way = env->spr[SPR_TLBMISS] & 0x3;
2753 #if defined (DEBUG_SOFTWARE_TLB)
2754 if (loglevel != 0) {
2755 fprintf(logfile, "%s: EPN " TDX " " ADDRX " PTE0 " ADDRX
2756 " PTE1 " ADDRX " way %d\n",
2757 __func__, T0, EPN, CMP, RPN, way);
2758 }
2759 #endif
2760 /* Store this TLB */
2761 ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
2762 way, is_code, CMP, RPN);
2763 }
2764
2765 void helper_load_74xx_tlbd (target_ulong EPN)
2766 {
2767 helper_load_74xx_tlb(EPN, 0);
2768 }
2769
2770 void helper_load_74xx_tlbi (target_ulong EPN)
2771 {
2772 helper_load_74xx_tlb(EPN, 1);
2773 }
2774
2775 static always_inline target_ulong booke_tlb_to_page_size (int size)
2776 {
2777 return 1024 << (2 * size);
2778 }
2779
2780 static always_inline int booke_page_size_to_tlb (target_ulong page_size)
2781 {
2782 int size;
2783
2784 switch (page_size) {
2785 case 0x00000400UL:
2786 size = 0x0;
2787 break;
2788 case 0x00001000UL:
2789 size = 0x1;
2790 break;
2791 case 0x00004000UL:
2792 size = 0x2;
2793 break;
2794 case 0x00010000UL:
2795 size = 0x3;
2796 break;
2797 case 0x00040000UL:
2798 size = 0x4;
2799 break;
2800 case 0x00100000UL:
2801 size = 0x5;
2802 break;
2803 case 0x00400000UL:
2804 size = 0x6;
2805 break;
2806 case 0x01000000UL:
2807 size = 0x7;
2808 break;
2809 case 0x04000000UL:
2810 size = 0x8;
2811 break;
2812 case 0x10000000UL:
2813 size = 0x9;
2814 break;
2815 case 0x40000000UL:
2816 size = 0xA;
2817 break;
2818 #if defined (TARGET_PPC64)
2819 case 0x000100000000ULL:
2820 size = 0xB;
2821 break;
2822 case 0x000400000000ULL:
2823 size = 0xC;
2824 break;
2825 case 0x001000000000ULL:
2826 size = 0xD;
2827 break;
2828 case 0x004000000000ULL:
2829 size = 0xE;
2830 break;
2831 case 0x010000000000ULL:
2832 size = 0xF;
2833 break;
2834 #endif
2835 default:
2836 size = -1;
2837 break;
2838 }
2839
2840 return size;
2841 }
2842
2843 /* Helpers for 4xx TLB management */
2844 void do_4xx_tlbre_lo (void)
2845 {
2846 ppcemb_tlb_t *tlb;
2847 int size;
2848
2849 T0 &= 0x3F;
2850 tlb = &env->tlb[T0].tlbe;
2851 T0 = tlb->EPN;
2852 if (tlb->prot & PAGE_VALID)
2853 T0 |= 0x400;
2854 size = booke_page_size_to_tlb(tlb->size);
2855 if (size < 0 || size > 0x7)
2856 size = 1;
2857 T0 |= size << 7;
2858 env->spr[SPR_40x_PID] = tlb->PID;
2859 }
2860
2861 void do_4xx_tlbre_hi (void)
2862 {
2863 ppcemb_tlb_t *tlb;
2864
2865 T0 &= 0x3F;
2866 tlb = &env->tlb[T0].tlbe;
2867 T0 = tlb->RPN;
2868 if (tlb->prot & PAGE_EXEC)
2869 T0 |= 0x200;
2870 if (tlb->prot & PAGE_WRITE)
2871 T0 |= 0x100;
2872 }
2873
2874 void do_4xx_tlbwe_hi (void)
2875 {
2876 ppcemb_tlb_t *tlb;
2877 target_ulong page, end;
2878
2879 #if defined (DEBUG_SOFTWARE_TLB)
2880 if (loglevel != 0) {
2881 fprintf(logfile, "%s T0 " TDX " T1 " TDX "\n", __func__, T0, T1);
2882 }
2883 #endif
2884 T0 &= 0x3F;
2885 tlb = &env->tlb[T0].tlbe;
2886 /* Invalidate previous TLB (if it's valid) */
2887 if (tlb->prot & PAGE_VALID) {
2888 end = tlb->EPN + tlb->size;
2889 #if defined (DEBUG_SOFTWARE_TLB)
2890 if (loglevel != 0) {
2891 fprintf(logfile, "%s: invalidate old TLB %d start " ADDRX
2892 " end " ADDRX "\n", __func__, (int)T0, tlb->EPN, end);
2893 }
2894 #endif
2895 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
2896 tlb_flush_page(env, page);
2897 }
2898 tlb->size = booke_tlb_to_page_size((T1 >> 7) & 0x7);
2899 /* We cannot handle TLB size < TARGET_PAGE_SIZE.
2900 * If this ever occurs, one should use the ppcemb target instead
2901 * of the ppc or ppc64 one
2902 */
2903 if ((T1 & 0x40) && tlb->size < TARGET_PAGE_SIZE) {
2904 cpu_abort(env, "TLB size " TARGET_FMT_lu " < %u "
2905 "are not supported (%d)\n",
2906 tlb->size, TARGET_PAGE_SIZE, (int)((T1 >> 7) & 0x7));
2907 }
2908 tlb->EPN = T1 & ~(tlb->size - 1);
2909 if (T1 & 0x40)
2910 tlb->prot |= PAGE_VALID;
2911 else
2912 tlb->prot &= ~PAGE_VALID;
2913 if (T1 & 0x20) {
2914 /* XXX: TO BE FIXED */
2915 cpu_abort(env, "Little-endian TLB entries are not supported by now\n");
2916 }
2917 tlb->PID = env->spr[SPR_40x_PID]; /* PID */
2918 tlb->attr = T1 & 0xFF;
2919 #if defined (DEBUG_SOFTWARE_TLB)
2920 if (loglevel != 0) {
2921 fprintf(logfile, "%s: set up TLB %d RPN " PADDRX " EPN " ADDRX
2922 " size " ADDRX " prot %c%c%c%c PID %d\n", __func__,
2923 (int)T0, tlb->RPN, tlb->EPN, tlb->size,
2924 tlb->prot & PAGE_READ ? 'r' : '-',
2925 tlb->prot & PAGE_WRITE ? 'w' : '-',
2926 tlb->prot & PAGE_EXEC ? 'x' : '-',
2927 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
2928 }
2929 #endif
2930 /* Invalidate new TLB (if valid) */
2931 if (tlb->prot & PAGE_VALID) {
2932 end = tlb->EPN + tlb->size;
2933 #if defined (DEBUG_SOFTWARE_TLB)
2934 if (loglevel != 0) {
2935 fprintf(logfile, "%s: invalidate TLB %d start " ADDRX
2936 " end " ADDRX "\n", __func__, (int)T0, tlb->EPN, end);
2937 }
2938 #endif
2939 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
2940 tlb_flush_page(env, page);
2941 }
2942 }
2943
2944 void do_4xx_tlbwe_lo (void)
2945 {
2946 ppcemb_tlb_t *tlb;
2947
2948 #if defined (DEBUG_SOFTWARE_TLB)
2949 if (loglevel != 0) {
2950 fprintf(logfile, "%s T0 " TDX " T1 " TDX "\n", __func__, T0, T1);
2951 }
2952 #endif
2953 T0 &= 0x3F;
2954 tlb = &env->tlb[T0].tlbe;
2955 tlb->RPN = T1 & 0xFFFFFC00;
2956 tlb->prot = PAGE_READ;
2957 if (T1 & 0x200)
2958 tlb->prot |= PAGE_EXEC;
2959 if (T1 & 0x100)
2960 tlb->prot |= PAGE_WRITE;
2961 #if defined (DEBUG_SOFTWARE_TLB)
2962 if (loglevel != 0) {
2963 fprintf(logfile, "%s: set up TLB %d RPN " PADDRX " EPN " ADDRX
2964 " size " ADDRX " prot %c%c%c%c PID %d\n", __func__,
2965 (int)T0, tlb->RPN, tlb->EPN, tlb->size,
2966 tlb->prot & PAGE_READ ? 'r' : '-',
2967 tlb->prot & PAGE_WRITE ? 'w' : '-',
2968 tlb->prot & PAGE_EXEC ? 'x' : '-',
2969 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
2970 }
2971 #endif
2972 }
2973
2974 /* PowerPC 440 TLB management */
2975 void do_440_tlbwe (int word)
2976 {
2977 ppcemb_tlb_t *tlb;
2978 target_ulong EPN, RPN, size;
2979 int do_flush_tlbs;
2980
2981 #if defined (DEBUG_SOFTWARE_TLB)
2982 if (loglevel != 0) {
2983 fprintf(logfile, "%s word %d T0 " TDX " T1 " TDX "\n",
2984 __func__, word, T0, T1);
2985 }
2986 #endif
2987 do_flush_tlbs = 0;
2988 T0 &= 0x3F;
2989 tlb = &env->tlb[T0].tlbe;
2990 switch (word) {
2991 default:
2992 /* Just here to please gcc */
2993 case 0:
2994 EPN = T1 & 0xFFFFFC00;
2995 if ((tlb->prot & PAGE_VALID) && EPN != tlb->EPN)
2996 do_flush_tlbs = 1;
2997 tlb->EPN = EPN;
2998 size = booke_tlb_to_page_size((T1 >> 4) & 0xF);
2999 if ((tlb->prot & PAGE_VALID) && tlb->size < size)
3000 do_flush_tlbs = 1;
3001 tlb->size = size;
3002 tlb->attr &= ~0x1;
3003 tlb->attr |= (T1 >> 8) & 1;
3004 if (T1 & 0x200) {
3005 tlb->prot |= PAGE_VALID;
3006 } else {
3007 if (tlb->prot & PAGE_VALID) {
3008 tlb->prot &= ~PAGE_VALID;
3009 do_flush_tlbs = 1;
3010 }
3011 }
3012 tlb->PID = env->spr[SPR_440_MMUCR] & 0x000000FF;
3013 if (do_flush_tlbs)
3014 tlb_flush(env, 1);
3015 break;
3016 case 1:
3017 RPN = T1 & 0xFFFFFC0F;
3018 if ((tlb->prot & PAGE_VALID) && tlb->RPN != RPN)
3019 tlb_flush(env, 1);
3020 tlb->RPN = RPN;
3021 break;
3022 case 2:
3023 tlb->attr = (tlb->attr & 0x1) | (T1 & 0x0000FF00);
3024 tlb->prot = tlb->prot & PAGE_VALID;
3025 if (T1 & 0x1)
3026 tlb->prot |= PAGE_READ << 4;
3027 if (T1 & 0x2)
3028 tlb->prot |= PAGE_WRITE << 4;
3029 if (T1 & 0x4)
3030 tlb->prot |= PAGE_EXEC << 4;
3031 if (T1 & 0x8)
3032 tlb->prot |= PAGE_READ;
3033 if (T1 & 0x10)
3034 tlb->prot |= PAGE_WRITE;
3035 if (T1 & 0x20)
3036 tlb->prot |= PAGE_EXEC;
3037 break;
3038 }
3039 }
3040
3041 void do_440_tlbre (int word)
3042 {
3043 ppcemb_tlb_t *tlb;
3044 int size;
3045
3046 T0 &= 0x3F;
3047 tlb = &env->tlb[T0].tlbe;
3048 switch (word) {
3049 default:
3050 /* Just here to please gcc */
3051 case 0:
3052 T0 = tlb->EPN;
3053 size = booke_page_size_to_tlb(tlb->size);
3054 if (size < 0 || size > 0xF)
3055 size = 1;
3056 T0 |= size << 4;
3057 if (tlb->attr & 0x1)
3058 T0 |= 0x100;
3059 if (tlb->prot & PAGE_VALID)
3060 T0 |= 0x200;
3061 env->spr[SPR_440_MMUCR] &= ~0x000000FF;
3062 env->spr[SPR_440_MMUCR] |= tlb->PID;
3063 break;
3064 case 1:
3065 T0 = tlb->RPN;
3066 break;
3067 case 2:
3068 T0 = tlb->attr & ~0x1;
3069 if (tlb->prot & (PAGE_READ << 4))
3070 T0 |= 0x1;
3071 if (tlb->prot & (PAGE_WRITE << 4))
3072 T0 |= 0x2;
3073 if (tlb->prot & (PAGE_EXEC << 4))
3074 T0 |= 0x4;
3075 if (tlb->prot & PAGE_READ)
3076 T0 |= 0x8;
3077 if (tlb->prot & PAGE_WRITE)
3078 T0 |= 0x10;
3079 if (tlb->prot & PAGE_EXEC)
3080 T0 |= 0x20;
3081 break;
3082 }
3083 }
3084 #endif /* !CONFIG_USER_ONLY */
Qemu copy for testing