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