?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/ppc: Move vsel and vperm/vpermr to decodetree
[qemu.git] / target / ppc / int_helper.c
blob6c63c7b2278c81acb6c2e6780304cdfd9b529df7
1 /*
2 * PowerPC integer and vector 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.1 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
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "internal.h"
23 #include "qemu/host-utils.h"
24 #include "qemu/main-loop.h"
25 #include "qemu/log.h"
26 #include "exec/helper-proto.h"
27 #include "crypto/aes.h"
28 #include "fpu/softfloat.h"
29 #include "qapi/error.h"
30 #include "qemu/guest-random.h"
31
32 #include "helper_regs.h"
33 /*****************************************************************************/
34 /* Fixed point operations helpers */
35
36 static inline void helper_update_ov_legacy(CPUPPCState *env, int ov)
37 {
38 if (unlikely(ov)) {
39 env->so = env->ov = 1;
40 } else {
41 env->ov = 0;
42 }
43 }
44
45 target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb,
46 uint32_t oe)
47 {
48 uint64_t rt = 0;
49 int overflow = 0;
50
51 uint64_t dividend = (uint64_t)ra << 32;
52 uint64_t divisor = (uint32_t)rb;
53
54 if (unlikely(divisor == 0)) {
55 overflow = 1;
56 } else {
57 rt = dividend / divisor;
58 overflow = rt > UINT32_MAX;
59 }
60
61 if (unlikely(overflow)) {
62 rt = 0; /* Undefined */
63 }
64
65 if (oe) {
66 helper_update_ov_legacy(env, overflow);
67 }
68
69 return (target_ulong)rt;
70 }
71
72 target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb,
73 uint32_t oe)
74 {
75 int64_t rt = 0;
76 int overflow = 0;
77
78 int64_t dividend = (int64_t)ra << 32;
79 int64_t divisor = (int64_t)((int32_t)rb);
80
81 if (unlikely((divisor == 0) ||
82 ((divisor == -1ull) && (dividend == INT64_MIN)))) {
83 overflow = 1;
84 } else {
85 rt = dividend / divisor;
86 overflow = rt != (int32_t)rt;
87 }
88
89 if (unlikely(overflow)) {
90 rt = 0; /* Undefined */
91 }
92
93 if (oe) {
94 helper_update_ov_legacy(env, overflow);
95 }
96
97 return (target_ulong)rt;
98 }
99
100 #if defined(TARGET_PPC64)
101
102 uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe)
103 {
104 uint64_t rt = 0;
105 int overflow = 0;
106
107 if (unlikely(rb == 0 || ra >= rb)) {
108 overflow = 1;
109 rt = 0; /* Undefined */
110 } else {
111 divu128(&rt, &ra, rb);
112 }
113
114 if (oe) {
115 helper_update_ov_legacy(env, overflow);
116 }
117
118 return rt;
119 }
120
121 uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe)
122 {
123 uint64_t rt = 0;
124 int64_t ra = (int64_t)rau;
125 int64_t rb = (int64_t)rbu;
126 int overflow = 0;
127
128 if (unlikely(rb == 0 || uabs64(ra) >= uabs64(rb))) {
129 overflow = 1;
130 rt = 0; /* Undefined */
131 } else {
132 divs128(&rt, &ra, rb);
133 }
134
135 if (oe) {
136 helper_update_ov_legacy(env, overflow);
137 }
138
139 return rt;
140 }
141
142 #endif
143
144
145 #if defined(TARGET_PPC64)
146 /* if x = 0xab, returns 0xababababababababa */
147 #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff))
148
149 /*
150 * subtract 1 from each byte, and with inverse, check if MSB is set at each
151 * byte.
152 * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80
153 * (0xFF & 0xFF) & 0x80 = 0x80 (zero found)
154 */
155 #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80))
156
157 /* When you XOR the pattern and there is a match, that byte will be zero */
158 #define hasvalue(x, n) (haszero((x) ^ pattern(n)))
159
160 uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb)
161 {
162 return hasvalue(rb, ra) ? CRF_GT : 0;
163 }
164
165 #undef pattern
166 #undef haszero
167 #undef hasvalue
168
169 /*
170 * Return a random number.
171 */
172 uint64_t helper_darn32(void)
173 {
174 Error *err = NULL;
175 uint32_t ret;
176
177 if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) {
178 qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s",
179 error_get_pretty(err));
180 error_free(err);
181 return -1;
182 }
183
184 return ret;
185 }
186
187 uint64_t helper_darn64(void)
188 {
189 Error *err = NULL;
190 uint64_t ret;
191
192 if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) {
193 qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s",
194 error_get_pretty(err));
195 error_free(err);
196 return -1;
197 }
198
199 return ret;
200 }
201
202 uint64_t helper_bpermd(uint64_t rs, uint64_t rb)
203 {
204 int i;
205 uint64_t ra = 0;
206
207 for (i = 0; i < 8; i++) {
208 int index = (rs >> (i * 8)) & 0xFF;
209 if (index < 64) {
210 if (rb & PPC_BIT(index)) {
211 ra |= 1 << i;
212 }
213 }
214 }
215 return ra;
216 }
217
218 #endif
219
220 target_ulong helper_cmpb(target_ulong rs, target_ulong rb)
221 {
222 target_ulong mask = 0xff;
223 target_ulong ra = 0;
224 int i;
225
226 for (i = 0; i < sizeof(target_ulong); i++) {
227 if ((rs & mask) == (rb & mask)) {
228 ra |= mask;
229 }
230 mask <<= 8;
231 }
232 return ra;
233 }
234
235 /* shift right arithmetic helper */
236 target_ulong helper_sraw(CPUPPCState *env, target_ulong value,
237 target_ulong shift)
238 {
239 int32_t ret;
240
241 if (likely(!(shift & 0x20))) {
242 if (likely((uint32_t)shift != 0)) {
243 shift &= 0x1f;
244 ret = (int32_t)value >> shift;
245 if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
246 env->ca32 = env->ca = 0;
247 } else {
248 env->ca32 = env->ca = 1;
249 }
250 } else {
251 ret = (int32_t)value;
252 env->ca32 = env->ca = 0;
253 }
254 } else {
255 ret = (int32_t)value >> 31;
256 env->ca32 = env->ca = (ret != 0);
257 }
258 return (target_long)ret;
259 }
260
261 #if defined(TARGET_PPC64)
262 target_ulong helper_srad(CPUPPCState *env, target_ulong value,
263 target_ulong shift)
264 {
265 int64_t ret;
266
267 if (likely(!(shift & 0x40))) {
268 if (likely((uint64_t)shift != 0)) {
269 shift &= 0x3f;
270 ret = (int64_t)value >> shift;
271 if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) {
272 env->ca32 = env->ca = 0;
273 } else {
274 env->ca32 = env->ca = 1;
275 }
276 } else {
277 ret = (int64_t)value;
278 env->ca32 = env->ca = 0;
279 }
280 } else {
281 ret = (int64_t)value >> 63;
282 env->ca32 = env->ca = (ret != 0);
283 }
284 return ret;
285 }
286 #endif
287
288 #if defined(TARGET_PPC64)
289 target_ulong helper_popcntb(target_ulong val)
290 {
291 /* Note that we don't fold past bytes */
292 val = (val & 0x5555555555555555ULL) + ((val >> 1) &
293 0x5555555555555555ULL);
294 val = (val & 0x3333333333333333ULL) + ((val >> 2) &
295 0x3333333333333333ULL);
296 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) &
297 0x0f0f0f0f0f0f0f0fULL);
298 return val;
299 }
300
301 target_ulong helper_popcntw(target_ulong val)
302 {
303 /* Note that we don't fold past words. */
304 val = (val & 0x5555555555555555ULL) + ((val >> 1) &
305 0x5555555555555555ULL);
306 val = (val & 0x3333333333333333ULL) + ((val >> 2) &
307 0x3333333333333333ULL);
308 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) &
309 0x0f0f0f0f0f0f0f0fULL);
310 val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) &
311 0x00ff00ff00ff00ffULL);
312 val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) &
313 0x0000ffff0000ffffULL);
314 return val;
315 }
316 #else
317 target_ulong helper_popcntb(target_ulong val)
318 {
319 /* Note that we don't fold past bytes */
320 val = (val & 0x55555555) + ((val >> 1) & 0x55555555);
321 val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
322 val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f);
323 return val;
324 }
325 #endif
326
327 uint64_t helper_CFUGED(uint64_t src, uint64_t mask)
328 {
329 /*
330 * Instead of processing the mask bit-by-bit from the most significant to
331 * the least significant bit, as described in PowerISA, we'll handle it in
332 * blocks of 'n' zeros/ones from LSB to MSB. To avoid the decision to use
333 * ctz or cto, we negate the mask at the end of the loop.
334 */
335 target_ulong m, left = 0, right = 0;
336 unsigned int n, i = 64;
337 bool bit = false; /* tracks if we are processing zeros or ones */
338
339 if (mask == 0 || mask == -1) {
340 return src;
341 }
342
343 /* Processes the mask in blocks, from LSB to MSB */
344 while (i) {
345 /* Find how many bits we should take */
346 n = ctz64(mask);
347 if (n > i) {
348 n = i;
349 }
350
351 /*
352 * Extracts 'n' trailing bits of src and put them on the leading 'n'
353 * bits of 'right' or 'left', pushing down the previously extracted
354 * values.
355 */
356 m = (1ll << n) - 1;
357 if (bit) {
358 right = ror64(right | (src & m), n);
359 } else {
360 left = ror64(left | (src & m), n);
361 }
362
363 /*
364 * Discards the processed bits from 'src' and 'mask'. Note that we are
365 * removing 'n' trailing zeros from 'mask', but the logical shift will
366 * add 'n' leading zeros back, so the population count of 'mask' is kept
367 * the same.
368 */
369 src >>= n;
370 mask >>= n;
371 i -= n;
372 bit = !bit;
373 mask = ~mask;
374 }
375
376 /*
377 * At the end, right was ror'ed ctpop(mask) times. To put it back in place,
378 * we'll shift it more 64-ctpop(mask) times.
379 */
380 if (bit) {
381 n = ctpop64(mask);
382 } else {
383 n = 64 - ctpop64(mask);
384 }
385
386 return left | (right >> n);
387 }
388
389 uint64_t helper_PDEPD(uint64_t src, uint64_t mask)
390 {
391 int i, o;
392 uint64_t result = 0;
393
394 if (mask == -1) {
395 return src;
396 }
397
398 for (i = 0; mask != 0; i++) {
399 o = ctz64(mask);
400 mask &= mask - 1;
401 result |= ((src >> i) & 1) << o;
402 }
403
404 return result;
405 }
406
407 uint64_t helper_PEXTD(uint64_t src, uint64_t mask)
408 {
409 int i, o;
410 uint64_t result = 0;
411
412 if (mask == -1) {
413 return src;
414 }
415
416 for (o = 0; mask != 0; o++) {
417 i = ctz64(mask);
418 mask &= mask - 1;
419 result |= ((src >> i) & 1) << o;
420 }
421
422 return result;
423 }
424
425 /*****************************************************************************/
426 /* Altivec extension helpers */
427 #if defined(HOST_WORDS_BIGENDIAN)
428 #define VECTOR_FOR_INORDER_I(index, element) \
429 for (index = 0; index < ARRAY_SIZE(r->element); index++)
430 #else
431 #define VECTOR_FOR_INORDER_I(index, element) \
432 for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--)
433 #endif
434
435 /* Saturating arithmetic helpers. */
436 #define SATCVT(from, to, from_type, to_type, min, max) \
437 static inline to_type cvt##from##to(from_type x, int *sat) \
438 { \
439 to_type r; \
440 \
441 if (x < (from_type)min) { \
442 r = min; \
443 *sat = 1; \
444 } else if (x > (from_type)max) { \
445 r = max; \
446 *sat = 1; \
447 } else { \
448 r = x; \
449 } \
450 return r; \
451 }
452 #define SATCVTU(from, to, from_type, to_type, min, max) \
453 static inline to_type cvt##from##to(from_type x, int *sat) \
454 { \
455 to_type r; \
456 \
457 if (x > (from_type)max) { \
458 r = max; \
459 *sat = 1; \
460 } else { \
461 r = x; \
462 } \
463 return r; \
464 }
465 SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX)
466 SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX)
467 SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX)
468
469 SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX)
470 SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX)
471 SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX)
472 SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX)
473 SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX)
474 SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX)
475 #undef SATCVT
476 #undef SATCVTU
477
478 void helper_mtvscr(CPUPPCState *env, uint32_t vscr)
479 {
480 ppc_store_vscr(env, vscr);
481 }
482
483 uint32_t helper_mfvscr(CPUPPCState *env)
484 {
485 return ppc_get_vscr(env);
486 }
487
488 static inline void set_vscr_sat(CPUPPCState *env)
489 {
490 /* The choice of non-zero value is arbitrary. */
491 env->vscr_sat.u32[0] = 1;
492 }
493
494 void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
495 {
496 int i;
497
498 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
499 r->u32[i] = ~a->u32[i] < b->u32[i];
500 }
501 }
502
503 /* vprtybw */
504 void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b)
505 {
506 int i;
507 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
508 uint64_t res = b->u32[i] ^ (b->u32[i] >> 16);
509 res ^= res >> 8;
510 r->u32[i] = res & 1;
511 }
512 }
513
514 /* vprtybd */
515 void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b)
516 {
517 int i;
518 for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
519 uint64_t res = b->u64[i] ^ (b->u64[i] >> 32);
520 res ^= res >> 16;
521 res ^= res >> 8;
522 r->u64[i] = res & 1;
523 }
524 }
525
526 /* vprtybq */
527 void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b)
528 {
529 uint64_t res = b->u64[0] ^ b->u64[1];
530 res ^= res >> 32;
531 res ^= res >> 16;
532 res ^= res >> 8;
533 r->VsrD(1) = res & 1;
534 r->VsrD(0) = 0;
535 }
536
537 #define VARITHFP(suffix, func) \
538 void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
539 ppc_avr_t *b) \
540 { \
541 int i; \
542 \
543 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
544 r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \
545 } \
546 }
547 VARITHFP(addfp, float32_add)
548 VARITHFP(subfp, float32_sub)
549 VARITHFP(minfp, float32_min)
550 VARITHFP(maxfp, float32_max)
551 #undef VARITHFP
552
553 #define VARITHFPFMA(suffix, type) \
554 void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
555 ppc_avr_t *b, ppc_avr_t *c) \
556 { \
557 int i; \
558 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
559 r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \
560 type, &env->vec_status); \
561 } \
562 }
563 VARITHFPFMA(maddfp, 0);
564 VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c);
565 #undef VARITHFPFMA
566
567 #define VARITHSAT_CASE(type, op, cvt, element) \
568 { \
569 type result = (type)a->element[i] op (type)b->element[i]; \
570 r->element[i] = cvt(result, &sat); \
571 }
572
573 #define VARITHSAT_DO(name, op, optype, cvt, element) \
574 void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat, \
575 ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \
576 { \
577 int sat = 0; \
578 int i; \
579 \
580 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
581 VARITHSAT_CASE(optype, op, cvt, element); \
582 } \
583 if (sat) { \
584 vscr_sat->u32[0] = 1; \
585 } \
586 }
587 #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \
588 VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \
589 VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element)
590 #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \
591 VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \
592 VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element)
593 VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb)
594 VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh)
595 VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw)
596 VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub)
597 VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh)
598 VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw)
599 #undef VARITHSAT_CASE
600 #undef VARITHSAT_DO
601 #undef VARITHSAT_SIGNED
602 #undef VARITHSAT_UNSIGNED
603
604 #define VAVG_DO(name, element, etype) \
605 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
606 { \
607 int i; \
608 \
609 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
610 etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \
611 r->element[i] = x >> 1; \
612 } \
613 }
614
615 #define VAVG(type, signed_element, signed_type, unsigned_element, \
616 unsigned_type) \
617 VAVG_DO(avgs##type, signed_element, signed_type) \
618 VAVG_DO(avgu##type, unsigned_element, unsigned_type)
619 VAVG(b, s8, int16_t, u8, uint16_t)
620 VAVG(h, s16, int32_t, u16, uint32_t)
621 VAVG(w, s32, int64_t, u32, uint64_t)
622 #undef VAVG_DO
623 #undef VAVG
624
625 #define VABSDU_DO(name, element) \
626 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
627 { \
628 int i; \
629 \
630 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
631 r->element[i] = (a->element[i] > b->element[i]) ? \
632 (a->element[i] - b->element[i]) : \
633 (b->element[i] - a->element[i]); \
634 } \
635 }
636
637 /*
638 * VABSDU - Vector absolute difference unsigned
639 * name - instruction mnemonic suffix (b: byte, h: halfword, w: word)
640 * element - element type to access from vector
641 */
642 #define VABSDU(type, element) \
643 VABSDU_DO(absdu##type, element)
644 VABSDU(b, u8)
645 VABSDU(h, u16)
646 VABSDU(w, u32)
647 #undef VABSDU_DO
648 #undef VABSDU
649
650 #define VCF(suffix, cvt, element) \
651 void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \
652 ppc_avr_t *b, uint32_t uim) \
653 { \
654 int i; \
655 \
656 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
657 float32 t = cvt(b->element[i], &env->vec_status); \
658 r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \
659 } \
660 }
661 VCF(ux, uint32_to_float32, u32)
662 VCF(sx, int32_to_float32, s32)
663 #undef VCF
664
665 #define VCMPNEZ(NAME, ELEM) \
666 void helper_##NAME(ppc_vsr_t *t, ppc_vsr_t *a, ppc_vsr_t *b, uint32_t desc) \
667 { \
668 for (int i = 0; i < ARRAY_SIZE(t->ELEM); i++) { \
669 t->ELEM[i] = ((a->ELEM[i] == 0) || (b->ELEM[i] == 0) || \
670 (a->ELEM[i] != b->ELEM[i])) ? -1 : 0; \
671 } \
672 }
673 VCMPNEZ(VCMPNEZB, u8)
674 VCMPNEZ(VCMPNEZH, u16)
675 VCMPNEZ(VCMPNEZW, u32)
676 #undef VCMPNEZ
677
678 #define VCMPFP_DO(suffix, compare, order, record) \
679 void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \
680 ppc_avr_t *a, ppc_avr_t *b) \
681 { \
682 uint32_t ones = (uint32_t)-1; \
683 uint32_t all = ones; \
684 uint32_t none = 0; \
685 int i; \
686 \
687 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
688 uint32_t result; \
689 FloatRelation rel = \
690 float32_compare_quiet(a->f32[i], b->f32[i], \
691 &env->vec_status); \
692 if (rel == float_relation_unordered) { \
693 result = 0; \
694 } else if (rel compare order) { \
695 result = ones; \
696 } else { \
697 result = 0; \
698 } \
699 r->u32[i] = result; \
700 all &= result; \
701 none |= result; \
702 } \
703 if (record) { \
704 env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \
705 } \
706 }
707 #define VCMPFP(suffix, compare, order) \
708 VCMPFP_DO(suffix, compare, order, 0) \
709 VCMPFP_DO(suffix##_dot, compare, order, 1)
710 VCMPFP(eqfp, ==, float_relation_equal)
711 VCMPFP(gefp, !=, float_relation_less)
712 VCMPFP(gtfp, ==, float_relation_greater)
713 #undef VCMPFP_DO
714 #undef VCMPFP
715
716 static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r,
717 ppc_avr_t *a, ppc_avr_t *b, int record)
718 {
719 int i;
720 int all_in = 0;
721
722 for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
723 FloatRelation le_rel = float32_compare_quiet(a->f32[i], b->f32[i],
724 &env->vec_status);
725 if (le_rel == float_relation_unordered) {
726 r->u32[i] = 0xc0000000;
727 all_in = 1;
728 } else {
729 float32 bneg = float32_chs(b->f32[i]);
730 FloatRelation ge_rel = float32_compare_quiet(a->f32[i], bneg,
731 &env->vec_status);
732 int le = le_rel != float_relation_greater;
733 int ge = ge_rel != float_relation_less;
734
735 r->u32[i] = ((!le) << 31) | ((!ge) << 30);
736 all_in |= (!le | !ge);
737 }
738 }
739 if (record) {
740 env->crf[6] = (all_in == 0) << 1;
741 }
742 }
743
744 void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
745 {
746 vcmpbfp_internal(env, r, a, b, 0);
747 }
748
749 void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
750 ppc_avr_t *b)
751 {
752 vcmpbfp_internal(env, r, a, b, 1);
753 }
754
755 #define VCT(suffix, satcvt, element) \
756 void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \
757 ppc_avr_t *b, uint32_t uim) \
758 { \
759 int i; \
760 int sat = 0; \
761 float_status s = env->vec_status; \
762 \
763 set_float_rounding_mode(float_round_to_zero, &s); \
764 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
765 if (float32_is_any_nan(b->f32[i])) { \
766 r->element[i] = 0; \
767 } else { \
768 float64 t = float32_to_float64(b->f32[i], &s); \
769 int64_t j; \
770 \
771 t = float64_scalbn(t, uim, &s); \
772 j = float64_to_int64(t, &s); \
773 r->element[i] = satcvt(j, &sat); \
774 } \
775 } \
776 if (sat) { \
777 set_vscr_sat(env); \
778 } \
779 }
780 VCT(uxs, cvtsduw, u32)
781 VCT(sxs, cvtsdsw, s32)
782 #undef VCT
783
784 target_ulong helper_vclzlsbb(ppc_avr_t *r)
785 {
786 target_ulong count = 0;
787 int i;
788 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
789 if (r->VsrB(i) & 0x01) {
790 break;
791 }
792 count++;
793 }
794 return count;
795 }
796
797 target_ulong helper_vctzlsbb(ppc_avr_t *r)
798 {
799 target_ulong count = 0;
800 int i;
801 for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
802 if (r->VsrB(i) & 0x01) {
803 break;
804 }
805 count++;
806 }
807 return count;
808 }
809
810 void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
811 ppc_avr_t *b, ppc_avr_t *c)
812 {
813 int sat = 0;
814 int i;
815
816 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
817 int32_t prod = a->s16[i] * b->s16[i];
818 int32_t t = (int32_t)c->s16[i] + (prod >> 15);
819
820 r->s16[i] = cvtswsh(t, &sat);
821 }
822
823 if (sat) {
824 set_vscr_sat(env);
825 }
826 }
827
828 void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
829 ppc_avr_t *b, ppc_avr_t *c)
830 {
831 int sat = 0;
832 int i;
833
834 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
835 int32_t prod = a->s16[i] * b->s16[i] + 0x00004000;
836 int32_t t = (int32_t)c->s16[i] + (prod >> 15);
837 r->s16[i] = cvtswsh(t, &sat);
838 }
839
840 if (sat) {
841 set_vscr_sat(env);
842 }
843 }
844
845 void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
846 {
847 int i;
848
849 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
850 int32_t prod = a->s16[i] * b->s16[i];
851 r->s16[i] = (int16_t) (prod + c->s16[i]);
852 }
853 }
854
855 #define VMRG_DO(name, element, access, ofs) \
856 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
857 { \
858 ppc_avr_t result; \
859 int i, half = ARRAY_SIZE(r->element) / 2; \
860 \
861 for (i = 0; i < half; i++) { \
862 result.access(i * 2 + 0) = a->access(i + ofs); \
863 result.access(i * 2 + 1) = b->access(i + ofs); \
864 } \
865 *r = result; \
866 }
867
868 #define VMRG(suffix, element, access) \
869 VMRG_DO(mrgl##suffix, element, access, half) \
870 VMRG_DO(mrgh##suffix, element, access, 0)
871 VMRG(b, u8, VsrB)
872 VMRG(h, u16, VsrH)
873 VMRG(w, u32, VsrW)
874 #undef VMRG_DO
875 #undef VMRG
876
877 void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
878 ppc_avr_t *b, ppc_avr_t *c)
879 {
880 int32_t prod[16];
881 int i;
882
883 for (i = 0; i < ARRAY_SIZE(r->s8); i++) {
884 prod[i] = (int32_t)a->s8[i] * b->u8[i];
885 }
886
887 VECTOR_FOR_INORDER_I(i, s32) {
888 r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] +
889 prod[4 * i + 2] + prod[4 * i + 3];
890 }
891 }
892
893 void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
894 ppc_avr_t *b, ppc_avr_t *c)
895 {
896 int32_t prod[8];
897 int i;
898
899 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
900 prod[i] = a->s16[i] * b->s16[i];
901 }
902
903 VECTOR_FOR_INORDER_I(i, s32) {
904 r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1];
905 }
906 }
907
908 void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
909 ppc_avr_t *b, ppc_avr_t *c)
910 {
911 int32_t prod[8];
912 int i;
913 int sat = 0;
914
915 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
916 prod[i] = (int32_t)a->s16[i] * b->s16[i];
917 }
918
919 VECTOR_FOR_INORDER_I(i, s32) {
920 int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1];
921
922 r->u32[i] = cvtsdsw(t, &sat);
923 }
924
925 if (sat) {
926 set_vscr_sat(env);
927 }
928 }
929
930 void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
931 ppc_avr_t *b, ppc_avr_t *c)
932 {
933 uint16_t prod[16];
934 int i;
935
936 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
937 prod[i] = a->u8[i] * b->u8[i];
938 }
939
940 VECTOR_FOR_INORDER_I(i, u32) {
941 r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] +
942 prod[4 * i + 2] + prod[4 * i + 3];
943 }
944 }
945
946 void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
947 ppc_avr_t *b, ppc_avr_t *c)
948 {
949 uint32_t prod[8];
950 int i;
951
952 for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
953 prod[i] = a->u16[i] * b->u16[i];
954 }
955
956 VECTOR_FOR_INORDER_I(i, u32) {
957 r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1];
958 }
959 }
960
961 void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
962 ppc_avr_t *b, ppc_avr_t *c)
963 {
964 uint32_t prod[8];
965 int i;
966 int sat = 0;
967
968 for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
969 prod[i] = a->u16[i] * b->u16[i];
970 }
971
972 VECTOR_FOR_INORDER_I(i, s32) {
973 uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1];
974
975 r->u32[i] = cvtuduw(t, &sat);
976 }
977
978 if (sat) {
979 set_vscr_sat(env);
980 }
981 }
982
983 #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast) \
984 void helper_V##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
985 { \
986 int i; \
987 \
988 for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \
989 r->prod_access(i >> 1) = (cast)a->mul_access(i) * \
990 (cast)b->mul_access(i); \
991 } \
992 }
993
994 #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast) \
995 void helper_V##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
996 { \
997 int i; \
998 \
999 for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \
1000 r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) * \
1001 (cast)b->mul_access(i + 1); \
1002 } \
1003 }
1004
1005 #define VMUL(suffix, mul_element, mul_access, prod_access, cast) \
1006 VMUL_DO_EVN(MULE##suffix, mul_element, mul_access, prod_access, cast) \
1007 VMUL_DO_ODD(MULO##suffix, mul_element, mul_access, prod_access, cast)
1008 VMUL(SB, s8, VsrSB, VsrSH, int16_t)
1009 VMUL(SH, s16, VsrSH, VsrSW, int32_t)
1010 VMUL(SW, s32, VsrSW, VsrSD, int64_t)
1011 VMUL(UB, u8, VsrB, VsrH, uint16_t)
1012 VMUL(UH, u16, VsrH, VsrW, uint32_t)
1013 VMUL(UW, u32, VsrW, VsrD, uint64_t)
1014 #undef VMUL_DO_EVN
1015 #undef VMUL_DO_ODD
1016 #undef VMUL
1017
1018 void helper_VPERM(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1019 {
1020 ppc_avr_t result;
1021 int i;
1022
1023 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1024 int s = c->VsrB(i) & 0x1f;
1025 int index = s & 0xf;
1026
1027 if (s & 0x10) {
1028 result.VsrB(i) = b->VsrB(index);
1029 } else {
1030 result.VsrB(i) = a->VsrB(index);
1031 }
1032 }
1033 *r = result;
1034 }
1035
1036 void helper_VPERMR(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1037 {
1038 ppc_avr_t result;
1039 int i;
1040
1041 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1042 int s = c->VsrB(i) & 0x1f;
1043 int index = 15 - (s & 0xf);
1044
1045 if (s & 0x10) {
1046 result.VsrB(i) = a->VsrB(index);
1047 } else {
1048 result.VsrB(i) = b->VsrB(index);
1049 }
1050 }
1051 *r = result;
1052 }
1053
1054 #if defined(HOST_WORDS_BIGENDIAN)
1055 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)])
1056 #define VBPERMD_INDEX(i) (i)
1057 #define VBPERMQ_DW(index) (((index) & 0x40) != 0)
1058 #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1))
1059 #else
1060 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)])
1061 #define VBPERMD_INDEX(i) (1 - i)
1062 #define VBPERMQ_DW(index) (((index) & 0x40) == 0)
1063 #define EXTRACT_BIT(avr, i, index) \
1064 (extract64((avr)->u64[1 - i], 63 - index, 1))
1065 #endif
1066
1067 void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1068 {
1069 int i, j;
1070 ppc_avr_t result = { .u64 = { 0, 0 } };
1071 VECTOR_FOR_INORDER_I(i, u64) {
1072 for (j = 0; j < 8; j++) {
1073 int index = VBPERMQ_INDEX(b, (i * 8) + j);
1074 if (index < 64 && EXTRACT_BIT(a, i, index)) {
1075 result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j);
1076 }
1077 }
1078 }
1079 *r = result;
1080 }
1081
1082 void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1083 {
1084 int i;
1085 uint64_t perm = 0;
1086
1087 VECTOR_FOR_INORDER_I(i, u8) {
1088 int index = VBPERMQ_INDEX(b, i);
1089
1090 if (index < 128) {
1091 uint64_t mask = (1ull << (63 - (index & 0x3F)));
1092 if (a->u64[VBPERMQ_DW(index)] & mask) {
1093 perm |= (0x8000 >> i);
1094 }
1095 }
1096 }
1097
1098 r->VsrD(0) = perm;
1099 r->VsrD(1) = 0;
1100 }
1101
1102 #undef VBPERMQ_INDEX
1103 #undef VBPERMQ_DW
1104
1105 #define PMSUM(name, srcfld, trgfld, trgtyp) \
1106 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1107 { \
1108 int i, j; \
1109 trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])]; \
1110 \
1111 VECTOR_FOR_INORDER_I(i, srcfld) { \
1112 prod[i] = 0; \
1113 for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \
1114 if (a->srcfld[i] & (1ull << j)) { \
1115 prod[i] ^= ((trgtyp)b->srcfld[i] << j); \
1116 } \
1117 } \
1118 } \
1119 \
1120 VECTOR_FOR_INORDER_I(i, trgfld) { \
1121 r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1]; \
1122 } \
1123 }
1124
1125 PMSUM(vpmsumb, u8, u16, uint16_t)
1126 PMSUM(vpmsumh, u16, u32, uint32_t)
1127 PMSUM(vpmsumw, u32, u64, uint64_t)
1128
1129 void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1130 {
1131
1132 #ifdef CONFIG_INT128
1133 int i, j;
1134 __uint128_t prod[2];
1135
1136 VECTOR_FOR_INORDER_I(i, u64) {
1137 prod[i] = 0;
1138 for (j = 0; j < 64; j++) {
1139 if (a->u64[i] & (1ull << j)) {
1140 prod[i] ^= (((__uint128_t)b->u64[i]) << j);
1141 }
1142 }
1143 }
1144
1145 r->u128 = prod[0] ^ prod[1];
1146
1147 #else
1148 int i, j;
1149 ppc_avr_t prod[2];
1150
1151 VECTOR_FOR_INORDER_I(i, u64) {
1152 prod[i].VsrD(1) = prod[i].VsrD(0) = 0;
1153 for (j = 0; j < 64; j++) {
1154 if (a->u64[i] & (1ull << j)) {
1155 ppc_avr_t bshift;
1156 if (j == 0) {
1157 bshift.VsrD(0) = 0;
1158 bshift.VsrD(1) = b->u64[i];
1159 } else {
1160 bshift.VsrD(0) = b->u64[i] >> (64 - j);
1161 bshift.VsrD(1) = b->u64[i] << j;
1162 }
1163 prod[i].VsrD(1) ^= bshift.VsrD(1);
1164 prod[i].VsrD(0) ^= bshift.VsrD(0);
1165 }
1166 }
1167 }
1168
1169 r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1);
1170 r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0);
1171 #endif
1172 }
1173
1174
1175 #if defined(HOST_WORDS_BIGENDIAN)
1176 #define PKBIG 1
1177 #else
1178 #define PKBIG 0
1179 #endif
1180 void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1181 {
1182 int i, j;
1183 ppc_avr_t result;
1184 #if defined(HOST_WORDS_BIGENDIAN)
1185 const ppc_avr_t *x[2] = { a, b };
1186 #else
1187 const ppc_avr_t *x[2] = { b, a };
1188 #endif
1189
1190 VECTOR_FOR_INORDER_I(i, u64) {
1191 VECTOR_FOR_INORDER_I(j, u32) {
1192 uint32_t e = x[i]->u32[j];
1193
1194 result.u16[4 * i + j] = (((e >> 9) & 0xfc00) |
1195 ((e >> 6) & 0x3e0) |
1196 ((e >> 3) & 0x1f));
1197 }
1198 }
1199 *r = result;
1200 }
1201
1202 #define VPK(suffix, from, to, cvt, dosat) \
1203 void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \
1204 ppc_avr_t *a, ppc_avr_t *b) \
1205 { \
1206 int i; \
1207 int sat = 0; \
1208 ppc_avr_t result; \
1209 ppc_avr_t *a0 = PKBIG ? a : b; \
1210 ppc_avr_t *a1 = PKBIG ? b : a; \
1211 \
1212 VECTOR_FOR_INORDER_I(i, from) { \
1213 result.to[i] = cvt(a0->from[i], &sat); \
1214 result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\
1215 } \
1216 *r = result; \
1217 if (dosat && sat) { \
1218 set_vscr_sat(env); \
1219 } \
1220 }
1221 #define I(x, y) (x)
1222 VPK(shss, s16, s8, cvtshsb, 1)
1223 VPK(shus, s16, u8, cvtshub, 1)
1224 VPK(swss, s32, s16, cvtswsh, 1)
1225 VPK(swus, s32, u16, cvtswuh, 1)
1226 VPK(sdss, s64, s32, cvtsdsw, 1)
1227 VPK(sdus, s64, u32, cvtsduw, 1)
1228 VPK(uhus, u16, u8, cvtuhub, 1)
1229 VPK(uwus, u32, u16, cvtuwuh, 1)
1230 VPK(udus, u64, u32, cvtuduw, 1)
1231 VPK(uhum, u16, u8, I, 0)
1232 VPK(uwum, u32, u16, I, 0)
1233 VPK(udum, u64, u32, I, 0)
1234 #undef I
1235 #undef VPK
1236 #undef PKBIG
1237
1238 void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1239 {
1240 int i;
1241
1242 for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1243 r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status);
1244 }
1245 }
1246
1247 #define VRFI(suffix, rounding) \
1248 void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \
1249 ppc_avr_t *b) \
1250 { \
1251 int i; \
1252 float_status s = env->vec_status; \
1253 \
1254 set_float_rounding_mode(rounding, &s); \
1255 for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \
1256 r->f32[i] = float32_round_to_int (b->f32[i], &s); \
1257 } \
1258 }
1259 VRFI(n, float_round_nearest_even)
1260 VRFI(m, float_round_down)
1261 VRFI(p, float_round_up)
1262 VRFI(z, float_round_to_zero)
1263 #undef VRFI
1264
1265 void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1266 {
1267 int i;
1268
1269 for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1270 float32 t = float32_sqrt(b->f32[i], &env->vec_status);
1271
1272 r->f32[i] = float32_div(float32_one, t, &env->vec_status);
1273 }
1274 }
1275
1276 #define VRLMI(name, size, element, insert) \
1277 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \
1278 { \
1279 int i; \
1280 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1281 uint##size##_t src1 = a->element[i]; \
1282 uint##size##_t src2 = b->element[i]; \
1283 uint##size##_t src3 = r->element[i]; \
1284 uint##size##_t begin, end, shift, mask, rot_val; \
1285 \
1286 shift = extract##size(src2, 0, 6); \
1287 end = extract##size(src2, 8, 6); \
1288 begin = extract##size(src2, 16, 6); \
1289 rot_val = rol##size(src1, shift); \
1290 mask = mask_u##size(begin, end); \
1291 if (insert) { \
1292 r->element[i] = (rot_val & mask) | (src3 & ~mask); \
1293 } else { \
1294 r->element[i] = (rot_val & mask); \
1295 } \
1296 } \
1297 }
1298
1299 VRLMI(VRLDMI, 64, u64, 1);
1300 VRLMI(VRLWMI, 32, u32, 1);
1301 VRLMI(VRLDNM, 64, u64, 0);
1302 VRLMI(VRLWNM, 32, u32, 0);
1303
1304 void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1305 {
1306 int i;
1307
1308 for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1309 r->f32[i] = float32_exp2(b->f32[i], &env->vec_status);
1310 }
1311 }
1312
1313 void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1314 {
1315 int i;
1316
1317 for (i = 0; i < ARRAY_SIZE(r->f32); i++) {
1318 r->f32[i] = float32_log2(b->f32[i], &env->vec_status);
1319 }
1320 }
1321
1322 #define VEXTU_X_DO(name, size, left) \
1323 target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \
1324 { \
1325 int index = (a & 0xf) * 8; \
1326 if (left) { \
1327 index = 128 - index - size; \
1328 } \
1329 return int128_getlo(int128_rshift(b->s128, index)) & \
1330 MAKE_64BIT_MASK(0, size); \
1331 }
1332 VEXTU_X_DO(vextublx, 8, 1)
1333 VEXTU_X_DO(vextuhlx, 16, 1)
1334 VEXTU_X_DO(vextuwlx, 32, 1)
1335 VEXTU_X_DO(vextubrx, 8, 0)
1336 VEXTU_X_DO(vextuhrx, 16, 0)
1337 VEXTU_X_DO(vextuwrx, 32, 0)
1338 #undef VEXTU_X_DO
1339
1340 void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1341 {
1342 int i;
1343 unsigned int shift, bytes, size;
1344
1345 size = ARRAY_SIZE(r->u8);
1346 for (i = 0; i < size; i++) {
1347 shift = b->VsrB(i) & 0x7; /* extract shift value */
1348 bytes = (a->VsrB(i) << 8) + /* extract adjacent bytes */
1349 (((i + 1) < size) ? a->VsrB(i + 1) : 0);
1350 r->VsrB(i) = (bytes << shift) >> 8; /* shift and store result */
1351 }
1352 }
1353
1354 void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1355 {
1356 int i;
1357 unsigned int shift, bytes;
1358
1359 /*
1360 * Use reverse order, as destination and source register can be
1361 * same. Its being modified in place saving temporary, reverse
1362 * order will guarantee that computed result is not fed back.
1363 */
1364 for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
1365 shift = b->VsrB(i) & 0x7; /* extract shift value */
1366 bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i);
1367 /* extract adjacent bytes */
1368 r->VsrB(i) = (bytes >> shift) & 0xFF; /* shift and store result */
1369 }
1370 }
1371
1372 void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
1373 {
1374 int sh = shift & 0xf;
1375 int i;
1376 ppc_avr_t result;
1377
1378 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1379 int index = sh + i;
1380 if (index > 0xf) {
1381 result.VsrB(i) = b->VsrB(index - 0x10);
1382 } else {
1383 result.VsrB(i) = a->VsrB(index);
1384 }
1385 }
1386 *r = result;
1387 }
1388
1389 void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1390 {
1391 int sh = (b->VsrB(0xf) >> 3) & 0xf;
1392
1393 #if defined(HOST_WORDS_BIGENDIAN)
1394 memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1395 memset(&r->u8[16 - sh], 0, sh);
1396 #else
1397 memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1398 memset(&r->u8[0], 0, sh);
1399 #endif
1400 }
1401
1402 #if defined(HOST_WORDS_BIGENDIAN)
1403 #define ELEM_ADDR(VEC, IDX, SIZE) (&(VEC)->u8[IDX])
1404 #else
1405 #define ELEM_ADDR(VEC, IDX, SIZE) (&(VEC)->u8[15 - (IDX)] - (SIZE) + 1)
1406 #endif
1407
1408 #define VINSX(SUFFIX, TYPE) \
1409 void glue(glue(helper_VINS, SUFFIX), LX)(CPUPPCState *env, ppc_avr_t *t, \
1410 uint64_t val, target_ulong index) \
1411 { \
1412 const int maxidx = ARRAY_SIZE(t->u8) - sizeof(TYPE); \
1413 target_long idx = index; \
1414 \
1415 if (idx < 0 || idx > maxidx) { \
1416 idx = idx < 0 ? sizeof(TYPE) - idx : idx; \
1417 qemu_log_mask(LOG_GUEST_ERROR, \
1418 "Invalid index for Vector Insert Element after 0x" TARGET_FMT_lx \
1419 ", RA = " TARGET_FMT_ld " > %d\n", env->nip, idx, maxidx); \
1420 } else { \
1421 TYPE src = val; \
1422 memcpy(ELEM_ADDR(t, idx, sizeof(TYPE)), &src, sizeof(TYPE)); \
1423 } \
1424 }
1425 VINSX(B, uint8_t)
1426 VINSX(H, uint16_t)
1427 VINSX(W, uint32_t)
1428 VINSX(D, uint64_t)
1429 #undef ELEM_ADDR
1430 #undef VINSX
1431 #if defined(HOST_WORDS_BIGENDIAN)
1432 #define VEXTDVLX(NAME, SIZE) \
1433 void helper_##NAME(CPUPPCState *env, ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \
1434 target_ulong index) \
1435 { \
1436 const target_long idx = index; \
1437 ppc_avr_t tmp[2] = { *a, *b }; \
1438 memset(t, 0, sizeof(*t)); \
1439 if (idx >= 0 && idx + SIZE <= sizeof(tmp)) { \
1440 memcpy(&t->u8[ARRAY_SIZE(t->u8) / 2 - SIZE], (void *)tmp + idx, SIZE); \
1441 } else { \
1442 qemu_log_mask(LOG_GUEST_ERROR, "Invalid index for " #NAME " after 0x" \
1443 TARGET_FMT_lx ", RC = " TARGET_FMT_ld " > %d\n", \
1444 env->nip, idx < 0 ? SIZE - idx : idx, 32 - SIZE); \
1445 } \
1446 }
1447 #else
1448 #define VEXTDVLX(NAME, SIZE) \
1449 void helper_##NAME(CPUPPCState *env, ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \
1450 target_ulong index) \
1451 { \
1452 const target_long idx = index; \
1453 ppc_avr_t tmp[2] = { *b, *a }; \
1454 memset(t, 0, sizeof(*t)); \
1455 if (idx >= 0 && idx + SIZE <= sizeof(tmp)) { \
1456 memcpy(&t->u8[ARRAY_SIZE(t->u8) / 2], \
1457 (void *)tmp + sizeof(tmp) - SIZE - idx, SIZE); \
1458 } else { \
1459 qemu_log_mask(LOG_GUEST_ERROR, "Invalid index for " #NAME " after 0x" \
1460 TARGET_FMT_lx ", RC = " TARGET_FMT_ld " > %d\n", \
1461 env->nip, idx < 0 ? SIZE - idx : idx, 32 - SIZE); \
1462 } \
1463 }
1464 #endif
1465 VEXTDVLX(VEXTDUBVLX, 1)
1466 VEXTDVLX(VEXTDUHVLX, 2)
1467 VEXTDVLX(VEXTDUWVLX, 4)
1468 VEXTDVLX(VEXTDDVLX, 8)
1469 #undef VEXTDVLX
1470 #if defined(HOST_WORDS_BIGENDIAN)
1471 #define VEXTRACT(suffix, element) \
1472 void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1473 { \
1474 uint32_t es = sizeof(r->element[0]); \
1475 memmove(&r->u8[8 - es], &b->u8[index], es); \
1476 memset(&r->u8[8], 0, 8); \
1477 memset(&r->u8[0], 0, 8 - es); \
1478 }
1479 #else
1480 #define VEXTRACT(suffix, element) \
1481 void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1482 { \
1483 uint32_t es = sizeof(r->element[0]); \
1484 uint32_t s = (16 - index) - es; \
1485 memmove(&r->u8[8], &b->u8[s], es); \
1486 memset(&r->u8[0], 0, 8); \
1487 memset(&r->u8[8 + es], 0, 8 - es); \
1488 }
1489 #endif
1490 VEXTRACT(ub, u8)
1491 VEXTRACT(uh, u16)
1492 VEXTRACT(uw, u32)
1493 VEXTRACT(d, u64)
1494 #undef VEXTRACT
1495
1496 #define VSTRI(NAME, ELEM, NUM_ELEMS, LEFT) \
1497 uint32_t helper_##NAME(ppc_avr_t *t, ppc_avr_t *b) \
1498 { \
1499 int i, idx, crf = 0; \
1500 \
1501 for (i = 0; i < NUM_ELEMS; i++) { \
1502 idx = LEFT ? i : NUM_ELEMS - i - 1; \
1503 if (b->Vsr##ELEM(idx)) { \
1504 t->Vsr##ELEM(idx) = b->Vsr##ELEM(idx); \
1505 } else { \
1506 crf = 0b0010; \
1507 break; \
1508 } \
1509 } \
1510 \
1511 for (; i < NUM_ELEMS; i++) { \
1512 idx = LEFT ? i : NUM_ELEMS - i - 1; \
1513 t->Vsr##ELEM(idx) = 0; \
1514 } \
1515 \
1516 return crf; \
1517 }
1518 VSTRI(VSTRIBL, B, 16, true)
1519 VSTRI(VSTRIBR, B, 16, false)
1520 VSTRI(VSTRIHL, H, 8, true)
1521 VSTRI(VSTRIHR, H, 8, false)
1522 #undef VSTRI
1523
1524 void helper_xxextractuw(CPUPPCState *env, ppc_vsr_t *xt,
1525 ppc_vsr_t *xb, uint32_t index)
1526 {
1527 ppc_vsr_t t = { };
1528 size_t es = sizeof(uint32_t);
1529 uint32_t ext_index;
1530 int i;
1531
1532 ext_index = index;
1533 for (i = 0; i < es; i++, ext_index++) {
1534 t.VsrB(8 - es + i) = xb->VsrB(ext_index % 16);
1535 }
1536
1537 *xt = t;
1538 }
1539
1540 void helper_xxinsertw(CPUPPCState *env, ppc_vsr_t *xt,
1541 ppc_vsr_t *xb, uint32_t index)
1542 {
1543 ppc_vsr_t t = *xt;
1544 size_t es = sizeof(uint32_t);
1545 int ins_index, i = 0;
1546
1547 ins_index = index;
1548 for (i = 0; i < es && ins_index < 16; i++, ins_index++) {
1549 t.VsrB(ins_index) = xb->VsrB(8 - es + i);
1550 }
1551
1552 *xt = t;
1553 }
1554
1555 #define XXBLEND(name, sz) \
1556 void glue(helper_XXBLENDV, name)(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \
1557 ppc_avr_t *c, uint32_t desc) \
1558 { \
1559 for (int i = 0; i < ARRAY_SIZE(t->glue(u, sz)); i++) { \
1560 t->glue(u, sz)[i] = (c->glue(s, sz)[i] >> (sz - 1)) ? \
1561 b->glue(u, sz)[i] : a->glue(u, sz)[i]; \
1562 } \
1563 }
1564 XXBLEND(B, 8)
1565 XXBLEND(H, 16)
1566 XXBLEND(W, 32)
1567 XXBLEND(D, 64)
1568 #undef XXBLEND
1569
1570 #define VNEG(name, element) \
1571 void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \
1572 { \
1573 int i; \
1574 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1575 r->element[i] = -b->element[i]; \
1576 } \
1577 }
1578 VNEG(vnegw, s32)
1579 VNEG(vnegd, s64)
1580 #undef VNEG
1581
1582 void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1583 {
1584 int sh = (b->VsrB(0xf) >> 3) & 0xf;
1585
1586 #if defined(HOST_WORDS_BIGENDIAN)
1587 memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1588 memset(&r->u8[0], 0, sh);
1589 #else
1590 memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1591 memset(&r->u8[16 - sh], 0, sh);
1592 #endif
1593 }
1594
1595 void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1596 {
1597 int i;
1598
1599 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1600 r->u32[i] = a->u32[i] >= b->u32[i];
1601 }
1602 }
1603
1604 void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1605 {
1606 int64_t t;
1607 int i, upper;
1608 ppc_avr_t result;
1609 int sat = 0;
1610
1611 upper = ARRAY_SIZE(r->s32) - 1;
1612 t = (int64_t)b->VsrSW(upper);
1613 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1614 t += a->VsrSW(i);
1615 result.VsrSW(i) = 0;
1616 }
1617 result.VsrSW(upper) = cvtsdsw(t, &sat);
1618 *r = result;
1619
1620 if (sat) {
1621 set_vscr_sat(env);
1622 }
1623 }
1624
1625 void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1626 {
1627 int i, j, upper;
1628 ppc_avr_t result;
1629 int sat = 0;
1630
1631 upper = 1;
1632 for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
1633 int64_t t = (int64_t)b->VsrSW(upper + i * 2);
1634
1635 result.VsrD(i) = 0;
1636 for (j = 0; j < ARRAY_SIZE(r->u64); j++) {
1637 t += a->VsrSW(2 * i + j);
1638 }
1639 result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat);
1640 }
1641
1642 *r = result;
1643 if (sat) {
1644 set_vscr_sat(env);
1645 }
1646 }
1647
1648 void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1649 {
1650 int i, j;
1651 int sat = 0;
1652
1653 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1654 int64_t t = (int64_t)b->s32[i];
1655
1656 for (j = 0; j < ARRAY_SIZE(r->s32); j++) {
1657 t += a->s8[4 * i + j];
1658 }
1659 r->s32[i] = cvtsdsw(t, &sat);
1660 }
1661
1662 if (sat) {
1663 set_vscr_sat(env);
1664 }
1665 }
1666
1667 void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1668 {
1669 int sat = 0;
1670 int i;
1671
1672 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1673 int64_t t = (int64_t)b->s32[i];
1674
1675 t += a->s16[2 * i] + a->s16[2 * i + 1];
1676 r->s32[i] = cvtsdsw(t, &sat);
1677 }
1678
1679 if (sat) {
1680 set_vscr_sat(env);
1681 }
1682 }
1683
1684 void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1685 {
1686 int i, j;
1687 int sat = 0;
1688
1689 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1690 uint64_t t = (uint64_t)b->u32[i];
1691
1692 for (j = 0; j < ARRAY_SIZE(r->u32); j++) {
1693 t += a->u8[4 * i + j];
1694 }
1695 r->u32[i] = cvtuduw(t, &sat);
1696 }
1697
1698 if (sat) {
1699 set_vscr_sat(env);
1700 }
1701 }
1702
1703 #if defined(HOST_WORDS_BIGENDIAN)
1704 #define UPKHI 1
1705 #define UPKLO 0
1706 #else
1707 #define UPKHI 0
1708 #define UPKLO 1
1709 #endif
1710 #define VUPKPX(suffix, hi) \
1711 void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \
1712 { \
1713 int i; \
1714 ppc_avr_t result; \
1715 \
1716 for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \
1717 uint16_t e = b->u16[hi ? i : i + 4]; \
1718 uint8_t a = (e >> 15) ? 0xff : 0; \
1719 uint8_t r = (e >> 10) & 0x1f; \
1720 uint8_t g = (e >> 5) & 0x1f; \
1721 uint8_t b = e & 0x1f; \
1722 \
1723 result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \
1724 } \
1725 *r = result; \
1726 }
1727 VUPKPX(lpx, UPKLO)
1728 VUPKPX(hpx, UPKHI)
1729 #undef VUPKPX
1730
1731 #define VUPK(suffix, unpacked, packee, hi) \
1732 void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \
1733 { \
1734 int i; \
1735 ppc_avr_t result; \
1736 \
1737 if (hi) { \
1738 for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \
1739 result.unpacked[i] = b->packee[i]; \
1740 } \
1741 } else { \
1742 for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \
1743 i++) { \
1744 result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \
1745 } \
1746 } \
1747 *r = result; \
1748 }
1749 VUPK(hsb, s16, s8, UPKHI)
1750 VUPK(hsh, s32, s16, UPKHI)
1751 VUPK(hsw, s64, s32, UPKHI)
1752 VUPK(lsb, s16, s8, UPKLO)
1753 VUPK(lsh, s32, s16, UPKLO)
1754 VUPK(lsw, s64, s32, UPKLO)
1755 #undef VUPK
1756 #undef UPKHI
1757 #undef UPKLO
1758
1759 #define VGENERIC_DO(name, element) \
1760 void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \
1761 { \
1762 int i; \
1763 \
1764 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1765 r->element[i] = name(b->element[i]); \
1766 } \
1767 }
1768
1769 #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8)
1770 #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16)
1771
1772 VGENERIC_DO(clzb, u8)
1773 VGENERIC_DO(clzh, u16)
1774
1775 #undef clzb
1776 #undef clzh
1777
1778 #define ctzb(v) ((v) ? ctz32(v) : 8)
1779 #define ctzh(v) ((v) ? ctz32(v) : 16)
1780 #define ctzw(v) ctz32((v))
1781 #define ctzd(v) ctz64((v))
1782
1783 VGENERIC_DO(ctzb, u8)
1784 VGENERIC_DO(ctzh, u16)
1785 VGENERIC_DO(ctzw, u32)
1786 VGENERIC_DO(ctzd, u64)
1787
1788 #undef ctzb
1789 #undef ctzh
1790 #undef ctzw
1791 #undef ctzd
1792
1793 #define popcntb(v) ctpop8(v)
1794 #define popcnth(v) ctpop16(v)
1795 #define popcntw(v) ctpop32(v)
1796 #define popcntd(v) ctpop64(v)
1797
1798 VGENERIC_DO(popcntb, u8)
1799 VGENERIC_DO(popcnth, u16)
1800 VGENERIC_DO(popcntw, u32)
1801 VGENERIC_DO(popcntd, u64)
1802
1803 #undef popcntb
1804 #undef popcnth
1805 #undef popcntw
1806 #undef popcntd
1807
1808 #undef VGENERIC_DO
1809
1810 #if defined(HOST_WORDS_BIGENDIAN)
1811 #define QW_ONE { .u64 = { 0, 1 } }
1812 #else
1813 #define QW_ONE { .u64 = { 1, 0 } }
1814 #endif
1815
1816 #ifndef CONFIG_INT128
1817
1818 static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a)
1819 {
1820 t->u64[0] = ~a.u64[0];
1821 t->u64[1] = ~a.u64[1];
1822 }
1823
1824 static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b)
1825 {
1826 if (a.VsrD(0) < b.VsrD(0)) {
1827 return -1;
1828 } else if (a.VsrD(0) > b.VsrD(0)) {
1829 return 1;
1830 } else if (a.VsrD(1) < b.VsrD(1)) {
1831 return -1;
1832 } else if (a.VsrD(1) > b.VsrD(1)) {
1833 return 1;
1834 } else {
1835 return 0;
1836 }
1837 }
1838
1839 static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
1840 {
1841 t->VsrD(1) = a.VsrD(1) + b.VsrD(1);
1842 t->VsrD(0) = a.VsrD(0) + b.VsrD(0) +
1843 (~a.VsrD(1) < b.VsrD(1));
1844 }
1845
1846 static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
1847 {
1848 ppc_avr_t not_a;
1849 t->VsrD(1) = a.VsrD(1) + b.VsrD(1);
1850 t->VsrD(0) = a.VsrD(0) + b.VsrD(0) +
1851 (~a.VsrD(1) < b.VsrD(1));
1852 avr_qw_not(&not_a, a);
1853 return avr_qw_cmpu(not_a, b) < 0;
1854 }
1855
1856 #endif
1857
1858 void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1859 {
1860 #ifdef CONFIG_INT128
1861 r->u128 = a->u128 + b->u128;
1862 #else
1863 avr_qw_add(r, *a, *b);
1864 #endif
1865 }
1866
1867 void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1868 {
1869 #ifdef CONFIG_INT128
1870 r->u128 = a->u128 + b->u128 + (c->u128 & 1);
1871 #else
1872
1873 if (c->VsrD(1) & 1) {
1874 ppc_avr_t tmp;
1875
1876 tmp.VsrD(0) = 0;
1877 tmp.VsrD(1) = c->VsrD(1) & 1;
1878 avr_qw_add(&tmp, *a, tmp);
1879 avr_qw_add(r, tmp, *b);
1880 } else {
1881 avr_qw_add(r, *a, *b);
1882 }
1883 #endif
1884 }
1885
1886 void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1887 {
1888 #ifdef CONFIG_INT128
1889 r->u128 = (~a->u128 < b->u128);
1890 #else
1891 ppc_avr_t not_a;
1892
1893 avr_qw_not(&not_a, *a);
1894
1895 r->VsrD(0) = 0;
1896 r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0);
1897 #endif
1898 }
1899
1900 void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1901 {
1902 #ifdef CONFIG_INT128
1903 int carry_out = (~a->u128 < b->u128);
1904 if (!carry_out && (c->u128 & 1)) {
1905 carry_out = ((a->u128 + b->u128 + 1) == 0) &&
1906 ((a->u128 != 0) || (b->u128 != 0));
1907 }
1908 r->u128 = carry_out;
1909 #else
1910
1911 int carry_in = c->VsrD(1) & 1;
1912 int carry_out = 0;
1913 ppc_avr_t tmp;
1914
1915 carry_out = avr_qw_addc(&tmp, *a, *b);
1916
1917 if (!carry_out && carry_in) {
1918 ppc_avr_t one = QW_ONE;
1919 carry_out = avr_qw_addc(&tmp, tmp, one);
1920 }
1921 r->VsrD(0) = 0;
1922 r->VsrD(1) = carry_out;
1923 #endif
1924 }
1925
1926 void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1927 {
1928 #ifdef CONFIG_INT128
1929 r->u128 = a->u128 - b->u128;
1930 #else
1931 ppc_avr_t tmp;
1932 ppc_avr_t one = QW_ONE;
1933
1934 avr_qw_not(&tmp, *b);
1935 avr_qw_add(&tmp, *a, tmp);
1936 avr_qw_add(r, tmp, one);
1937 #endif
1938 }
1939
1940 void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1941 {
1942 #ifdef CONFIG_INT128
1943 r->u128 = a->u128 + ~b->u128 + (c->u128 & 1);
1944 #else
1945 ppc_avr_t tmp, sum;
1946
1947 avr_qw_not(&tmp, *b);
1948 avr_qw_add(&sum, *a, tmp);
1949
1950 tmp.VsrD(0) = 0;
1951 tmp.VsrD(1) = c->VsrD(1) & 1;
1952 avr_qw_add(r, sum, tmp);
1953 #endif
1954 }
1955
1956 void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1957 {
1958 #ifdef CONFIG_INT128
1959 r->u128 = (~a->u128 < ~b->u128) ||
1960 (a->u128 + ~b->u128 == (__uint128_t)-1);
1961 #else
1962 int carry = (avr_qw_cmpu(*a, *b) > 0);
1963 if (!carry) {
1964 ppc_avr_t tmp;
1965 avr_qw_not(&tmp, *b);
1966 avr_qw_add(&tmp, *a, tmp);
1967 carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull));
1968 }
1969 r->VsrD(0) = 0;
1970 r->VsrD(1) = carry;
1971 #endif
1972 }
1973
1974 void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
1975 {
1976 #ifdef CONFIG_INT128
1977 r->u128 =
1978 (~a->u128 < ~b->u128) ||
1979 ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1));
1980 #else
1981 int carry_in = c->VsrD(1) & 1;
1982 int carry_out = (avr_qw_cmpu(*a, *b) > 0);
1983 if (!carry_out && carry_in) {
1984 ppc_avr_t tmp;
1985 avr_qw_not(&tmp, *b);
1986 avr_qw_add(&tmp, *a, tmp);
1987 carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull));
1988 }
1989
1990 r->VsrD(0) = 0;
1991 r->VsrD(1) = carry_out;
1992 #endif
1993 }
1994
1995 #define BCD_PLUS_PREF_1 0xC
1996 #define BCD_PLUS_PREF_2 0xF
1997 #define BCD_PLUS_ALT_1 0xA
1998 #define BCD_NEG_PREF 0xD
1999 #define BCD_NEG_ALT 0xB
2000 #define BCD_PLUS_ALT_2 0xE
2001 #define NATIONAL_PLUS 0x2B
2002 #define NATIONAL_NEG 0x2D
2003
2004 #define BCD_DIG_BYTE(n) (15 - ((n) / 2))
2005
2006 static int bcd_get_sgn(ppc_avr_t *bcd)
2007 {
2008 switch (bcd->VsrB(BCD_DIG_BYTE(0)) & 0xF) {
2009 case BCD_PLUS_PREF_1:
2010 case BCD_PLUS_PREF_2:
2011 case BCD_PLUS_ALT_1:
2012 case BCD_PLUS_ALT_2:
2013 {
2014 return 1;
2015 }
2016
2017 case BCD_NEG_PREF:
2018 case BCD_NEG_ALT:
2019 {
2020 return -1;
2021 }
2022
2023 default:
2024 {
2025 return 0;
2026 }
2027 }
2028 }
2029
2030 static int bcd_preferred_sgn(int sgn, int ps)
2031 {
2032 if (sgn >= 0) {
2033 return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2;
2034 } else {
2035 return BCD_NEG_PREF;
2036 }
2037 }
2038
2039 static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid)
2040 {
2041 uint8_t result;
2042 if (n & 1) {
2043 result = bcd->VsrB(BCD_DIG_BYTE(n)) >> 4;
2044 } else {
2045 result = bcd->VsrB(BCD_DIG_BYTE(n)) & 0xF;
2046 }
2047
2048 if (unlikely(result > 9)) {
2049 *invalid = true;
2050 }
2051 return result;
2052 }
2053
2054 static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n)
2055 {
2056 if (n & 1) {
2057 bcd->VsrB(BCD_DIG_BYTE(n)) &= 0x0F;
2058 bcd->VsrB(BCD_DIG_BYTE(n)) |= (digit << 4);
2059 } else {
2060 bcd->VsrB(BCD_DIG_BYTE(n)) &= 0xF0;
2061 bcd->VsrB(BCD_DIG_BYTE(n)) |= digit;
2062 }
2063 }
2064
2065 static bool bcd_is_valid(ppc_avr_t *bcd)
2066 {
2067 int i;
2068 int invalid = 0;
2069
2070 if (bcd_get_sgn(bcd) == 0) {
2071 return false;
2072 }
2073
2074 for (i = 1; i < 32; i++) {
2075 bcd_get_digit(bcd, i, &invalid);
2076 if (unlikely(invalid)) {
2077 return false;
2078 }
2079 }
2080 return true;
2081 }
2082
2083 static int bcd_cmp_zero(ppc_avr_t *bcd)
2084 {
2085 if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) {
2086 return CRF_EQ;
2087 } else {
2088 return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT;
2089 }
2090 }
2091
2092 static uint16_t get_national_digit(ppc_avr_t *reg, int n)
2093 {
2094 return reg->VsrH(7 - n);
2095 }
2096
2097 static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n)
2098 {
2099 reg->VsrH(7 - n) = val;
2100 }
2101
2102 static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b)
2103 {
2104 int i;
2105 int invalid = 0;
2106 for (i = 31; i > 0; i--) {
2107 uint8_t dig_a = bcd_get_digit(a, i, &invalid);
2108 uint8_t dig_b = bcd_get_digit(b, i, &invalid);
2109 if (unlikely(invalid)) {
2110 return 0; /* doesn't matter */
2111 } else if (dig_a > dig_b) {
2112 return 1;
2113 } else if (dig_a < dig_b) {
2114 return -1;
2115 }
2116 }
2117
2118 return 0;
2119 }
2120
2121 static int bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2122 int *overflow)
2123 {
2124 int carry = 0;
2125 int i;
2126 int is_zero = 1;
2127
2128 for (i = 1; i <= 31; i++) {
2129 uint8_t digit = bcd_get_digit(a, i, invalid) +
2130 bcd_get_digit(b, i, invalid) + carry;
2131 is_zero &= (digit == 0);
2132 if (digit > 9) {
2133 carry = 1;
2134 digit -= 10;
2135 } else {
2136 carry = 0;
2137 }
2138
2139 bcd_put_digit(t, digit, i);
2140 }
2141
2142 *overflow = carry;
2143 return is_zero;
2144 }
2145
2146 static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2147 int *overflow)
2148 {
2149 int carry = 0;
2150 int i;
2151
2152 for (i = 1; i <= 31; i++) {
2153 uint8_t digit = bcd_get_digit(a, i, invalid) -
2154 bcd_get_digit(b, i, invalid) + carry;
2155 if (digit & 0x80) {
2156 carry = -1;
2157 digit += 10;
2158 } else {
2159 carry = 0;
2160 }
2161
2162 bcd_put_digit(t, digit, i);
2163 }
2164
2165 *overflow = carry;
2166 }
2167
2168 uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2169 {
2170
2171 int sgna = bcd_get_sgn(a);
2172 int sgnb = bcd_get_sgn(b);
2173 int invalid = (sgna == 0) || (sgnb == 0);
2174 int overflow = 0;
2175 int zero = 0;
2176 uint32_t cr = 0;
2177 ppc_avr_t result = { .u64 = { 0, 0 } };
2178
2179 if (!invalid) {
2180 if (sgna == sgnb) {
2181 result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps);
2182 zero = bcd_add_mag(&result, a, b, &invalid, &overflow);
2183 cr = (sgna > 0) ? CRF_GT : CRF_LT;
2184 } else {
2185 int magnitude = bcd_cmp_mag(a, b);
2186 if (magnitude > 0) {
2187 result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps);
2188 bcd_sub_mag(&result, a, b, &invalid, &overflow);
2189 cr = (sgna > 0) ? CRF_GT : CRF_LT;
2190 } else if (magnitude < 0) {
2191 result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgnb, ps);
2192 bcd_sub_mag(&result, b, a, &invalid, &overflow);
2193 cr = (sgnb > 0) ? CRF_GT : CRF_LT;
2194 } else {
2195 result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(0, ps);
2196 cr = CRF_EQ;
2197 }
2198 }
2199 }
2200
2201 if (unlikely(invalid)) {
2202 result.VsrD(0) = result.VsrD(1) = -1;
2203 cr = CRF_SO;
2204 } else if (overflow) {
2205 cr |= CRF_SO;
2206 } else if (zero) {
2207 cr |= CRF_EQ;
2208 }
2209
2210 *r = result;
2211
2212 return cr;
2213 }
2214
2215 uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2216 {
2217 ppc_avr_t bcopy = *b;
2218 int sgnb = bcd_get_sgn(b);
2219 if (sgnb < 0) {
2220 bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0);
2221 } else if (sgnb > 0) {
2222 bcd_put_digit(&bcopy, BCD_NEG_PREF, 0);
2223 }
2224 /* else invalid ... defer to bcdadd code for proper handling */
2225
2226 return helper_bcdadd(r, a, &bcopy, ps);
2227 }
2228
2229 uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2230 {
2231 int i;
2232 int cr = 0;
2233 uint16_t national = 0;
2234 uint16_t sgnb = get_national_digit(b, 0);
2235 ppc_avr_t ret = { .u64 = { 0, 0 } };
2236 int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG);
2237
2238 for (i = 1; i < 8; i++) {
2239 national = get_national_digit(b, i);
2240 if (unlikely(national < 0x30 || national > 0x39)) {
2241 invalid = 1;
2242 break;
2243 }
2244
2245 bcd_put_digit(&ret, national & 0xf, i);
2246 }
2247
2248 if (sgnb == NATIONAL_PLUS) {
2249 bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0);
2250 } else {
2251 bcd_put_digit(&ret, BCD_NEG_PREF, 0);
2252 }
2253
2254 cr = bcd_cmp_zero(&ret);
2255
2256 if (unlikely(invalid)) {
2257 cr = CRF_SO;
2258 }
2259
2260 *r = ret;
2261
2262 return cr;
2263 }
2264
2265 uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2266 {
2267 int i;
2268 int cr = 0;
2269 int sgnb = bcd_get_sgn(b);
2270 int invalid = (sgnb == 0);
2271 ppc_avr_t ret = { .u64 = { 0, 0 } };
2272
2273 int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0);
2274
2275 for (i = 1; i < 8; i++) {
2276 set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i);
2277
2278 if (unlikely(invalid)) {
2279 break;
2280 }
2281 }
2282 set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0);
2283
2284 cr = bcd_cmp_zero(b);
2285
2286 if (ox_flag) {
2287 cr |= CRF_SO;
2288 }
2289
2290 if (unlikely(invalid)) {
2291 cr = CRF_SO;
2292 }
2293
2294 *r = ret;
2295
2296 return cr;
2297 }
2298
2299 uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2300 {
2301 int i;
2302 int cr = 0;
2303 int invalid = 0;
2304 int zone_digit = 0;
2305 int zone_lead = ps ? 0xF : 0x3;
2306 int digit = 0;
2307 ppc_avr_t ret = { .u64 = { 0, 0 } };
2308 int sgnb = b->VsrB(BCD_DIG_BYTE(0)) >> 4;
2309
2310 if (unlikely((sgnb < 0xA) && ps)) {
2311 invalid = 1;
2312 }
2313
2314 for (i = 0; i < 16; i++) {
2315 zone_digit = i ? b->VsrB(BCD_DIG_BYTE(i * 2)) >> 4 : zone_lead;
2316 digit = b->VsrB(BCD_DIG_BYTE(i * 2)) & 0xF;
2317 if (unlikely(zone_digit != zone_lead || digit > 0x9)) {
2318 invalid = 1;
2319 break;
2320 }
2321
2322 bcd_put_digit(&ret, digit, i + 1);
2323 }
2324
2325 if ((ps && (sgnb == 0xB || sgnb == 0xD)) ||
2326 (!ps && (sgnb & 0x4))) {
2327 bcd_put_digit(&ret, BCD_NEG_PREF, 0);
2328 } else {
2329 bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0);
2330 }
2331
2332 cr = bcd_cmp_zero(&ret);
2333
2334 if (unlikely(invalid)) {
2335 cr = CRF_SO;
2336 }
2337
2338 *r = ret;
2339
2340 return cr;
2341 }
2342
2343 uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2344 {
2345 int i;
2346 int cr = 0;
2347 uint8_t digit = 0;
2348 int sgnb = bcd_get_sgn(b);
2349 int zone_lead = (ps) ? 0xF0 : 0x30;
2350 int invalid = (sgnb == 0);
2351 ppc_avr_t ret = { .u64 = { 0, 0 } };
2352
2353 int ox_flag = ((b->VsrD(0) >> 4) != 0);
2354
2355 for (i = 0; i < 16; i++) {
2356 digit = bcd_get_digit(b, i + 1, &invalid);
2357
2358 if (unlikely(invalid)) {
2359 break;
2360 }
2361
2362 ret.VsrB(BCD_DIG_BYTE(i * 2)) = zone_lead + digit;
2363 }
2364
2365 if (ps) {
2366 bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1);
2367 } else {
2368 bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1);
2369 }
2370
2371 cr = bcd_cmp_zero(b);
2372
2373 if (ox_flag) {
2374 cr |= CRF_SO;
2375 }
2376
2377 if (unlikely(invalid)) {
2378 cr = CRF_SO;
2379 }
2380
2381 *r = ret;
2382
2383 return cr;
2384 }
2385
2386 /**
2387 * Compare 2 128-bit unsigned integers, passed in as unsigned 64-bit pairs
2388 *
2389 * Returns:
2390 * > 0 if ahi|alo > bhi|blo,
2391 * 0 if ahi|alo == bhi|blo,
2392 * < 0 if ahi|alo < bhi|blo
2393 */
2394 static inline int ucmp128(uint64_t alo, uint64_t ahi,
2395 uint64_t blo, uint64_t bhi)
2396 {
2397 return (ahi == bhi) ?
2398 (alo > blo ? 1 : (alo == blo ? 0 : -1)) :
2399 (ahi > bhi ? 1 : -1);
2400 }
2401
2402 uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2403 {
2404 int i;
2405 int cr;
2406 uint64_t lo_value;
2407 uint64_t hi_value;
2408 uint64_t rem;
2409 ppc_avr_t ret = { .u64 = { 0, 0 } };
2410
2411 if (b->VsrSD(0) < 0) {
2412 lo_value = -b->VsrSD(1);
2413 hi_value = ~b->VsrD(0) + !lo_value;
2414 bcd_put_digit(&ret, 0xD, 0);
2415
2416 cr = CRF_LT;
2417 } else {
2418 lo_value = b->VsrD(1);
2419 hi_value = b->VsrD(0);
2420 bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0);
2421
2422 if (hi_value == 0 && lo_value == 0) {
2423 cr = CRF_EQ;
2424 } else {
2425 cr = CRF_GT;
2426 }
2427 }
2428
2429 /*
2430 * Check src limits: abs(src) <= 10^31 - 1
2431 *
2432 * 10^31 - 1 = 0x0000007e37be2022 c0914b267fffffff
2433 */
2434 if (ucmp128(lo_value, hi_value,
2435 0xc0914b267fffffffULL, 0x7e37be2022ULL) > 0) {
2436 cr |= CRF_SO;
2437
2438 /*
2439 * According to the ISA, if src wouldn't fit in the destination
2440 * register, the result is undefined.
2441 * In that case, we leave r unchanged.
2442 */
2443 } else {
2444 rem = divu128(&lo_value, &hi_value, 1000000000000000ULL);
2445
2446 for (i = 1; i < 16; rem /= 10, i++) {
2447 bcd_put_digit(&ret, rem % 10, i);
2448 }
2449
2450 for (; i < 32; lo_value /= 10, i++) {
2451 bcd_put_digit(&ret, lo_value % 10, i);
2452 }
2453
2454 *r = ret;
2455 }
2456
2457 return cr;
2458 }
2459
2460 uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2461 {
2462 uint8_t i;
2463 int cr;
2464 uint64_t carry;
2465 uint64_t unused;
2466 uint64_t lo_value;
2467 uint64_t hi_value = 0;
2468 int sgnb = bcd_get_sgn(b);
2469 int invalid = (sgnb == 0);
2470
2471 lo_value = bcd_get_digit(b, 31, &invalid);
2472 for (i = 30; i > 0; i--) {
2473 mulu64(&lo_value, &carry, lo_value, 10ULL);
2474 mulu64(&hi_value, &unused, hi_value, 10ULL);
2475 lo_value += bcd_get_digit(b, i, &invalid);
2476 hi_value += carry;
2477
2478 if (unlikely(invalid)) {
2479 break;
2480 }
2481 }
2482
2483 if (sgnb == -1) {
2484 r->VsrSD(1) = -lo_value;
2485 r->VsrSD(0) = ~hi_value + !r->VsrSD(1);
2486 } else {
2487 r->VsrSD(1) = lo_value;
2488 r->VsrSD(0) = hi_value;
2489 }
2490
2491 cr = bcd_cmp_zero(b);
2492
2493 if (unlikely(invalid)) {
2494 cr = CRF_SO;
2495 }
2496
2497 return cr;
2498 }
2499
2500 uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2501 {
2502 int i;
2503 int invalid = 0;
2504
2505 if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) {
2506 return CRF_SO;
2507 }
2508
2509 *r = *a;
2510 bcd_put_digit(r, b->VsrB(BCD_DIG_BYTE(0)) & 0xF, 0);
2511
2512 for (i = 1; i < 32; i++) {
2513 bcd_get_digit(a, i, &invalid);
2514 bcd_get_digit(b, i, &invalid);
2515 if (unlikely(invalid)) {
2516 return CRF_SO;
2517 }
2518 }
2519
2520 return bcd_cmp_zero(r);
2521 }
2522
2523 uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps)
2524 {
2525 int sgnb = bcd_get_sgn(b);
2526
2527 *r = *b;
2528 bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0);
2529
2530 if (bcd_is_valid(b) == false) {
2531 return CRF_SO;
2532 }
2533
2534 return bcd_cmp_zero(r);
2535 }
2536
2537 uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2538 {
2539 int cr;
2540 int i = a->VsrSB(7);
2541 bool ox_flag = false;
2542 int sgnb = bcd_get_sgn(b);
2543 ppc_avr_t ret = *b;
2544 ret.VsrD(1) &= ~0xf;
2545
2546 if (bcd_is_valid(b) == false) {
2547 return CRF_SO;
2548 }
2549
2550 if (unlikely(i > 31)) {
2551 i = 31;
2552 } else if (unlikely(i < -31)) {
2553 i = -31;
2554 }
2555
2556 if (i > 0) {
2557 ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2558 } else {
2559 urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
2560 }
2561 bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0);
2562
2563 *r = ret;
2564
2565 cr = bcd_cmp_zero(r);
2566 if (ox_flag) {
2567 cr |= CRF_SO;
2568 }
2569
2570 return cr;
2571 }
2572
2573 uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2574 {
2575 int cr;
2576 int i;
2577 int invalid = 0;
2578 bool ox_flag = false;
2579 ppc_avr_t ret = *b;
2580
2581 for (i = 0; i < 32; i++) {
2582 bcd_get_digit(b, i, &invalid);
2583
2584 if (unlikely(invalid)) {
2585 return CRF_SO;
2586 }
2587 }
2588
2589 i = a->VsrSB(7);
2590 if (i >= 32) {
2591 ox_flag = true;
2592 ret.VsrD(1) = ret.VsrD(0) = 0;
2593 } else if (i <= -32) {
2594 ret.VsrD(1) = ret.VsrD(0) = 0;
2595 } else if (i > 0) {
2596 ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2597 } else {
2598 urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
2599 }
2600 *r = ret;
2601
2602 cr = bcd_cmp_zero(r);
2603 if (ox_flag) {
2604 cr |= CRF_SO;
2605 }
2606
2607 return cr;
2608 }
2609
2610 uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2611 {
2612 int cr;
2613 int unused = 0;
2614 int invalid = 0;
2615 bool ox_flag = false;
2616 int sgnb = bcd_get_sgn(b);
2617 ppc_avr_t ret = *b;
2618 ret.VsrD(1) &= ~0xf;
2619
2620 int i = a->VsrSB(7);
2621 ppc_avr_t bcd_one;
2622
2623 bcd_one.VsrD(0) = 0;
2624 bcd_one.VsrD(1) = 0x10;
2625
2626 if (bcd_is_valid(b) == false) {
2627 return CRF_SO;
2628 }
2629
2630 if (unlikely(i > 31)) {
2631 i = 31;
2632 } else if (unlikely(i < -31)) {
2633 i = -31;
2634 }
2635
2636 if (i > 0) {
2637 ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag);
2638 } else {
2639 urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4);
2640
2641 if (bcd_get_digit(&ret, 0, &invalid) >= 5) {
2642 bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused);
2643 }
2644 }
2645 bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0);
2646
2647 cr = bcd_cmp_zero(&ret);
2648 if (ox_flag) {
2649 cr |= CRF_SO;
2650 }
2651 *r = ret;
2652
2653 return cr;
2654 }
2655
2656 uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2657 {
2658 uint64_t mask;
2659 uint32_t ox_flag = 0;
2660 int i = a->VsrSH(3) + 1;
2661 ppc_avr_t ret = *b;
2662
2663 if (bcd_is_valid(b) == false) {
2664 return CRF_SO;
2665 }
2666
2667 if (i > 16 && i < 32) {
2668 mask = (uint64_t)-1 >> (128 - i * 4);
2669 if (ret.VsrD(0) & ~mask) {
2670 ox_flag = CRF_SO;
2671 }
2672
2673 ret.VsrD(0) &= mask;
2674 } else if (i >= 0 && i <= 16) {
2675 mask = (uint64_t)-1 >> (64 - i * 4);
2676 if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) {
2677 ox_flag = CRF_SO;
2678 }
2679
2680 ret.VsrD(1) &= mask;
2681 ret.VsrD(0) = 0;
2682 }
2683 bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0);
2684 *r = ret;
2685
2686 return bcd_cmp_zero(&ret) | ox_flag;
2687 }
2688
2689 uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2690 {
2691 int i;
2692 uint64_t mask;
2693 uint32_t ox_flag = 0;
2694 int invalid = 0;
2695 ppc_avr_t ret = *b;
2696
2697 for (i = 0; i < 32; i++) {
2698 bcd_get_digit(b, i, &invalid);
2699
2700 if (unlikely(invalid)) {
2701 return CRF_SO;
2702 }
2703 }
2704
2705 i = a->VsrSH(3);
2706 if (i > 16 && i < 33) {
2707 mask = (uint64_t)-1 >> (128 - i * 4);
2708 if (ret.VsrD(0) & ~mask) {
2709 ox_flag = CRF_SO;
2710 }
2711
2712 ret.VsrD(0) &= mask;
2713 } else if (i > 0 && i <= 16) {
2714 mask = (uint64_t)-1 >> (64 - i * 4);
2715 if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) {
2716 ox_flag = CRF_SO;
2717 }
2718
2719 ret.VsrD(1) &= mask;
2720 ret.VsrD(0) = 0;
2721 } else if (i == 0) {
2722 if (ret.VsrD(0) || ret.VsrD(1)) {
2723 ox_flag = CRF_SO;
2724 }
2725 ret.VsrD(0) = ret.VsrD(1) = 0;
2726 }
2727
2728 *r = ret;
2729 if (r->VsrD(0) == 0 && r->VsrD(1) == 0) {
2730 return ox_flag | CRF_EQ;
2731 }
2732
2733 return ox_flag | CRF_GT;
2734 }
2735
2736 void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a)
2737 {
2738 int i;
2739 VECTOR_FOR_INORDER_I(i, u8) {
2740 r->u8[i] = AES_sbox[a->u8[i]];
2741 }
2742 }
2743
2744 void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2745 {
2746 ppc_avr_t result;
2747 int i;
2748
2749 VECTOR_FOR_INORDER_I(i, u32) {
2750 result.VsrW(i) = b->VsrW(i) ^
2751 (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^
2752 AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^
2753 AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^
2754 AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]);
2755 }
2756 *r = result;
2757 }
2758
2759 void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2760 {
2761 ppc_avr_t result;
2762 int i;
2763
2764 VECTOR_FOR_INORDER_I(i, u8) {
2765 result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]);
2766 }
2767 *r = result;
2768 }
2769
2770 void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2771 {
2772 /* This differs from what is written in ISA V2.07. The RTL is */
2773 /* incorrect and will be fixed in V2.07B. */
2774 int i;
2775 ppc_avr_t tmp;
2776
2777 VECTOR_FOR_INORDER_I(i, u8) {
2778 tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])];
2779 }
2780
2781 VECTOR_FOR_INORDER_I(i, u32) {
2782 r->VsrW(i) =
2783 AES_imc[tmp.VsrB(4 * i + 0)][0] ^
2784 AES_imc[tmp.VsrB(4 * i + 1)][1] ^
2785 AES_imc[tmp.VsrB(4 * i + 2)][2] ^
2786 AES_imc[tmp.VsrB(4 * i + 3)][3];
2787 }
2788 }
2789
2790 void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2791 {
2792 ppc_avr_t result;
2793 int i;
2794
2795 VECTOR_FOR_INORDER_I(i, u8) {
2796 result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]);
2797 }
2798 *r = result;
2799 }
2800
2801 void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six)
2802 {
2803 int st = (st_six & 0x10) != 0;
2804 int six = st_six & 0xF;
2805 int i;
2806
2807 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
2808 if (st == 0) {
2809 if ((six & (0x8 >> i)) == 0) {
2810 r->VsrW(i) = ror32(a->VsrW(i), 7) ^
2811 ror32(a->VsrW(i), 18) ^
2812 (a->VsrW(i) >> 3);
2813 } else { /* six.bit[i] == 1 */
2814 r->VsrW(i) = ror32(a->VsrW(i), 17) ^
2815 ror32(a->VsrW(i), 19) ^
2816 (a->VsrW(i) >> 10);
2817 }
2818 } else { /* st == 1 */
2819 if ((six & (0x8 >> i)) == 0) {
2820 r->VsrW(i) = ror32(a->VsrW(i), 2) ^
2821 ror32(a->VsrW(i), 13) ^
2822 ror32(a->VsrW(i), 22);
2823 } else { /* six.bit[i] == 1 */
2824 r->VsrW(i) = ror32(a->VsrW(i), 6) ^
2825 ror32(a->VsrW(i), 11) ^
2826 ror32(a->VsrW(i), 25);
2827 }
2828 }
2829 }
2830 }
2831
2832 void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six)
2833 {
2834 int st = (st_six & 0x10) != 0;
2835 int six = st_six & 0xF;
2836 int i;
2837
2838 for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
2839 if (st == 0) {
2840 if ((six & (0x8 >> (2 * i))) == 0) {
2841 r->VsrD(i) = ror64(a->VsrD(i), 1) ^
2842 ror64(a->VsrD(i), 8) ^
2843 (a->VsrD(i) >> 7);
2844 } else { /* six.bit[2*i] == 1 */
2845 r->VsrD(i) = ror64(a->VsrD(i), 19) ^
2846 ror64(a->VsrD(i), 61) ^
2847 (a->VsrD(i) >> 6);
2848 }
2849 } else { /* st == 1 */
2850 if ((six & (0x8 >> (2 * i))) == 0) {
2851 r->VsrD(i) = ror64(a->VsrD(i), 28) ^
2852 ror64(a->VsrD(i), 34) ^
2853 ror64(a->VsrD(i), 39);
2854 } else { /* six.bit[2*i] == 1 */
2855 r->VsrD(i) = ror64(a->VsrD(i), 14) ^
2856 ror64(a->VsrD(i), 18) ^
2857 ror64(a->VsrD(i), 41);
2858 }
2859 }
2860 }
2861 }
2862
2863 void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2864 {
2865 ppc_avr_t result;
2866 int i;
2867
2868 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
2869 int indexA = c->VsrB(i) >> 4;
2870 int indexB = c->VsrB(i) & 0xF;
2871
2872 result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB);
2873 }
2874 *r = result;
2875 }
2876
2877 #undef VECTOR_FOR_INORDER_I
2878
2879 /*****************************************************************************/
2880 /* SPE extension helpers */
2881 /* Use a table to make this quicker */
2882 static const uint8_t hbrev[16] = {
2883 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
2884 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
2885 };
2886
2887 static inline uint8_t byte_reverse(uint8_t val)
2888 {
2889 return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
2890 }
2891
2892 static inline uint32_t word_reverse(uint32_t val)
2893 {
2894 return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
2895 (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
2896 }
2897
2898 #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */
2899 target_ulong helper_brinc(target_ulong arg1, target_ulong arg2)
2900 {
2901 uint32_t a, b, d, mask;
2902
2903 mask = UINT32_MAX >> (32 - MASKBITS);
2904 a = arg1 & mask;
2905 b = arg2 & mask;
2906 d = word_reverse(1 + word_reverse(a | ~b));
2907 return (arg1 & ~mask) | (d & b);
2908 }
2909
2910 uint32_t helper_cntlsw32(uint32_t val)
2911 {
2912 if (val & 0x80000000) {
2913 return clz32(~val);
2914 } else {
2915 return clz32(val);
2916 }
2917 }
2918
2919 uint32_t helper_cntlzw32(uint32_t val)
2920 {
2921 return clz32(val);
2922 }
2923
2924 /* 440 specific */
2925 target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high,
2926 target_ulong low, uint32_t update_Rc)
2927 {
2928 target_ulong mask;
2929 int i;
2930
2931 i = 1;
2932 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2933 if ((high & mask) == 0) {
2934 if (update_Rc) {
2935 env->crf[0] = 0x4;
2936 }
2937 goto done;
2938 }
2939 i++;
2940 }
2941 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2942 if ((low & mask) == 0) {
2943 if (update_Rc) {
2944 env->crf[0] = 0x8;
2945 }
2946 goto done;
2947 }
2948 i++;
2949 }
2950 i = 8;
2951 if (update_Rc) {
2952 env->crf[0] = 0x2;
2953 }
2954 done:
2955 env->xer = (env->xer & ~0x7F) | i;
2956 if (update_Rc) {
2957 env->crf[0] |= xer_so;
2958 }
2959 return i;
2960 }
QEmu