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