]> git.proxmox.com Git - mirror_qemu.git/blob - target-ppc/int_helper.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
target-ppc: add vector extract instructions
[mirror_qemu.git] / target-ppc / int_helper.c
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 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "qemu/osdep.h"
20 #include "cpu.h"
21 #include "exec/exec-all.h"
22 #include "qemu/host-utils.h"
23 #include "exec/helper-proto.h"
24 #include "crypto/aes.h"
25
26 #include "helper_regs.h"
27 /*****************************************************************************/
28 /* Fixed point operations helpers */
29
30 target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb,
31 uint32_t oe)
32 {
33 uint64_t rt = 0;
34 int overflow = 0;
35
36 uint64_t dividend = (uint64_t)ra << 32;
37 uint64_t divisor = (uint32_t)rb;
38
39 if (unlikely(divisor == 0)) {
40 overflow = 1;
41 } else {
42 rt = dividend / divisor;
43 overflow = rt > UINT32_MAX;
44 }
45
46 if (unlikely(overflow)) {
47 rt = 0; /* Undefined */
48 }
49
50 if (oe) {
51 if (unlikely(overflow)) {
52 env->so = env->ov = 1;
53 } else {
54 env->ov = 0;
55 }
56 }
57
58 return (target_ulong)rt;
59 }
60
61 target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb,
62 uint32_t oe)
63 {
64 int64_t rt = 0;
65 int overflow = 0;
66
67 int64_t dividend = (int64_t)ra << 32;
68 int64_t divisor = (int64_t)((int32_t)rb);
69
70 if (unlikely((divisor == 0) ||
71 ((divisor == -1ull) && (dividend == INT64_MIN)))) {
72 overflow = 1;
73 } else {
74 rt = dividend / divisor;
75 overflow = rt != (int32_t)rt;
76 }
77
78 if (unlikely(overflow)) {
79 rt = 0; /* Undefined */
80 }
81
82 if (oe) {
83 if (unlikely(overflow)) {
84 env->so = env->ov = 1;
85 } else {
86 env->ov = 0;
87 }
88 }
89
90 return (target_ulong)rt;
91 }
92
93 #if defined(TARGET_PPC64)
94
95 uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe)
96 {
97 uint64_t rt = 0;
98 int overflow = 0;
99
100 overflow = divu128(&rt, &ra, rb);
101
102 if (unlikely(overflow)) {
103 rt = 0; /* Undefined */
104 }
105
106 if (oe) {
107 if (unlikely(overflow)) {
108 env->so = env->ov = 1;
109 } else {
110 env->ov = 0;
111 }
112 }
113
114 return rt;
115 }
116
117 uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe)
118 {
119 int64_t rt = 0;
120 int64_t ra = (int64_t)rau;
121 int64_t rb = (int64_t)rbu;
122 int overflow = divs128(&rt, &ra, rb);
123
124 if (unlikely(overflow)) {
125 rt = 0; /* Undefined */
126 }
127
128 if (oe) {
129
130 if (unlikely(overflow)) {
131 env->so = env->ov = 1;
132 } else {
133 env->ov = 0;
134 }
135 }
136
137 return rt;
138 }
139
140 #endif
141
142
143 target_ulong helper_cntlzw(target_ulong t)
144 {
145 return clz32(t);
146 }
147
148 target_ulong helper_cnttzw(target_ulong t)
149 {
150 return ctz32(t);
151 }
152
153 #if defined(TARGET_PPC64)
154 /* if x = 0xab, returns 0xababababababababa */
155 #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff))
156
157 /* substract 1 from each byte, and with inverse, check if MSB is set at each
158 * byte.
159 * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80
160 * (0xFF & 0xFF) & 0x80 = 0x80 (zero found)
161 */
162 #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80))
163
164 /* When you XOR the pattern and there is a match, that byte will be zero */
165 #define hasvalue(x, n) (haszero((x) ^ pattern(n)))
166
167 uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb)
168 {
169 return hasvalue(rb, ra) ? 1 << CRF_GT : 0;
170 }
171
172 #undef pattern
173 #undef haszero
174 #undef hasvalue
175
176 target_ulong helper_cntlzd(target_ulong t)
177 {
178 return clz64(t);
179 }
180
181 target_ulong helper_cnttzd(target_ulong t)
182 {
183 return ctz64(t);
184 }
185 #endif
186
187 #if defined(TARGET_PPC64)
188
189 uint64_t helper_bpermd(uint64_t rs, uint64_t rb)
190 {
191 int i;
192 uint64_t ra = 0;
193
194 for (i = 0; i < 8; i++) {
195 int index = (rs >> (i*8)) & 0xFF;
196 if (index < 64) {
197 if (rb & (1ull << (63-index))) {
198 ra |= 1 << i;
199 }
200 }
201 }
202 return ra;
203 }
204
205 #endif
206
207 target_ulong helper_cmpb(target_ulong rs, target_ulong rb)
208 {
209 target_ulong mask = 0xff;
210 target_ulong ra = 0;
211 int i;
212
213 for (i = 0; i < sizeof(target_ulong); i++) {
214 if ((rs & mask) == (rb & mask)) {
215 ra |= mask;
216 }
217 mask <<= 8;
218 }
219 return ra;
220 }
221
222 /* shift right arithmetic helper */
223 target_ulong helper_sraw(CPUPPCState *env, target_ulong value,
224 target_ulong shift)
225 {
226 int32_t ret;
227
228 if (likely(!(shift & 0x20))) {
229 if (likely((uint32_t)shift != 0)) {
230 shift &= 0x1f;
231 ret = (int32_t)value >> shift;
232 if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) {
233 env->ca = 0;
234 } else {
235 env->ca = 1;
236 }
237 } else {
238 ret = (int32_t)value;
239 env->ca = 0;
240 }
241 } else {
242 ret = (int32_t)value >> 31;
243 env->ca = (ret != 0);
244 }
245 return (target_long)ret;
246 }
247
248 #if defined(TARGET_PPC64)
249 target_ulong helper_srad(CPUPPCState *env, target_ulong value,
250 target_ulong shift)
251 {
252 int64_t ret;
253
254 if (likely(!(shift & 0x40))) {
255 if (likely((uint64_t)shift != 0)) {
256 shift &= 0x3f;
257 ret = (int64_t)value >> shift;
258 if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) {
259 env->ca = 0;
260 } else {
261 env->ca = 1;
262 }
263 } else {
264 ret = (int64_t)value;
265 env->ca = 0;
266 }
267 } else {
268 ret = (int64_t)value >> 63;
269 env->ca = (ret != 0);
270 }
271 return ret;
272 }
273 #endif
274
275 #if defined(TARGET_PPC64)
276 target_ulong helper_popcntb(target_ulong val)
277 {
278 val = (val & 0x5555555555555555ULL) + ((val >> 1) &
279 0x5555555555555555ULL);
280 val = (val & 0x3333333333333333ULL) + ((val >> 2) &
281 0x3333333333333333ULL);
282 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) &
283 0x0f0f0f0f0f0f0f0fULL);
284 return val;
285 }
286
287 target_ulong helper_popcntw(target_ulong val)
288 {
289 val = (val & 0x5555555555555555ULL) + ((val >> 1) &
290 0x5555555555555555ULL);
291 val = (val & 0x3333333333333333ULL) + ((val >> 2) &
292 0x3333333333333333ULL);
293 val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) &
294 0x0f0f0f0f0f0f0f0fULL);
295 val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) &
296 0x00ff00ff00ff00ffULL);
297 val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) &
298 0x0000ffff0000ffffULL);
299 return val;
300 }
301
302 target_ulong helper_popcntd(target_ulong val)
303 {
304 return ctpop64(val);
305 }
306 #else
307 target_ulong helper_popcntb(target_ulong val)
308 {
309 val = (val & 0x55555555) + ((val >> 1) & 0x55555555);
310 val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
311 val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f);
312 return val;
313 }
314
315 target_ulong helper_popcntw(target_ulong val)
316 {
317 val = (val & 0x55555555) + ((val >> 1) & 0x55555555);
318 val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
319 val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f);
320 val = (val & 0x00ff00ff) + ((val >> 8) & 0x00ff00ff);
321 val = (val & 0x0000ffff) + ((val >> 16) & 0x0000ffff);
322 return val;
323 }
324 #endif
325
326 /*****************************************************************************/
327 /* PowerPC 601 specific instructions (POWER bridge) */
328 target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2)
329 {
330 uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
331
332 if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
333 (int32_t)arg2 == 0) {
334 env->spr[SPR_MQ] = 0;
335 return INT32_MIN;
336 } else {
337 env->spr[SPR_MQ] = tmp % arg2;
338 return tmp / (int32_t)arg2;
339 }
340 }
341
342 target_ulong helper_divo(CPUPPCState *env, target_ulong arg1,
343 target_ulong arg2)
344 {
345 uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ];
346
347 if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
348 (int32_t)arg2 == 0) {
349 env->so = env->ov = 1;
350 env->spr[SPR_MQ] = 0;
351 return INT32_MIN;
352 } else {
353 env->spr[SPR_MQ] = tmp % arg2;
354 tmp /= (int32_t)arg2;
355 if ((int32_t)tmp != tmp) {
356 env->so = env->ov = 1;
357 } else {
358 env->ov = 0;
359 }
360 return tmp;
361 }
362 }
363
364 target_ulong helper_divs(CPUPPCState *env, target_ulong arg1,
365 target_ulong arg2)
366 {
367 if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
368 (int32_t)arg2 == 0) {
369 env->spr[SPR_MQ] = 0;
370 return INT32_MIN;
371 } else {
372 env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
373 return (int32_t)arg1 / (int32_t)arg2;
374 }
375 }
376
377 target_ulong helper_divso(CPUPPCState *env, target_ulong arg1,
378 target_ulong arg2)
379 {
380 if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) ||
381 (int32_t)arg2 == 0) {
382 env->so = env->ov = 1;
383 env->spr[SPR_MQ] = 0;
384 return INT32_MIN;
385 } else {
386 env->ov = 0;
387 env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2;
388 return (int32_t)arg1 / (int32_t)arg2;
389 }
390 }
391
392 /*****************************************************************************/
393 /* 602 specific instructions */
394 /* mfrom is the most crazy instruction ever seen, imho ! */
395 /* Real implementation uses a ROM table. Do the same */
396 /* Extremely decomposed:
397 * -arg / 256
398 * return 256 * log10(10 + 1.0) + 0.5
399 */
400 #if !defined(CONFIG_USER_ONLY)
401 target_ulong helper_602_mfrom(target_ulong arg)
402 {
403 if (likely(arg < 602)) {
404 #include "mfrom_table.c"
405 return mfrom_ROM_table[arg];
406 } else {
407 return 0;
408 }
409 }
410 #endif
411
412 /*****************************************************************************/
413 /* Altivec extension helpers */
414 #if defined(HOST_WORDS_BIGENDIAN)
415 #define HI_IDX 0
416 #define LO_IDX 1
417 #define AVRB(i) u8[i]
418 #define AVRW(i) u32[i]
419 #else
420 #define HI_IDX 1
421 #define LO_IDX 0
422 #define AVRB(i) u8[15-(i)]
423 #define AVRW(i) u32[3-(i)]
424 #endif
425
426 #if defined(HOST_WORDS_BIGENDIAN)
427 #define VECTOR_FOR_INORDER_I(index, element) \
428 for (index = 0; index < ARRAY_SIZE(r->element); index++)
429 #else
430 #define VECTOR_FOR_INORDER_I(index, element) \
431 for (index = ARRAY_SIZE(r->element)-1; index >= 0; index--)
432 #endif
433
434 /* Saturating arithmetic helpers. */
435 #define SATCVT(from, to, from_type, to_type, min, max) \
436 static inline to_type cvt##from##to(from_type x, int *sat) \
437 { \
438 to_type r; \
439 \
440 if (x < (from_type)min) { \
441 r = min; \
442 *sat = 1; \
443 } else if (x > (from_type)max) { \
444 r = max; \
445 *sat = 1; \
446 } else { \
447 r = x; \
448 } \
449 return r; \
450 }
451 #define SATCVTU(from, to, from_type, to_type, min, max) \
452 static inline to_type cvt##from##to(from_type x, int *sat) \
453 { \
454 to_type r; \
455 \
456 if (x > (from_type)max) { \
457 r = max; \
458 *sat = 1; \
459 } else { \
460 r = x; \
461 } \
462 return r; \
463 }
464 SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX)
465 SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX)
466 SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX)
467
468 SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX)
469 SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX)
470 SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX)
471 SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX)
472 SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX)
473 SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX)
474 #undef SATCVT
475 #undef SATCVTU
476
477 void helper_lvsl(ppc_avr_t *r, target_ulong sh)
478 {
479 int i, j = (sh & 0xf);
480
481 VECTOR_FOR_INORDER_I(i, u8) {
482 r->u8[i] = j++;
483 }
484 }
485
486 void helper_lvsr(ppc_avr_t *r, target_ulong sh)
487 {
488 int i, j = 0x10 - (sh & 0xf);
489
490 VECTOR_FOR_INORDER_I(i, u8) {
491 r->u8[i] = j++;
492 }
493 }
494
495 void helper_mtvscr(CPUPPCState *env, ppc_avr_t *r)
496 {
497 #if defined(HOST_WORDS_BIGENDIAN)
498 env->vscr = r->u32[3];
499 #else
500 env->vscr = r->u32[0];
501 #endif
502 set_flush_to_zero(vscr_nj, &env->vec_status);
503 }
504
505 void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
506 {
507 int i;
508
509 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
510 r->u32[i] = ~a->u32[i] < b->u32[i];
511 }
512 }
513
514 #define VARITH_DO(name, op, element) \
515 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
516 { \
517 int i; \
518 \
519 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
520 r->element[i] = a->element[i] op b->element[i]; \
521 } \
522 }
523 #define VARITH(suffix, element) \
524 VARITH_DO(add##suffix, +, element) \
525 VARITH_DO(sub##suffix, -, element)
526 VARITH(ubm, u8)
527 VARITH(uhm, u16)
528 VARITH(uwm, u32)
529 VARITH(udm, u64)
530 VARITH_DO(muluwm, *, u32)
531 #undef VARITH_DO
532 #undef VARITH
533
534 #define VARITHFP(suffix, func) \
535 void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
536 ppc_avr_t *b) \
537 { \
538 int i; \
539 \
540 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
541 r->f[i] = func(a->f[i], b->f[i], &env->vec_status); \
542 } \
543 }
544 VARITHFP(addfp, float32_add)
545 VARITHFP(subfp, float32_sub)
546 VARITHFP(minfp, float32_min)
547 VARITHFP(maxfp, float32_max)
548 #undef VARITHFP
549
550 #define VARITHFPFMA(suffix, type) \
551 void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
552 ppc_avr_t *b, ppc_avr_t *c) \
553 { \
554 int i; \
555 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
556 r->f[i] = float32_muladd(a->f[i], c->f[i], b->f[i], \
557 type, &env->vec_status); \
558 } \
559 }
560 VARITHFPFMA(maddfp, 0);
561 VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c);
562 #undef VARITHFPFMA
563
564 #define VARITHSAT_CASE(type, op, cvt, element) \
565 { \
566 type result = (type)a->element[i] op (type)b->element[i]; \
567 r->element[i] = cvt(result, &sat); \
568 }
569
570 #define VARITHSAT_DO(name, op, optype, cvt, element) \
571 void helper_v##name(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \
572 ppc_avr_t *b) \
573 { \
574 int sat = 0; \
575 int i; \
576 \
577 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
578 switch (sizeof(r->element[0])) { \
579 case 1: \
580 VARITHSAT_CASE(optype, op, cvt, element); \
581 break; \
582 case 2: \
583 VARITHSAT_CASE(optype, op, cvt, element); \
584 break; \
585 case 4: \
586 VARITHSAT_CASE(optype, op, cvt, element); \
587 break; \
588 } \
589 } \
590 if (sat) { \
591 env->vscr |= (1 << VSCR_SAT); \
592 } \
593 }
594 #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \
595 VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \
596 VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element)
597 #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \
598 VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \
599 VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element)
600 VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb)
601 VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh)
602 VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw)
603 VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub)
604 VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh)
605 VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw)
606 #undef VARITHSAT_CASE
607 #undef VARITHSAT_DO
608 #undef VARITHSAT_SIGNED
609 #undef VARITHSAT_UNSIGNED
610
611 #define VAVG_DO(name, element, etype) \
612 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
613 { \
614 int i; \
615 \
616 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
617 etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \
618 r->element[i] = x >> 1; \
619 } \
620 }
621
622 #define VAVG(type, signed_element, signed_type, unsigned_element, \
623 unsigned_type) \
624 VAVG_DO(avgs##type, signed_element, signed_type) \
625 VAVG_DO(avgu##type, unsigned_element, unsigned_type)
626 VAVG(b, s8, int16_t, u8, uint16_t)
627 VAVG(h, s16, int32_t, u16, uint32_t)
628 VAVG(w, s32, int64_t, u32, uint64_t)
629 #undef VAVG_DO
630 #undef VAVG
631
632 #define VABSDU_DO(name, element) \
633 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
634 { \
635 int i; \
636 \
637 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
638 r->element[i] = (a->element[i] > b->element[i]) ? \
639 (a->element[i] - b->element[i]) : \
640 (b->element[i] - a->element[i]); \
641 } \
642 }
643
644 /* VABSDU - Vector absolute difference unsigned
645 * name - instruction mnemonic suffix (b: byte, h: halfword, w: word)
646 * element - element type to access from vector
647 */
648 #define VABSDU(type, element) \
649 VABSDU_DO(absdu##type, element)
650 VABSDU(b, u8)
651 VABSDU(h, u16)
652 VABSDU(w, u32)
653 #undef VABSDU_DO
654 #undef VABSDU
655
656 #define VCF(suffix, cvt, element) \
657 void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \
658 ppc_avr_t *b, uint32_t uim) \
659 { \
660 int i; \
661 \
662 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
663 float32 t = cvt(b->element[i], &env->vec_status); \
664 r->f[i] = float32_scalbn(t, -uim, &env->vec_status); \
665 } \
666 }
667 VCF(ux, uint32_to_float32, u32)
668 VCF(sx, int32_to_float32, s32)
669 #undef VCF
670
671 #define VCMP_DO(suffix, compare, element, record) \
672 void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \
673 ppc_avr_t *a, ppc_avr_t *b) \
674 { \
675 uint64_t ones = (uint64_t)-1; \
676 uint64_t all = ones; \
677 uint64_t none = 0; \
678 int i; \
679 \
680 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
681 uint64_t result = (a->element[i] compare b->element[i] ? \
682 ones : 0x0); \
683 switch (sizeof(a->element[0])) { \
684 case 8: \
685 r->u64[i] = result; \
686 break; \
687 case 4: \
688 r->u32[i] = result; \
689 break; \
690 case 2: \
691 r->u16[i] = result; \
692 break; \
693 case 1: \
694 r->u8[i] = result; \
695 break; \
696 } \
697 all &= result; \
698 none |= result; \
699 } \
700 if (record) { \
701 env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \
702 } \
703 }
704 #define VCMP(suffix, compare, element) \
705 VCMP_DO(suffix, compare, element, 0) \
706 VCMP_DO(suffix##_dot, compare, element, 1)
707 VCMP(equb, ==, u8)
708 VCMP(equh, ==, u16)
709 VCMP(equw, ==, u32)
710 VCMP(equd, ==, u64)
711 VCMP(gtub, >, u8)
712 VCMP(gtuh, >, u16)
713 VCMP(gtuw, >, u32)
714 VCMP(gtud, >, u64)
715 VCMP(gtsb, >, s8)
716 VCMP(gtsh, >, s16)
717 VCMP(gtsw, >, s32)
718 VCMP(gtsd, >, s64)
719 #undef VCMP_DO
720 #undef VCMP
721
722 #define VCMPNEZ_DO(suffix, element, etype, record) \
723 void helper_vcmpnez##suffix(CPUPPCState *env, ppc_avr_t *r, \
724 ppc_avr_t *a, ppc_avr_t *b) \
725 { \
726 etype ones = (etype)-1; \
727 etype all = ones; \
728 etype none = 0; \
729 int i; \
730 \
731 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
732 etype result = ((a->element[i] == 0) \
733 || (b->element[i] == 0) \
734 || (a->element[i] != b->element[i]) ? \
735 ones : 0x0); \
736 r->element[i] = result; \
737 all &= result; \
738 none |= result; \
739 } \
740 if (record) { \
741 env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \
742 } \
743 }
744
745 /* VCMPNEZ - Vector compare not equal to zero
746 * suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word)
747 * element - element type to access from vector
748 */
749 #define VCMPNEZ(suffix, element, etype) \
750 VCMPNEZ_DO(suffix, element, etype, 0) \
751 VCMPNEZ_DO(suffix##_dot, element, etype, 1)
752 VCMPNEZ(b, u8, uint8_t)
753 VCMPNEZ(h, u16, uint16_t)
754 VCMPNEZ(w, u32, uint32_t)
755 #undef VCMPNEZ_DO
756 #undef VCMPNEZ
757
758 #define VCMPFP_DO(suffix, compare, order, record) \
759 void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \
760 ppc_avr_t *a, ppc_avr_t *b) \
761 { \
762 uint32_t ones = (uint32_t)-1; \
763 uint32_t all = ones; \
764 uint32_t none = 0; \
765 int i; \
766 \
767 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
768 uint32_t result; \
769 int rel = float32_compare_quiet(a->f[i], b->f[i], \
770 &env->vec_status); \
771 if (rel == float_relation_unordered) { \
772 result = 0; \
773 } else if (rel compare order) { \
774 result = ones; \
775 } else { \
776 result = 0; \
777 } \
778 r->u32[i] = result; \
779 all &= result; \
780 none |= result; \
781 } \
782 if (record) { \
783 env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \
784 } \
785 }
786 #define VCMPFP(suffix, compare, order) \
787 VCMPFP_DO(suffix, compare, order, 0) \
788 VCMPFP_DO(suffix##_dot, compare, order, 1)
789 VCMPFP(eqfp, ==, float_relation_equal)
790 VCMPFP(gefp, !=, float_relation_less)
791 VCMPFP(gtfp, ==, float_relation_greater)
792 #undef VCMPFP_DO
793 #undef VCMPFP
794
795 static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r,
796 ppc_avr_t *a, ppc_avr_t *b, int record)
797 {
798 int i;
799 int all_in = 0;
800
801 for (i = 0; i < ARRAY_SIZE(r->f); i++) {
802 int le_rel = float32_compare_quiet(a->f[i], b->f[i], &env->vec_status);
803 if (le_rel == float_relation_unordered) {
804 r->u32[i] = 0xc0000000;
805 all_in = 1;
806 } else {
807 float32 bneg = float32_chs(b->f[i]);
808 int ge_rel = float32_compare_quiet(a->f[i], bneg, &env->vec_status);
809 int le = le_rel != float_relation_greater;
810 int ge = ge_rel != float_relation_less;
811
812 r->u32[i] = ((!le) << 31) | ((!ge) << 30);
813 all_in |= (!le | !ge);
814 }
815 }
816 if (record) {
817 env->crf[6] = (all_in == 0) << 1;
818 }
819 }
820
821 void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
822 {
823 vcmpbfp_internal(env, r, a, b, 0);
824 }
825
826 void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
827 ppc_avr_t *b)
828 {
829 vcmpbfp_internal(env, r, a, b, 1);
830 }
831
832 #define VCT(suffix, satcvt, element) \
833 void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \
834 ppc_avr_t *b, uint32_t uim) \
835 { \
836 int i; \
837 int sat = 0; \
838 float_status s = env->vec_status; \
839 \
840 set_float_rounding_mode(float_round_to_zero, &s); \
841 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
842 if (float32_is_any_nan(b->f[i])) { \
843 r->element[i] = 0; \
844 } else { \
845 float64 t = float32_to_float64(b->f[i], &s); \
846 int64_t j; \
847 \
848 t = float64_scalbn(t, uim, &s); \
849 j = float64_to_int64(t, &s); \
850 r->element[i] = satcvt(j, &sat); \
851 } \
852 } \
853 if (sat) { \
854 env->vscr |= (1 << VSCR_SAT); \
855 } \
856 }
857 VCT(uxs, cvtsduw, u32)
858 VCT(sxs, cvtsdsw, s32)
859 #undef VCT
860
861 void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
862 ppc_avr_t *b, ppc_avr_t *c)
863 {
864 int sat = 0;
865 int i;
866
867 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
868 int32_t prod = a->s16[i] * b->s16[i];
869 int32_t t = (int32_t)c->s16[i] + (prod >> 15);
870
871 r->s16[i] = cvtswsh(t, &sat);
872 }
873
874 if (sat) {
875 env->vscr |= (1 << VSCR_SAT);
876 }
877 }
878
879 void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
880 ppc_avr_t *b, ppc_avr_t *c)
881 {
882 int sat = 0;
883 int i;
884
885 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
886 int32_t prod = a->s16[i] * b->s16[i] + 0x00004000;
887 int32_t t = (int32_t)c->s16[i] + (prod >> 15);
888 r->s16[i] = cvtswsh(t, &sat);
889 }
890
891 if (sat) {
892 env->vscr |= (1 << VSCR_SAT);
893 }
894 }
895
896 #define VMINMAX_DO(name, compare, element) \
897 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
898 { \
899 int i; \
900 \
901 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
902 if (a->element[i] compare b->element[i]) { \
903 r->element[i] = b->element[i]; \
904 } else { \
905 r->element[i] = a->element[i]; \
906 } \
907 } \
908 }
909 #define VMINMAX(suffix, element) \
910 VMINMAX_DO(min##suffix, >, element) \
911 VMINMAX_DO(max##suffix, <, element)
912 VMINMAX(sb, s8)
913 VMINMAX(sh, s16)
914 VMINMAX(sw, s32)
915 VMINMAX(sd, s64)
916 VMINMAX(ub, u8)
917 VMINMAX(uh, u16)
918 VMINMAX(uw, u32)
919 VMINMAX(ud, u64)
920 #undef VMINMAX_DO
921 #undef VMINMAX
922
923 void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
924 {
925 int i;
926
927 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
928 int32_t prod = a->s16[i] * b->s16[i];
929 r->s16[i] = (int16_t) (prod + c->s16[i]);
930 }
931 }
932
933 #define VMRG_DO(name, element, highp) \
934 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
935 { \
936 ppc_avr_t result; \
937 int i; \
938 size_t n_elems = ARRAY_SIZE(r->element); \
939 \
940 for (i = 0; i < n_elems / 2; i++) { \
941 if (highp) { \
942 result.element[i*2+HI_IDX] = a->element[i]; \
943 result.element[i*2+LO_IDX] = b->element[i]; \
944 } else { \
945 result.element[n_elems - i * 2 - (1 + HI_IDX)] = \
946 b->element[n_elems - i - 1]; \
947 result.element[n_elems - i * 2 - (1 + LO_IDX)] = \
948 a->element[n_elems - i - 1]; \
949 } \
950 } \
951 *r = result; \
952 }
953 #if defined(HOST_WORDS_BIGENDIAN)
954 #define MRGHI 0
955 #define MRGLO 1
956 #else
957 #define MRGHI 1
958 #define MRGLO 0
959 #endif
960 #define VMRG(suffix, element) \
961 VMRG_DO(mrgl##suffix, element, MRGHI) \
962 VMRG_DO(mrgh##suffix, element, MRGLO)
963 VMRG(b, u8)
964 VMRG(h, u16)
965 VMRG(w, u32)
966 #undef VMRG_DO
967 #undef VMRG
968 #undef MRGHI
969 #undef MRGLO
970
971 void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
972 ppc_avr_t *b, ppc_avr_t *c)
973 {
974 int32_t prod[16];
975 int i;
976
977 for (i = 0; i < ARRAY_SIZE(r->s8); i++) {
978 prod[i] = (int32_t)a->s8[i] * b->u8[i];
979 }
980
981 VECTOR_FOR_INORDER_I(i, s32) {
982 r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] +
983 prod[4 * i + 2] + prod[4 * i + 3];
984 }
985 }
986
987 void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
988 ppc_avr_t *b, ppc_avr_t *c)
989 {
990 int32_t prod[8];
991 int i;
992
993 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
994 prod[i] = a->s16[i] * b->s16[i];
995 }
996
997 VECTOR_FOR_INORDER_I(i, s32) {
998 r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1];
999 }
1000 }
1001
1002 void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1003 ppc_avr_t *b, ppc_avr_t *c)
1004 {
1005 int32_t prod[8];
1006 int i;
1007 int sat = 0;
1008
1009 for (i = 0; i < ARRAY_SIZE(r->s16); i++) {
1010 prod[i] = (int32_t)a->s16[i] * b->s16[i];
1011 }
1012
1013 VECTOR_FOR_INORDER_I(i, s32) {
1014 int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1];
1015
1016 r->u32[i] = cvtsdsw(t, &sat);
1017 }
1018
1019 if (sat) {
1020 env->vscr |= (1 << VSCR_SAT);
1021 }
1022 }
1023
1024 void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1025 ppc_avr_t *b, ppc_avr_t *c)
1026 {
1027 uint16_t prod[16];
1028 int i;
1029
1030 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1031 prod[i] = a->u8[i] * b->u8[i];
1032 }
1033
1034 VECTOR_FOR_INORDER_I(i, u32) {
1035 r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] +
1036 prod[4 * i + 2] + prod[4 * i + 3];
1037 }
1038 }
1039
1040 void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1041 ppc_avr_t *b, ppc_avr_t *c)
1042 {
1043 uint32_t prod[8];
1044 int i;
1045
1046 for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
1047 prod[i] = a->u16[i] * b->u16[i];
1048 }
1049
1050 VECTOR_FOR_INORDER_I(i, u32) {
1051 r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1];
1052 }
1053 }
1054
1055 void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a,
1056 ppc_avr_t *b, ppc_avr_t *c)
1057 {
1058 uint32_t prod[8];
1059 int i;
1060 int sat = 0;
1061
1062 for (i = 0; i < ARRAY_SIZE(r->u16); i++) {
1063 prod[i] = a->u16[i] * b->u16[i];
1064 }
1065
1066 VECTOR_FOR_INORDER_I(i, s32) {
1067 uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1];
1068
1069 r->u32[i] = cvtuduw(t, &sat);
1070 }
1071
1072 if (sat) {
1073 env->vscr |= (1 << VSCR_SAT);
1074 }
1075 }
1076
1077 #define VMUL_DO(name, mul_element, prod_element, cast, evenp) \
1078 void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1079 { \
1080 int i; \
1081 \
1082 VECTOR_FOR_INORDER_I(i, prod_element) { \
1083 if (evenp) { \
1084 r->prod_element[i] = \
1085 (cast)a->mul_element[i * 2 + HI_IDX] * \
1086 (cast)b->mul_element[i * 2 + HI_IDX]; \
1087 } else { \
1088 r->prod_element[i] = \
1089 (cast)a->mul_element[i * 2 + LO_IDX] * \
1090 (cast)b->mul_element[i * 2 + LO_IDX]; \
1091 } \
1092 } \
1093 }
1094 #define VMUL(suffix, mul_element, prod_element, cast) \
1095 VMUL_DO(mule##suffix, mul_element, prod_element, cast, 1) \
1096 VMUL_DO(mulo##suffix, mul_element, prod_element, cast, 0)
1097 VMUL(sb, s8, s16, int16_t)
1098 VMUL(sh, s16, s32, int32_t)
1099 VMUL(sw, s32, s64, int64_t)
1100 VMUL(ub, u8, u16, uint16_t)
1101 VMUL(uh, u16, u32, uint32_t)
1102 VMUL(uw, u32, u64, uint64_t)
1103 #undef VMUL_DO
1104 #undef VMUL
1105
1106 void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1107 ppc_avr_t *c)
1108 {
1109 ppc_avr_t result;
1110 int i;
1111
1112 VECTOR_FOR_INORDER_I(i, u8) {
1113 int s = c->u8[i] & 0x1f;
1114 #if defined(HOST_WORDS_BIGENDIAN)
1115 int index = s & 0xf;
1116 #else
1117 int index = 15 - (s & 0xf);
1118 #endif
1119
1120 if (s & 0x10) {
1121 result.u8[i] = b->u8[index];
1122 } else {
1123 result.u8[i] = a->u8[index];
1124 }
1125 }
1126 *r = result;
1127 }
1128
1129 #if defined(HOST_WORDS_BIGENDIAN)
1130 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)])
1131 #define VBPERMQ_DW(index) (((index) & 0x40) != 0)
1132 #else
1133 #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15-(i)])
1134 #define VBPERMQ_DW(index) (((index) & 0x40) == 0)
1135 #endif
1136
1137 void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1138 {
1139 int i;
1140 uint64_t perm = 0;
1141
1142 VECTOR_FOR_INORDER_I(i, u8) {
1143 int index = VBPERMQ_INDEX(b, i);
1144
1145 if (index < 128) {
1146 uint64_t mask = (1ull << (63-(index & 0x3F)));
1147 if (a->u64[VBPERMQ_DW(index)] & mask) {
1148 perm |= (0x8000 >> i);
1149 }
1150 }
1151 }
1152
1153 r->u64[HI_IDX] = perm;
1154 r->u64[LO_IDX] = 0;
1155 }
1156
1157 #undef VBPERMQ_INDEX
1158 #undef VBPERMQ_DW
1159
1160 static const uint64_t VGBBD_MASKS[256] = {
1161 0x0000000000000000ull, /* 00 */
1162 0x0000000000000080ull, /* 01 */
1163 0x0000000000008000ull, /* 02 */
1164 0x0000000000008080ull, /* 03 */
1165 0x0000000000800000ull, /* 04 */
1166 0x0000000000800080ull, /* 05 */
1167 0x0000000000808000ull, /* 06 */
1168 0x0000000000808080ull, /* 07 */
1169 0x0000000080000000ull, /* 08 */
1170 0x0000000080000080ull, /* 09 */
1171 0x0000000080008000ull, /* 0A */
1172 0x0000000080008080ull, /* 0B */
1173 0x0000000080800000ull, /* 0C */
1174 0x0000000080800080ull, /* 0D */
1175 0x0000000080808000ull, /* 0E */
1176 0x0000000080808080ull, /* 0F */
1177 0x0000008000000000ull, /* 10 */
1178 0x0000008000000080ull, /* 11 */
1179 0x0000008000008000ull, /* 12 */
1180 0x0000008000008080ull, /* 13 */
1181 0x0000008000800000ull, /* 14 */
1182 0x0000008000800080ull, /* 15 */
1183 0x0000008000808000ull, /* 16 */
1184 0x0000008000808080ull, /* 17 */
1185 0x0000008080000000ull, /* 18 */
1186 0x0000008080000080ull, /* 19 */
1187 0x0000008080008000ull, /* 1A */
1188 0x0000008080008080ull, /* 1B */
1189 0x0000008080800000ull, /* 1C */
1190 0x0000008080800080ull, /* 1D */
1191 0x0000008080808000ull, /* 1E */
1192 0x0000008080808080ull, /* 1F */
1193 0x0000800000000000ull, /* 20 */
1194 0x0000800000000080ull, /* 21 */
1195 0x0000800000008000ull, /* 22 */
1196 0x0000800000008080ull, /* 23 */
1197 0x0000800000800000ull, /* 24 */
1198 0x0000800000800080ull, /* 25 */
1199 0x0000800000808000ull, /* 26 */
1200 0x0000800000808080ull, /* 27 */
1201 0x0000800080000000ull, /* 28 */
1202 0x0000800080000080ull, /* 29 */
1203 0x0000800080008000ull, /* 2A */
1204 0x0000800080008080ull, /* 2B */
1205 0x0000800080800000ull, /* 2C */
1206 0x0000800080800080ull, /* 2D */
1207 0x0000800080808000ull, /* 2E */
1208 0x0000800080808080ull, /* 2F */
1209 0x0000808000000000ull, /* 30 */
1210 0x0000808000000080ull, /* 31 */
1211 0x0000808000008000ull, /* 32 */
1212 0x0000808000008080ull, /* 33 */
1213 0x0000808000800000ull, /* 34 */
1214 0x0000808000800080ull, /* 35 */
1215 0x0000808000808000ull, /* 36 */
1216 0x0000808000808080ull, /* 37 */
1217 0x0000808080000000ull, /* 38 */
1218 0x0000808080000080ull, /* 39 */
1219 0x0000808080008000ull, /* 3A */
1220 0x0000808080008080ull, /* 3B */
1221 0x0000808080800000ull, /* 3C */
1222 0x0000808080800080ull, /* 3D */
1223 0x0000808080808000ull, /* 3E */
1224 0x0000808080808080ull, /* 3F */
1225 0x0080000000000000ull, /* 40 */
1226 0x0080000000000080ull, /* 41 */
1227 0x0080000000008000ull, /* 42 */
1228 0x0080000000008080ull, /* 43 */
1229 0x0080000000800000ull, /* 44 */
1230 0x0080000000800080ull, /* 45 */
1231 0x0080000000808000ull, /* 46 */
1232 0x0080000000808080ull, /* 47 */
1233 0x0080000080000000ull, /* 48 */
1234 0x0080000080000080ull, /* 49 */
1235 0x0080000080008000ull, /* 4A */
1236 0x0080000080008080ull, /* 4B */
1237 0x0080000080800000ull, /* 4C */
1238 0x0080000080800080ull, /* 4D */
1239 0x0080000080808000ull, /* 4E */
1240 0x0080000080808080ull, /* 4F */
1241 0x0080008000000000ull, /* 50 */
1242 0x0080008000000080ull, /* 51 */
1243 0x0080008000008000ull, /* 52 */
1244 0x0080008000008080ull, /* 53 */
1245 0x0080008000800000ull, /* 54 */
1246 0x0080008000800080ull, /* 55 */
1247 0x0080008000808000ull, /* 56 */
1248 0x0080008000808080ull, /* 57 */
1249 0x0080008080000000ull, /* 58 */
1250 0x0080008080000080ull, /* 59 */
1251 0x0080008080008000ull, /* 5A */
1252 0x0080008080008080ull, /* 5B */
1253 0x0080008080800000ull, /* 5C */
1254 0x0080008080800080ull, /* 5D */
1255 0x0080008080808000ull, /* 5E */
1256 0x0080008080808080ull, /* 5F */
1257 0x0080800000000000ull, /* 60 */
1258 0x0080800000000080ull, /* 61 */
1259 0x0080800000008000ull, /* 62 */
1260 0x0080800000008080ull, /* 63 */
1261 0x0080800000800000ull, /* 64 */
1262 0x0080800000800080ull, /* 65 */
1263 0x0080800000808000ull, /* 66 */
1264 0x0080800000808080ull, /* 67 */
1265 0x0080800080000000ull, /* 68 */
1266 0x0080800080000080ull, /* 69 */
1267 0x0080800080008000ull, /* 6A */
1268 0x0080800080008080ull, /* 6B */
1269 0x0080800080800000ull, /* 6C */
1270 0x0080800080800080ull, /* 6D */
1271 0x0080800080808000ull, /* 6E */
1272 0x0080800080808080ull, /* 6F */
1273 0x0080808000000000ull, /* 70 */
1274 0x0080808000000080ull, /* 71 */
1275 0x0080808000008000ull, /* 72 */
1276 0x0080808000008080ull, /* 73 */
1277 0x0080808000800000ull, /* 74 */
1278 0x0080808000800080ull, /* 75 */
1279 0x0080808000808000ull, /* 76 */
1280 0x0080808000808080ull, /* 77 */
1281 0x0080808080000000ull, /* 78 */
1282 0x0080808080000080ull, /* 79 */
1283 0x0080808080008000ull, /* 7A */
1284 0x0080808080008080ull, /* 7B */
1285 0x0080808080800000ull, /* 7C */
1286 0x0080808080800080ull, /* 7D */
1287 0x0080808080808000ull, /* 7E */
1288 0x0080808080808080ull, /* 7F */
1289 0x8000000000000000ull, /* 80 */
1290 0x8000000000000080ull, /* 81 */
1291 0x8000000000008000ull, /* 82 */
1292 0x8000000000008080ull, /* 83 */
1293 0x8000000000800000ull, /* 84 */
1294 0x8000000000800080ull, /* 85 */
1295 0x8000000000808000ull, /* 86 */
1296 0x8000000000808080ull, /* 87 */
1297 0x8000000080000000ull, /* 88 */
1298 0x8000000080000080ull, /* 89 */
1299 0x8000000080008000ull, /* 8A */
1300 0x8000000080008080ull, /* 8B */
1301 0x8000000080800000ull, /* 8C */
1302 0x8000000080800080ull, /* 8D */
1303 0x8000000080808000ull, /* 8E */
1304 0x8000000080808080ull, /* 8F */
1305 0x8000008000000000ull, /* 90 */
1306 0x8000008000000080ull, /* 91 */
1307 0x8000008000008000ull, /* 92 */
1308 0x8000008000008080ull, /* 93 */
1309 0x8000008000800000ull, /* 94 */
1310 0x8000008000800080ull, /* 95 */
1311 0x8000008000808000ull, /* 96 */
1312 0x8000008000808080ull, /* 97 */
1313 0x8000008080000000ull, /* 98 */
1314 0x8000008080000080ull, /* 99 */
1315 0x8000008080008000ull, /* 9A */
1316 0x8000008080008080ull, /* 9B */
1317 0x8000008080800000ull, /* 9C */
1318 0x8000008080800080ull, /* 9D */
1319 0x8000008080808000ull, /* 9E */
1320 0x8000008080808080ull, /* 9F */
1321 0x8000800000000000ull, /* A0 */
1322 0x8000800000000080ull, /* A1 */
1323 0x8000800000008000ull, /* A2 */
1324 0x8000800000008080ull, /* A3 */
1325 0x8000800000800000ull, /* A4 */
1326 0x8000800000800080ull, /* A5 */
1327 0x8000800000808000ull, /* A6 */
1328 0x8000800000808080ull, /* A7 */
1329 0x8000800080000000ull, /* A8 */
1330 0x8000800080000080ull, /* A9 */
1331 0x8000800080008000ull, /* AA */
1332 0x8000800080008080ull, /* AB */
1333 0x8000800080800000ull, /* AC */
1334 0x8000800080800080ull, /* AD */
1335 0x8000800080808000ull, /* AE */
1336 0x8000800080808080ull, /* AF */
1337 0x8000808000000000ull, /* B0 */
1338 0x8000808000000080ull, /* B1 */
1339 0x8000808000008000ull, /* B2 */
1340 0x8000808000008080ull, /* B3 */
1341 0x8000808000800000ull, /* B4 */
1342 0x8000808000800080ull, /* B5 */
1343 0x8000808000808000ull, /* B6 */
1344 0x8000808000808080ull, /* B7 */
1345 0x8000808080000000ull, /* B8 */
1346 0x8000808080000080ull, /* B9 */
1347 0x8000808080008000ull, /* BA */
1348 0x8000808080008080ull, /* BB */
1349 0x8000808080800000ull, /* BC */
1350 0x8000808080800080ull, /* BD */
1351 0x8000808080808000ull, /* BE */
1352 0x8000808080808080ull, /* BF */
1353 0x8080000000000000ull, /* C0 */
1354 0x8080000000000080ull, /* C1 */
1355 0x8080000000008000ull, /* C2 */
1356 0x8080000000008080ull, /* C3 */
1357 0x8080000000800000ull, /* C4 */
1358 0x8080000000800080ull, /* C5 */
1359 0x8080000000808000ull, /* C6 */
1360 0x8080000000808080ull, /* C7 */
1361 0x8080000080000000ull, /* C8 */
1362 0x8080000080000080ull, /* C9 */
1363 0x8080000080008000ull, /* CA */
1364 0x8080000080008080ull, /* CB */
1365 0x8080000080800000ull, /* CC */
1366 0x8080000080800080ull, /* CD */
1367 0x8080000080808000ull, /* CE */
1368 0x8080000080808080ull, /* CF */
1369 0x8080008000000000ull, /* D0 */
1370 0x8080008000000080ull, /* D1 */
1371 0x8080008000008000ull, /* D2 */
1372 0x8080008000008080ull, /* D3 */
1373 0x8080008000800000ull, /* D4 */
1374 0x8080008000800080ull, /* D5 */
1375 0x8080008000808000ull, /* D6 */
1376 0x8080008000808080ull, /* D7 */
1377 0x8080008080000000ull, /* D8 */
1378 0x8080008080000080ull, /* D9 */
1379 0x8080008080008000ull, /* DA */
1380 0x8080008080008080ull, /* DB */
1381 0x8080008080800000ull, /* DC */
1382 0x8080008080800080ull, /* DD */
1383 0x8080008080808000ull, /* DE */
1384 0x8080008080808080ull, /* DF */
1385 0x8080800000000000ull, /* E0 */
1386 0x8080800000000080ull, /* E1 */
1387 0x8080800000008000ull, /* E2 */
1388 0x8080800000008080ull, /* E3 */
1389 0x8080800000800000ull, /* E4 */
1390 0x8080800000800080ull, /* E5 */
1391 0x8080800000808000ull, /* E6 */
1392 0x8080800000808080ull, /* E7 */
1393 0x8080800080000000ull, /* E8 */
1394 0x8080800080000080ull, /* E9 */
1395 0x8080800080008000ull, /* EA */
1396 0x8080800080008080ull, /* EB */
1397 0x8080800080800000ull, /* EC */
1398 0x8080800080800080ull, /* ED */
1399 0x8080800080808000ull, /* EE */
1400 0x8080800080808080ull, /* EF */
1401 0x8080808000000000ull, /* F0 */
1402 0x8080808000000080ull, /* F1 */
1403 0x8080808000008000ull, /* F2 */
1404 0x8080808000008080ull, /* F3 */
1405 0x8080808000800000ull, /* F4 */
1406 0x8080808000800080ull, /* F5 */
1407 0x8080808000808000ull, /* F6 */
1408 0x8080808000808080ull, /* F7 */
1409 0x8080808080000000ull, /* F8 */
1410 0x8080808080000080ull, /* F9 */
1411 0x8080808080008000ull, /* FA */
1412 0x8080808080008080ull, /* FB */
1413 0x8080808080800000ull, /* FC */
1414 0x8080808080800080ull, /* FD */
1415 0x8080808080808000ull, /* FE */
1416 0x8080808080808080ull, /* FF */
1417 };
1418
1419 void helper_vgbbd(ppc_avr_t *r, ppc_avr_t *b)
1420 {
1421 int i;
1422 uint64_t t[2] = { 0, 0 };
1423
1424 VECTOR_FOR_INORDER_I(i, u8) {
1425 #if defined(HOST_WORDS_BIGENDIAN)
1426 t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (i & 7);
1427 #else
1428 t[i>>3] |= VGBBD_MASKS[b->u8[i]] >> (7-(i & 7));
1429 #endif
1430 }
1431
1432 r->u64[0] = t[0];
1433 r->u64[1] = t[1];
1434 }
1435
1436 #define PMSUM(name, srcfld, trgfld, trgtyp) \
1437 void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1438 { \
1439 int i, j; \
1440 trgtyp prod[sizeof(ppc_avr_t)/sizeof(a->srcfld[0])]; \
1441 \
1442 VECTOR_FOR_INORDER_I(i, srcfld) { \
1443 prod[i] = 0; \
1444 for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \
1445 if (a->srcfld[i] & (1ull<<j)) { \
1446 prod[i] ^= ((trgtyp)b->srcfld[i] << j); \
1447 } \
1448 } \
1449 } \
1450 \
1451 VECTOR_FOR_INORDER_I(i, trgfld) { \
1452 r->trgfld[i] = prod[2*i] ^ prod[2*i+1]; \
1453 } \
1454 }
1455
1456 PMSUM(vpmsumb, u8, u16, uint16_t)
1457 PMSUM(vpmsumh, u16, u32, uint32_t)
1458 PMSUM(vpmsumw, u32, u64, uint64_t)
1459
1460 void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1461 {
1462
1463 #ifdef CONFIG_INT128
1464 int i, j;
1465 __uint128_t prod[2];
1466
1467 VECTOR_FOR_INORDER_I(i, u64) {
1468 prod[i] = 0;
1469 for (j = 0; j < 64; j++) {
1470 if (a->u64[i] & (1ull<<j)) {
1471 prod[i] ^= (((__uint128_t)b->u64[i]) << j);
1472 }
1473 }
1474 }
1475
1476 r->u128 = prod[0] ^ prod[1];
1477
1478 #else
1479 int i, j;
1480 ppc_avr_t prod[2];
1481
1482 VECTOR_FOR_INORDER_I(i, u64) {
1483 prod[i].u64[LO_IDX] = prod[i].u64[HI_IDX] = 0;
1484 for (j = 0; j < 64; j++) {
1485 if (a->u64[i] & (1ull<<j)) {
1486 ppc_avr_t bshift;
1487 if (j == 0) {
1488 bshift.u64[HI_IDX] = 0;
1489 bshift.u64[LO_IDX] = b->u64[i];
1490 } else {
1491 bshift.u64[HI_IDX] = b->u64[i] >> (64-j);
1492 bshift.u64[LO_IDX] = b->u64[i] << j;
1493 }
1494 prod[i].u64[LO_IDX] ^= bshift.u64[LO_IDX];
1495 prod[i].u64[HI_IDX] ^= bshift.u64[HI_IDX];
1496 }
1497 }
1498 }
1499
1500 r->u64[LO_IDX] = prod[0].u64[LO_IDX] ^ prod[1].u64[LO_IDX];
1501 r->u64[HI_IDX] = prod[0].u64[HI_IDX] ^ prod[1].u64[HI_IDX];
1502 #endif
1503 }
1504
1505
1506 #if defined(HOST_WORDS_BIGENDIAN)
1507 #define PKBIG 1
1508 #else
1509 #define PKBIG 0
1510 #endif
1511 void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1512 {
1513 int i, j;
1514 ppc_avr_t result;
1515 #if defined(HOST_WORDS_BIGENDIAN)
1516 const ppc_avr_t *x[2] = { a, b };
1517 #else
1518 const ppc_avr_t *x[2] = { b, a };
1519 #endif
1520
1521 VECTOR_FOR_INORDER_I(i, u64) {
1522 VECTOR_FOR_INORDER_I(j, u32) {
1523 uint32_t e = x[i]->u32[j];
1524
1525 result.u16[4*i+j] = (((e >> 9) & 0xfc00) |
1526 ((e >> 6) & 0x3e0) |
1527 ((e >> 3) & 0x1f));
1528 }
1529 }
1530 *r = result;
1531 }
1532
1533 #define VPK(suffix, from, to, cvt, dosat) \
1534 void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \
1535 ppc_avr_t *a, ppc_avr_t *b) \
1536 { \
1537 int i; \
1538 int sat = 0; \
1539 ppc_avr_t result; \
1540 ppc_avr_t *a0 = PKBIG ? a : b; \
1541 ppc_avr_t *a1 = PKBIG ? b : a; \
1542 \
1543 VECTOR_FOR_INORDER_I(i, from) { \
1544 result.to[i] = cvt(a0->from[i], &sat); \
1545 result.to[i+ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat); \
1546 } \
1547 *r = result; \
1548 if (dosat && sat) { \
1549 env->vscr |= (1 << VSCR_SAT); \
1550 } \
1551 }
1552 #define I(x, y) (x)
1553 VPK(shss, s16, s8, cvtshsb, 1)
1554 VPK(shus, s16, u8, cvtshub, 1)
1555 VPK(swss, s32, s16, cvtswsh, 1)
1556 VPK(swus, s32, u16, cvtswuh, 1)
1557 VPK(sdss, s64, s32, cvtsdsw, 1)
1558 VPK(sdus, s64, u32, cvtsduw, 1)
1559 VPK(uhus, u16, u8, cvtuhub, 1)
1560 VPK(uwus, u32, u16, cvtuwuh, 1)
1561 VPK(udus, u64, u32, cvtuduw, 1)
1562 VPK(uhum, u16, u8, I, 0)
1563 VPK(uwum, u32, u16, I, 0)
1564 VPK(udum, u64, u32, I, 0)
1565 #undef I
1566 #undef VPK
1567 #undef PKBIG
1568
1569 void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1570 {
1571 int i;
1572
1573 for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1574 r->f[i] = float32_div(float32_one, b->f[i], &env->vec_status);
1575 }
1576 }
1577
1578 #define VRFI(suffix, rounding) \
1579 void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \
1580 ppc_avr_t *b) \
1581 { \
1582 int i; \
1583 float_status s = env->vec_status; \
1584 \
1585 set_float_rounding_mode(rounding, &s); \
1586 for (i = 0; i < ARRAY_SIZE(r->f); i++) { \
1587 r->f[i] = float32_round_to_int (b->f[i], &s); \
1588 } \
1589 }
1590 VRFI(n, float_round_nearest_even)
1591 VRFI(m, float_round_down)
1592 VRFI(p, float_round_up)
1593 VRFI(z, float_round_to_zero)
1594 #undef VRFI
1595
1596 #define VROTATE(suffix, element, mask) \
1597 void helper_vrl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1598 { \
1599 int i; \
1600 \
1601 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1602 unsigned int shift = b->element[i] & mask; \
1603 r->element[i] = (a->element[i] << shift) | \
1604 (a->element[i] >> (sizeof(a->element[0]) * 8 - shift)); \
1605 } \
1606 }
1607 VROTATE(b, u8, 0x7)
1608 VROTATE(h, u16, 0xF)
1609 VROTATE(w, u32, 0x1F)
1610 VROTATE(d, u64, 0x3F)
1611 #undef VROTATE
1612
1613 void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1614 {
1615 int i;
1616
1617 for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1618 float32 t = float32_sqrt(b->f[i], &env->vec_status);
1619
1620 r->f[i] = float32_div(float32_one, t, &env->vec_status);
1621 }
1622 }
1623
1624 void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b,
1625 ppc_avr_t *c)
1626 {
1627 r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]);
1628 r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]);
1629 }
1630
1631 void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1632 {
1633 int i;
1634
1635 for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1636 r->f[i] = float32_exp2(b->f[i], &env->vec_status);
1637 }
1638 }
1639
1640 void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b)
1641 {
1642 int i;
1643
1644 for (i = 0; i < ARRAY_SIZE(r->f); i++) {
1645 r->f[i] = float32_log2(b->f[i], &env->vec_status);
1646 }
1647 }
1648
1649 /* The specification says that the results are undefined if all of the
1650 * shift counts are not identical. We check to make sure that they are
1651 * to conform to what real hardware appears to do. */
1652 #define VSHIFT(suffix, leftp) \
1653 void helper_vs##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1654 { \
1655 int shift = b->u8[LO_IDX*15] & 0x7; \
1656 int doit = 1; \
1657 int i; \
1658 \
1659 for (i = 0; i < ARRAY_SIZE(r->u8); i++) { \
1660 doit = doit && ((b->u8[i] & 0x7) == shift); \
1661 } \
1662 if (doit) { \
1663 if (shift == 0) { \
1664 *r = *a; \
1665 } else if (leftp) { \
1666 uint64_t carry = a->u64[LO_IDX] >> (64 - shift); \
1667 \
1668 r->u64[HI_IDX] = (a->u64[HI_IDX] << shift) | carry; \
1669 r->u64[LO_IDX] = a->u64[LO_IDX] << shift; \
1670 } else { \
1671 uint64_t carry = a->u64[HI_IDX] << (64 - shift); \
1672 \
1673 r->u64[LO_IDX] = (a->u64[LO_IDX] >> shift) | carry; \
1674 r->u64[HI_IDX] = a->u64[HI_IDX] >> shift; \
1675 } \
1676 } \
1677 }
1678 VSHIFT(l, 1)
1679 VSHIFT(r, 0)
1680 #undef VSHIFT
1681
1682 #define VSL(suffix, element, mask) \
1683 void helper_vsl##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1684 { \
1685 int i; \
1686 \
1687 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1688 unsigned int shift = b->element[i] & mask; \
1689 \
1690 r->element[i] = a->element[i] << shift; \
1691 } \
1692 }
1693 VSL(b, u8, 0x7)
1694 VSL(h, u16, 0x0F)
1695 VSL(w, u32, 0x1F)
1696 VSL(d, u64, 0x3F)
1697 #undef VSL
1698
1699 void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1700 {
1701 int i;
1702 unsigned int shift, bytes, size;
1703
1704 size = ARRAY_SIZE(r->u8);
1705 for (i = 0; i < size; i++) {
1706 shift = b->u8[i] & 0x7; /* extract shift value */
1707 bytes = (a->u8[i] << 8) + /* extract adjacent bytes */
1708 (((i + 1) < size) ? a->u8[i + 1] : 0);
1709 r->u8[i] = (bytes << shift) >> 8; /* shift and store result */
1710 }
1711 }
1712
1713 void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1714 {
1715 int i;
1716 unsigned int shift, bytes;
1717
1718 /* Use reverse order, as destination and source register can be same. Its
1719 * being modified in place saving temporary, reverse order will guarantee
1720 * that computed result is not fed back.
1721 */
1722 for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
1723 shift = b->u8[i] & 0x7; /* extract shift value */
1724 bytes = ((i ? a->u8[i - 1] : 0) << 8) + a->u8[i];
1725 /* extract adjacent bytes */
1726 r->u8[i] = (bytes >> shift) & 0xFF; /* shift and store result */
1727 }
1728 }
1729
1730 void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
1731 {
1732 int sh = shift & 0xf;
1733 int i;
1734 ppc_avr_t result;
1735
1736 #if defined(HOST_WORDS_BIGENDIAN)
1737 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1738 int index = sh + i;
1739 if (index > 0xf) {
1740 result.u8[i] = b->u8[index - 0x10];
1741 } else {
1742 result.u8[i] = a->u8[index];
1743 }
1744 }
1745 #else
1746 for (i = 0; i < ARRAY_SIZE(r->u8); i++) {
1747 int index = (16 - sh) + i;
1748 if (index > 0xf) {
1749 result.u8[i] = a->u8[index - 0x10];
1750 } else {
1751 result.u8[i] = b->u8[index];
1752 }
1753 }
1754 #endif
1755 *r = result;
1756 }
1757
1758 void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1759 {
1760 int sh = (b->u8[LO_IDX*0xf] >> 3) & 0xf;
1761
1762 #if defined(HOST_WORDS_BIGENDIAN)
1763 memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1764 memset(&r->u8[16-sh], 0, sh);
1765 #else
1766 memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1767 memset(&r->u8[0], 0, sh);
1768 #endif
1769 }
1770
1771 /* Experimental testing shows that hardware masks the immediate. */
1772 #define _SPLAT_MASKED(element) (splat & (ARRAY_SIZE(r->element) - 1))
1773 #if defined(HOST_WORDS_BIGENDIAN)
1774 #define SPLAT_ELEMENT(element) _SPLAT_MASKED(element)
1775 #else
1776 #define SPLAT_ELEMENT(element) \
1777 (ARRAY_SIZE(r->element) - 1 - _SPLAT_MASKED(element))
1778 #endif
1779 #define VSPLT(suffix, element) \
1780 void helper_vsplt##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t splat) \
1781 { \
1782 uint32_t s = b->element[SPLAT_ELEMENT(element)]; \
1783 int i; \
1784 \
1785 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1786 r->element[i] = s; \
1787 } \
1788 }
1789 VSPLT(b, u8)
1790 VSPLT(h, u16)
1791 VSPLT(w, u32)
1792 #undef VSPLT
1793 #undef SPLAT_ELEMENT
1794 #undef _SPLAT_MASKED
1795 #if defined(HOST_WORDS_BIGENDIAN)
1796 #define VINSERT(suffix, element) \
1797 void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1798 { \
1799 memmove(&r->u8[index], &b->u8[8 - sizeof(r->element)], \
1800 sizeof(r->element[0])); \
1801 }
1802 #else
1803 #define VINSERT(suffix, element) \
1804 void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1805 { \
1806 uint32_t d = (16 - index) - sizeof(r->element[0]); \
1807 memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0])); \
1808 }
1809 #endif
1810 VINSERT(b, u8)
1811 VINSERT(h, u16)
1812 VINSERT(w, u32)
1813 VINSERT(d, u64)
1814 #undef VINSERT
1815 #if defined(HOST_WORDS_BIGENDIAN)
1816 #define VEXTRACT(suffix, element) \
1817 void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1818 { \
1819 uint32_t es = sizeof(r->element[0]); \
1820 memmove(&r->u8[8 - es], &b->u8[index], es); \
1821 memset(&r->u8[8], 0, 8); \
1822 memset(&r->u8[0], 0, 8 - es); \
1823 }
1824 #else
1825 #define VEXTRACT(suffix, element) \
1826 void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \
1827 { \
1828 uint32_t es = sizeof(r->element[0]); \
1829 uint32_t s = (16 - index) - es; \
1830 memmove(&r->u8[8], &b->u8[s], es); \
1831 memset(&r->u8[0], 0, 8); \
1832 memset(&r->u8[8 + es], 0, 8 - es); \
1833 }
1834 #endif
1835 VEXTRACT(ub, u8)
1836 VEXTRACT(uh, u16)
1837 VEXTRACT(uw, u32)
1838 VEXTRACT(d, u64)
1839 #undef VEXTRACT
1840
1841 #define VSPLTI(suffix, element, splat_type) \
1842 void helper_vspltis##suffix(ppc_avr_t *r, uint32_t splat) \
1843 { \
1844 splat_type x = (int8_t)(splat << 3) >> 3; \
1845 int i; \
1846 \
1847 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1848 r->element[i] = x; \
1849 } \
1850 }
1851 VSPLTI(b, s8, int8_t)
1852 VSPLTI(h, s16, int16_t)
1853 VSPLTI(w, s32, int32_t)
1854 #undef VSPLTI
1855
1856 #define VSR(suffix, element, mask) \
1857 void helper_vsr##suffix(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
1858 { \
1859 int i; \
1860 \
1861 for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
1862 unsigned int shift = b->element[i] & mask; \
1863 r->element[i] = a->element[i] >> shift; \
1864 } \
1865 }
1866 VSR(ab, s8, 0x7)
1867 VSR(ah, s16, 0xF)
1868 VSR(aw, s32, 0x1F)
1869 VSR(ad, s64, 0x3F)
1870 VSR(b, u8, 0x7)
1871 VSR(h, u16, 0xF)
1872 VSR(w, u32, 0x1F)
1873 VSR(d, u64, 0x3F)
1874 #undef VSR
1875
1876 void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1877 {
1878 int sh = (b->u8[LO_IDX * 0xf] >> 3) & 0xf;
1879
1880 #if defined(HOST_WORDS_BIGENDIAN)
1881 memmove(&r->u8[sh], &a->u8[0], 16 - sh);
1882 memset(&r->u8[0], 0, sh);
1883 #else
1884 memmove(&r->u8[0], &a->u8[sh], 16 - sh);
1885 memset(&r->u8[16 - sh], 0, sh);
1886 #endif
1887 }
1888
1889 void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1890 {
1891 int i;
1892
1893 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1894 r->u32[i] = a->u32[i] >= b->u32[i];
1895 }
1896 }
1897
1898 void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1899 {
1900 int64_t t;
1901 int i, upper;
1902 ppc_avr_t result;
1903 int sat = 0;
1904
1905 #if defined(HOST_WORDS_BIGENDIAN)
1906 upper = ARRAY_SIZE(r->s32)-1;
1907 #else
1908 upper = 0;
1909 #endif
1910 t = (int64_t)b->s32[upper];
1911 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1912 t += a->s32[i];
1913 result.s32[i] = 0;
1914 }
1915 result.s32[upper] = cvtsdsw(t, &sat);
1916 *r = result;
1917
1918 if (sat) {
1919 env->vscr |= (1 << VSCR_SAT);
1920 }
1921 }
1922
1923 void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1924 {
1925 int i, j, upper;
1926 ppc_avr_t result;
1927 int sat = 0;
1928
1929 #if defined(HOST_WORDS_BIGENDIAN)
1930 upper = 1;
1931 #else
1932 upper = 0;
1933 #endif
1934 for (i = 0; i < ARRAY_SIZE(r->u64); i++) {
1935 int64_t t = (int64_t)b->s32[upper + i * 2];
1936
1937 result.u64[i] = 0;
1938 for (j = 0; j < ARRAY_SIZE(r->u64); j++) {
1939 t += a->s32[2 * i + j];
1940 }
1941 result.s32[upper + i * 2] = cvtsdsw(t, &sat);
1942 }
1943
1944 *r = result;
1945 if (sat) {
1946 env->vscr |= (1 << VSCR_SAT);
1947 }
1948 }
1949
1950 void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1951 {
1952 int i, j;
1953 int sat = 0;
1954
1955 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1956 int64_t t = (int64_t)b->s32[i];
1957
1958 for (j = 0; j < ARRAY_SIZE(r->s32); j++) {
1959 t += a->s8[4 * i + j];
1960 }
1961 r->s32[i] = cvtsdsw(t, &sat);
1962 }
1963
1964 if (sat) {
1965 env->vscr |= (1 << VSCR_SAT);
1966 }
1967 }
1968
1969 void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1970 {
1971 int sat = 0;
1972 int i;
1973
1974 for (i = 0; i < ARRAY_SIZE(r->s32); i++) {
1975 int64_t t = (int64_t)b->s32[i];
1976
1977 t += a->s16[2 * i] + a->s16[2 * i + 1];
1978 r->s32[i] = cvtsdsw(t, &sat);
1979 }
1980
1981 if (sat) {
1982 env->vscr |= (1 << VSCR_SAT);
1983 }
1984 }
1985
1986 void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
1987 {
1988 int i, j;
1989 int sat = 0;
1990
1991 for (i = 0; i < ARRAY_SIZE(r->u32); i++) {
1992 uint64_t t = (uint64_t)b->u32[i];
1993
1994 for (j = 0; j < ARRAY_SIZE(r->u32); j++) {
1995 t += a->u8[4 * i + j];
1996 }
1997 r->u32[i] = cvtuduw(t, &sat);
1998 }
1999
2000 if (sat) {
2001 env->vscr |= (1 << VSCR_SAT);
2002 }
2003 }
2004
2005 #if defined(HOST_WORDS_BIGENDIAN)
2006 #define UPKHI 1
2007 #define UPKLO 0
2008 #else
2009 #define UPKHI 0
2010 #define UPKLO 1
2011 #endif
2012 #define VUPKPX(suffix, hi) \
2013 void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \
2014 { \
2015 int i; \
2016 ppc_avr_t result; \
2017 \
2018 for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \
2019 uint16_t e = b->u16[hi ? i : i+4]; \
2020 uint8_t a = (e >> 15) ? 0xff : 0; \
2021 uint8_t r = (e >> 10) & 0x1f; \
2022 uint8_t g = (e >> 5) & 0x1f; \
2023 uint8_t b = e & 0x1f; \
2024 \
2025 result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \
2026 } \
2027 *r = result; \
2028 }
2029 VUPKPX(lpx, UPKLO)
2030 VUPKPX(hpx, UPKHI)
2031 #undef VUPKPX
2032
2033 #define VUPK(suffix, unpacked, packee, hi) \
2034 void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \
2035 { \
2036 int i; \
2037 ppc_avr_t result; \
2038 \
2039 if (hi) { \
2040 for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \
2041 result.unpacked[i] = b->packee[i]; \
2042 } \
2043 } else { \
2044 for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \
2045 i++) { \
2046 result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \
2047 } \
2048 } \
2049 *r = result; \
2050 }
2051 VUPK(hsb, s16, s8, UPKHI)
2052 VUPK(hsh, s32, s16, UPKHI)
2053 VUPK(hsw, s64, s32, UPKHI)
2054 VUPK(lsb, s16, s8, UPKLO)
2055 VUPK(lsh, s32, s16, UPKLO)
2056 VUPK(lsw, s64, s32, UPKLO)
2057 #undef VUPK
2058 #undef UPKHI
2059 #undef UPKLO
2060
2061 #define VGENERIC_DO(name, element) \
2062 void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \
2063 { \
2064 int i; \
2065 \
2066 VECTOR_FOR_INORDER_I(i, element) { \
2067 r->element[i] = name(b->element[i]); \
2068 } \
2069 }
2070
2071 #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8)
2072 #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16)
2073 #define clzw(v) clz32((v))
2074 #define clzd(v) clz64((v))
2075
2076 VGENERIC_DO(clzb, u8)
2077 VGENERIC_DO(clzh, u16)
2078 VGENERIC_DO(clzw, u32)
2079 VGENERIC_DO(clzd, u64)
2080
2081 #undef clzb
2082 #undef clzh
2083 #undef clzw
2084 #undef clzd
2085
2086 #define popcntb(v) ctpop8(v)
2087 #define popcnth(v) ctpop16(v)
2088 #define popcntw(v) ctpop32(v)
2089 #define popcntd(v) ctpop64(v)
2090
2091 VGENERIC_DO(popcntb, u8)
2092 VGENERIC_DO(popcnth, u16)
2093 VGENERIC_DO(popcntw, u32)
2094 VGENERIC_DO(popcntd, u64)
2095
2096 #undef popcntb
2097 #undef popcnth
2098 #undef popcntw
2099 #undef popcntd
2100
2101 #undef VGENERIC_DO
2102
2103 #if defined(HOST_WORDS_BIGENDIAN)
2104 #define QW_ONE { .u64 = { 0, 1 } }
2105 #else
2106 #define QW_ONE { .u64 = { 1, 0 } }
2107 #endif
2108
2109 #ifndef CONFIG_INT128
2110
2111 static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a)
2112 {
2113 t->u64[0] = ~a.u64[0];
2114 t->u64[1] = ~a.u64[1];
2115 }
2116
2117 static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b)
2118 {
2119 if (a.u64[HI_IDX] < b.u64[HI_IDX]) {
2120 return -1;
2121 } else if (a.u64[HI_IDX] > b.u64[HI_IDX]) {
2122 return 1;
2123 } else if (a.u64[LO_IDX] < b.u64[LO_IDX]) {
2124 return -1;
2125 } else if (a.u64[LO_IDX] > b.u64[LO_IDX]) {
2126 return 1;
2127 } else {
2128 return 0;
2129 }
2130 }
2131
2132 static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
2133 {
2134 t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX];
2135 t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] +
2136 (~a.u64[LO_IDX] < b.u64[LO_IDX]);
2137 }
2138
2139 static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b)
2140 {
2141 ppc_avr_t not_a;
2142 t->u64[LO_IDX] = a.u64[LO_IDX] + b.u64[LO_IDX];
2143 t->u64[HI_IDX] = a.u64[HI_IDX] + b.u64[HI_IDX] +
2144 (~a.u64[LO_IDX] < b.u64[LO_IDX]);
2145 avr_qw_not(&not_a, a);
2146 return avr_qw_cmpu(not_a, b) < 0;
2147 }
2148
2149 #endif
2150
2151 void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2152 {
2153 #ifdef CONFIG_INT128
2154 r->u128 = a->u128 + b->u128;
2155 #else
2156 avr_qw_add(r, *a, *b);
2157 #endif
2158 }
2159
2160 void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2161 {
2162 #ifdef CONFIG_INT128
2163 r->u128 = a->u128 + b->u128 + (c->u128 & 1);
2164 #else
2165
2166 if (c->u64[LO_IDX] & 1) {
2167 ppc_avr_t tmp;
2168
2169 tmp.u64[HI_IDX] = 0;
2170 tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1;
2171 avr_qw_add(&tmp, *a, tmp);
2172 avr_qw_add(r, tmp, *b);
2173 } else {
2174 avr_qw_add(r, *a, *b);
2175 }
2176 #endif
2177 }
2178
2179 void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2180 {
2181 #ifdef CONFIG_INT128
2182 r->u128 = (~a->u128 < b->u128);
2183 #else
2184 ppc_avr_t not_a;
2185
2186 avr_qw_not(&not_a, *a);
2187
2188 r->u64[HI_IDX] = 0;
2189 r->u64[LO_IDX] = (avr_qw_cmpu(not_a, *b) < 0);
2190 #endif
2191 }
2192
2193 void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2194 {
2195 #ifdef CONFIG_INT128
2196 int carry_out = (~a->u128 < b->u128);
2197 if (!carry_out && (c->u128 & 1)) {
2198 carry_out = ((a->u128 + b->u128 + 1) == 0) &&
2199 ((a->u128 != 0) || (b->u128 != 0));
2200 }
2201 r->u128 = carry_out;
2202 #else
2203
2204 int carry_in = c->u64[LO_IDX] & 1;
2205 int carry_out = 0;
2206 ppc_avr_t tmp;
2207
2208 carry_out = avr_qw_addc(&tmp, *a, *b);
2209
2210 if (!carry_out && carry_in) {
2211 ppc_avr_t one = QW_ONE;
2212 carry_out = avr_qw_addc(&tmp, tmp, one);
2213 }
2214 r->u64[HI_IDX] = 0;
2215 r->u64[LO_IDX] = carry_out;
2216 #endif
2217 }
2218
2219 void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2220 {
2221 #ifdef CONFIG_INT128
2222 r->u128 = a->u128 - b->u128;
2223 #else
2224 ppc_avr_t tmp;
2225 ppc_avr_t one = QW_ONE;
2226
2227 avr_qw_not(&tmp, *b);
2228 avr_qw_add(&tmp, *a, tmp);
2229 avr_qw_add(r, tmp, one);
2230 #endif
2231 }
2232
2233 void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2234 {
2235 #ifdef CONFIG_INT128
2236 r->u128 = a->u128 + ~b->u128 + (c->u128 & 1);
2237 #else
2238 ppc_avr_t tmp, sum;
2239
2240 avr_qw_not(&tmp, *b);
2241 avr_qw_add(&sum, *a, tmp);
2242
2243 tmp.u64[HI_IDX] = 0;
2244 tmp.u64[LO_IDX] = c->u64[LO_IDX] & 1;
2245 avr_qw_add(r, sum, tmp);
2246 #endif
2247 }
2248
2249 void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2250 {
2251 #ifdef CONFIG_INT128
2252 r->u128 = (~a->u128 < ~b->u128) ||
2253 (a->u128 + ~b->u128 == (__uint128_t)-1);
2254 #else
2255 int carry = (avr_qw_cmpu(*a, *b) > 0);
2256 if (!carry) {
2257 ppc_avr_t tmp;
2258 avr_qw_not(&tmp, *b);
2259 avr_qw_add(&tmp, *a, tmp);
2260 carry = ((tmp.s64[HI_IDX] == -1ull) && (tmp.s64[LO_IDX] == -1ull));
2261 }
2262 r->u64[HI_IDX] = 0;
2263 r->u64[LO_IDX] = carry;
2264 #endif
2265 }
2266
2267 void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2268 {
2269 #ifdef CONFIG_INT128
2270 r->u128 =
2271 (~a->u128 < ~b->u128) ||
2272 ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1));
2273 #else
2274 int carry_in = c->u64[LO_IDX] & 1;
2275 int carry_out = (avr_qw_cmpu(*a, *b) > 0);
2276 if (!carry_out && carry_in) {
2277 ppc_avr_t tmp;
2278 avr_qw_not(&tmp, *b);
2279 avr_qw_add(&tmp, *a, tmp);
2280 carry_out = ((tmp.u64[HI_IDX] == -1ull) && (tmp.u64[LO_IDX] == -1ull));
2281 }
2282
2283 r->u64[HI_IDX] = 0;
2284 r->u64[LO_IDX] = carry_out;
2285 #endif
2286 }
2287
2288 #define BCD_PLUS_PREF_1 0xC
2289 #define BCD_PLUS_PREF_2 0xF
2290 #define BCD_PLUS_ALT_1 0xA
2291 #define BCD_NEG_PREF 0xD
2292 #define BCD_NEG_ALT 0xB
2293 #define BCD_PLUS_ALT_2 0xE
2294
2295 #if defined(HOST_WORDS_BIGENDIAN)
2296 #define BCD_DIG_BYTE(n) (15 - (n/2))
2297 #else
2298 #define BCD_DIG_BYTE(n) (n/2)
2299 #endif
2300
2301 static int bcd_get_sgn(ppc_avr_t *bcd)
2302 {
2303 switch (bcd->u8[BCD_DIG_BYTE(0)] & 0xF) {
2304 case BCD_PLUS_PREF_1:
2305 case BCD_PLUS_PREF_2:
2306 case BCD_PLUS_ALT_1:
2307 case BCD_PLUS_ALT_2:
2308 {
2309 return 1;
2310 }
2311
2312 case BCD_NEG_PREF:
2313 case BCD_NEG_ALT:
2314 {
2315 return -1;
2316 }
2317
2318 default:
2319 {
2320 return 0;
2321 }
2322 }
2323 }
2324
2325 static int bcd_preferred_sgn(int sgn, int ps)
2326 {
2327 if (sgn >= 0) {
2328 return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2;
2329 } else {
2330 return BCD_NEG_PREF;
2331 }
2332 }
2333
2334 static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid)
2335 {
2336 uint8_t result;
2337 if (n & 1) {
2338 result = bcd->u8[BCD_DIG_BYTE(n)] >> 4;
2339 } else {
2340 result = bcd->u8[BCD_DIG_BYTE(n)] & 0xF;
2341 }
2342
2343 if (unlikely(result > 9)) {
2344 *invalid = true;
2345 }
2346 return result;
2347 }
2348
2349 static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n)
2350 {
2351 if (n & 1) {
2352 bcd->u8[BCD_DIG_BYTE(n)] &= 0x0F;
2353 bcd->u8[BCD_DIG_BYTE(n)] |= (digit<<4);
2354 } else {
2355 bcd->u8[BCD_DIG_BYTE(n)] &= 0xF0;
2356 bcd->u8[BCD_DIG_BYTE(n)] |= digit;
2357 }
2358 }
2359
2360 static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b)
2361 {
2362 int i;
2363 int invalid = 0;
2364 for (i = 31; i > 0; i--) {
2365 uint8_t dig_a = bcd_get_digit(a, i, &invalid);
2366 uint8_t dig_b = bcd_get_digit(b, i, &invalid);
2367 if (unlikely(invalid)) {
2368 return 0; /* doesn't matter */
2369 } else if (dig_a > dig_b) {
2370 return 1;
2371 } else if (dig_a < dig_b) {
2372 return -1;
2373 }
2374 }
2375
2376 return 0;
2377 }
2378
2379 static int bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2380 int *overflow)
2381 {
2382 int carry = 0;
2383 int i;
2384 int is_zero = 1;
2385 for (i = 1; i <= 31; i++) {
2386 uint8_t digit = bcd_get_digit(a, i, invalid) +
2387 bcd_get_digit(b, i, invalid) + carry;
2388 is_zero &= (digit == 0);
2389 if (digit > 9) {
2390 carry = 1;
2391 digit -= 10;
2392 } else {
2393 carry = 0;
2394 }
2395
2396 bcd_put_digit(t, digit, i);
2397
2398 if (unlikely(*invalid)) {
2399 return -1;
2400 }
2401 }
2402
2403 *overflow = carry;
2404 return is_zero;
2405 }
2406
2407 static int bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid,
2408 int *overflow)
2409 {
2410 int carry = 0;
2411 int i;
2412 int is_zero = 1;
2413 for (i = 1; i <= 31; i++) {
2414 uint8_t digit = bcd_get_digit(a, i, invalid) -
2415 bcd_get_digit(b, i, invalid) + carry;
2416 is_zero &= (digit == 0);
2417 if (digit & 0x80) {
2418 carry = -1;
2419 digit += 10;
2420 } else {
2421 carry = 0;
2422 }
2423
2424 bcd_put_digit(t, digit, i);
2425
2426 if (unlikely(*invalid)) {
2427 return -1;
2428 }
2429 }
2430
2431 *overflow = carry;
2432 return is_zero;
2433 }
2434
2435 uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2436 {
2437
2438 int sgna = bcd_get_sgn(a);
2439 int sgnb = bcd_get_sgn(b);
2440 int invalid = (sgna == 0) || (sgnb == 0);
2441 int overflow = 0;
2442 int zero = 0;
2443 uint32_t cr = 0;
2444 ppc_avr_t result = { .u64 = { 0, 0 } };
2445
2446 if (!invalid) {
2447 if (sgna == sgnb) {
2448 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2449 zero = bcd_add_mag(&result, a, b, &invalid, &overflow);
2450 cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2451 } else if (bcd_cmp_mag(a, b) > 0) {
2452 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgna, ps);
2453 zero = bcd_sub_mag(&result, a, b, &invalid, &overflow);
2454 cr = (sgna > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2455 } else {
2456 result.u8[BCD_DIG_BYTE(0)] = bcd_preferred_sgn(sgnb, ps);
2457 zero = bcd_sub_mag(&result, b, a, &invalid, &overflow);
2458 cr = (sgnb > 0) ? 1 << CRF_GT : 1 << CRF_LT;
2459 }
2460 }
2461
2462 if (unlikely(invalid)) {
2463 result.u64[HI_IDX] = result.u64[LO_IDX] = -1;
2464 cr = 1 << CRF_SO;
2465 } else if (overflow) {
2466 cr |= 1 << CRF_SO;
2467 } else if (zero) {
2468 cr = 1 << CRF_EQ;
2469 }
2470
2471 *r = result;
2472
2473 return cr;
2474 }
2475
2476 uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps)
2477 {
2478 ppc_avr_t bcopy = *b;
2479 int sgnb = bcd_get_sgn(b);
2480 if (sgnb < 0) {
2481 bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0);
2482 } else if (sgnb > 0) {
2483 bcd_put_digit(&bcopy, BCD_NEG_PREF, 0);
2484 }
2485 /* else invalid ... defer to bcdadd code for proper handling */
2486
2487 return helper_bcdadd(r, a, &bcopy, ps);
2488 }
2489
2490 void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a)
2491 {
2492 int i;
2493 VECTOR_FOR_INORDER_I(i, u8) {
2494 r->u8[i] = AES_sbox[a->u8[i]];
2495 }
2496 }
2497
2498 void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2499 {
2500 ppc_avr_t result;
2501 int i;
2502
2503 VECTOR_FOR_INORDER_I(i, u32) {
2504 result.AVRW(i) = b->AVRW(i) ^
2505 (AES_Te0[a->AVRB(AES_shifts[4*i + 0])] ^
2506 AES_Te1[a->AVRB(AES_shifts[4*i + 1])] ^
2507 AES_Te2[a->AVRB(AES_shifts[4*i + 2])] ^
2508 AES_Te3[a->AVRB(AES_shifts[4*i + 3])]);
2509 }
2510 *r = result;
2511 }
2512
2513 void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2514 {
2515 ppc_avr_t result;
2516 int i;
2517
2518 VECTOR_FOR_INORDER_I(i, u8) {
2519 result.AVRB(i) = b->AVRB(i) ^ (AES_sbox[a->AVRB(AES_shifts[i])]);
2520 }
2521 *r = result;
2522 }
2523
2524 void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2525 {
2526 /* This differs from what is written in ISA V2.07. The RTL is */
2527 /* incorrect and will be fixed in V2.07B. */
2528 int i;
2529 ppc_avr_t tmp;
2530
2531 VECTOR_FOR_INORDER_I(i, u8) {
2532 tmp.AVRB(i) = b->AVRB(i) ^ AES_isbox[a->AVRB(AES_ishifts[i])];
2533 }
2534
2535 VECTOR_FOR_INORDER_I(i, u32) {
2536 r->AVRW(i) =
2537 AES_imc[tmp.AVRB(4*i + 0)][0] ^
2538 AES_imc[tmp.AVRB(4*i + 1)][1] ^
2539 AES_imc[tmp.AVRB(4*i + 2)][2] ^
2540 AES_imc[tmp.AVRB(4*i + 3)][3];
2541 }
2542 }
2543
2544 void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
2545 {
2546 ppc_avr_t result;
2547 int i;
2548
2549 VECTOR_FOR_INORDER_I(i, u8) {
2550 result.AVRB(i) = b->AVRB(i) ^ (AES_isbox[a->AVRB(AES_ishifts[i])]);
2551 }
2552 *r = result;
2553 }
2554
2555 #define ROTRu32(v, n) (((v) >> (n)) | ((v) << (32-n)))
2556 #if defined(HOST_WORDS_BIGENDIAN)
2557 #define EL_IDX(i) (i)
2558 #else
2559 #define EL_IDX(i) (3 - (i))
2560 #endif
2561
2562 void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six)
2563 {
2564 int st = (st_six & 0x10) != 0;
2565 int six = st_six & 0xF;
2566 int i;
2567
2568 VECTOR_FOR_INORDER_I(i, u32) {
2569 if (st == 0) {
2570 if ((six & (0x8 >> i)) == 0) {
2571 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 7) ^
2572 ROTRu32(a->u32[EL_IDX(i)], 18) ^
2573 (a->u32[EL_IDX(i)] >> 3);
2574 } else { /* six.bit[i] == 1 */
2575 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 17) ^
2576 ROTRu32(a->u32[EL_IDX(i)], 19) ^
2577 (a->u32[EL_IDX(i)] >> 10);
2578 }
2579 } else { /* st == 1 */
2580 if ((six & (0x8 >> i)) == 0) {
2581 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 2) ^
2582 ROTRu32(a->u32[EL_IDX(i)], 13) ^
2583 ROTRu32(a->u32[EL_IDX(i)], 22);
2584 } else { /* six.bit[i] == 1 */
2585 r->u32[EL_IDX(i)] = ROTRu32(a->u32[EL_IDX(i)], 6) ^
2586 ROTRu32(a->u32[EL_IDX(i)], 11) ^
2587 ROTRu32(a->u32[EL_IDX(i)], 25);
2588 }
2589 }
2590 }
2591 }
2592
2593 #undef ROTRu32
2594 #undef EL_IDX
2595
2596 #define ROTRu64(v, n) (((v) >> (n)) | ((v) << (64-n)))
2597 #if defined(HOST_WORDS_BIGENDIAN)
2598 #define EL_IDX(i) (i)
2599 #else
2600 #define EL_IDX(i) (1 - (i))
2601 #endif
2602
2603 void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six)
2604 {
2605 int st = (st_six & 0x10) != 0;
2606 int six = st_six & 0xF;
2607 int i;
2608
2609 VECTOR_FOR_INORDER_I(i, u64) {
2610 if (st == 0) {
2611 if ((six & (0x8 >> (2*i))) == 0) {
2612 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 1) ^
2613 ROTRu64(a->u64[EL_IDX(i)], 8) ^
2614 (a->u64[EL_IDX(i)] >> 7);
2615 } else { /* six.bit[2*i] == 1 */
2616 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 19) ^
2617 ROTRu64(a->u64[EL_IDX(i)], 61) ^
2618 (a->u64[EL_IDX(i)] >> 6);
2619 }
2620 } else { /* st == 1 */
2621 if ((six & (0x8 >> (2*i))) == 0) {
2622 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 28) ^
2623 ROTRu64(a->u64[EL_IDX(i)], 34) ^
2624 ROTRu64(a->u64[EL_IDX(i)], 39);
2625 } else { /* six.bit[2*i] == 1 */
2626 r->u64[EL_IDX(i)] = ROTRu64(a->u64[EL_IDX(i)], 14) ^
2627 ROTRu64(a->u64[EL_IDX(i)], 18) ^
2628 ROTRu64(a->u64[EL_IDX(i)], 41);
2629 }
2630 }
2631 }
2632 }
2633
2634 #undef ROTRu64
2635 #undef EL_IDX
2636
2637 void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c)
2638 {
2639 ppc_avr_t result;
2640 int i;
2641
2642 VECTOR_FOR_INORDER_I(i, u8) {
2643 int indexA = c->u8[i] >> 4;
2644 int indexB = c->u8[i] & 0xF;
2645 #if defined(HOST_WORDS_BIGENDIAN)
2646 result.u8[i] = a->u8[indexA] ^ b->u8[indexB];
2647 #else
2648 result.u8[i] = a->u8[15-indexA] ^ b->u8[15-indexB];
2649 #endif
2650 }
2651 *r = result;
2652 }
2653
2654 #undef VECTOR_FOR_INORDER_I
2655 #undef HI_IDX
2656 #undef LO_IDX
2657
2658 /*****************************************************************************/
2659 /* SPE extension helpers */
2660 /* Use a table to make this quicker */
2661 static const uint8_t hbrev[16] = {
2662 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE,
2663 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF,
2664 };
2665
2666 static inline uint8_t byte_reverse(uint8_t val)
2667 {
2668 return hbrev[val >> 4] | (hbrev[val & 0xF] << 4);
2669 }
2670
2671 static inline uint32_t word_reverse(uint32_t val)
2672 {
2673 return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) |
2674 (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24);
2675 }
2676
2677 #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */
2678 target_ulong helper_brinc(target_ulong arg1, target_ulong arg2)
2679 {
2680 uint32_t a, b, d, mask;
2681
2682 mask = UINT32_MAX >> (32 - MASKBITS);
2683 a = arg1 & mask;
2684 b = arg2 & mask;
2685 d = word_reverse(1 + word_reverse(a | ~b));
2686 return (arg1 & ~mask) | (d & b);
2687 }
2688
2689 uint32_t helper_cntlsw32(uint32_t val)
2690 {
2691 if (val & 0x80000000) {
2692 return clz32(~val);
2693 } else {
2694 return clz32(val);
2695 }
2696 }
2697
2698 uint32_t helper_cntlzw32(uint32_t val)
2699 {
2700 return clz32(val);
2701 }
2702
2703 /* 440 specific */
2704 target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high,
2705 target_ulong low, uint32_t update_Rc)
2706 {
2707 target_ulong mask;
2708 int i;
2709
2710 i = 1;
2711 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2712 if ((high & mask) == 0) {
2713 if (update_Rc) {
2714 env->crf[0] = 0x4;
2715 }
2716 goto done;
2717 }
2718 i++;
2719 }
2720 for (mask = 0xFF000000; mask != 0; mask = mask >> 8) {
2721 if ((low & mask) == 0) {
2722 if (update_Rc) {
2723 env->crf[0] = 0x8;
2724 }
2725 goto done;
2726 }
2727 i++;
2728 }
2729 i = 8;
2730 if (update_Rc) {
2731 env->crf[0] = 0x2;
2732 }
2733 done:
2734 env->xer = (env->xer & ~0x7F) | i;
2735 if (update_Rc) {
2736 env->crf[0] |= xer_so;
2737 }
2738 return i;
2739 }
QEMU mirror