hmp: Ignore Error objects where the return value suffices
[qemu.git] / target / mips / lmmi_helper.c
1 /*
2 * Loongson Multimedia Instruction emulation helpers for QEMU.
3 *
4 * Copyright (c) 2011 Richard Henderson <rth@twiddle.net>
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
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "exec/helper-proto.h"
23
24 /*
25 * If the byte ordering doesn't matter, i.e. all columns are treated
26 * identically, then this union can be used directly. If byte ordering
27 * does matter, we generally ignore dumping to memory.
28 */
29 typedef union {
30 uint8_t ub[8];
31 int8_t sb[8];
32 uint16_t uh[4];
33 int16_t sh[4];
34 uint32_t uw[2];
35 int32_t sw[2];
36 uint64_t d;
37 } LMIValue;
38
39 /* Some byte ordering issues can be mitigated by XORing in the following. */
40 #ifdef HOST_WORDS_BIGENDIAN
41 # define BYTE_ORDER_XOR(N) N
42 #else
43 # define BYTE_ORDER_XOR(N) 0
44 #endif
45
46 #define SATSB(x) (x < -0x80 ? -0x80 : x > 0x7f ? 0x7f : x)
47 #define SATUB(x) (x > 0xff ? 0xff : x)
48
49 #define SATSH(x) (x < -0x8000 ? -0x8000 : x > 0x7fff ? 0x7fff : x)
50 #define SATUH(x) (x > 0xffff ? 0xffff : x)
51
52 #define SATSW(x) \
53 (x < -0x80000000ll ? -0x80000000ll : x > 0x7fffffff ? 0x7fffffff : x)
54 #define SATUW(x) (x > 0xffffffffull ? 0xffffffffull : x)
55
56 uint64_t helper_paddsb(uint64_t fs, uint64_t ft)
57 {
58 LMIValue vs, vt;
59 unsigned int i;
60
61 vs.d = fs;
62 vt.d = ft;
63 for (i = 0; i < 8; ++i) {
64 int r = vs.sb[i] + vt.sb[i];
65 vs.sb[i] = SATSB(r);
66 }
67 return vs.d;
68 }
69
70 uint64_t helper_paddusb(uint64_t fs, uint64_t ft)
71 {
72 LMIValue vs, vt;
73 unsigned int i;
74
75 vs.d = fs;
76 vt.d = ft;
77 for (i = 0; i < 8; ++i) {
78 int r = vs.ub[i] + vt.ub[i];
79 vs.ub[i] = SATUB(r);
80 }
81 return vs.d;
82 }
83
84 uint64_t helper_paddsh(uint64_t fs, uint64_t ft)
85 {
86 LMIValue vs, vt;
87 unsigned int i;
88
89 vs.d = fs;
90 vt.d = ft;
91 for (i = 0; i < 4; ++i) {
92 int r = vs.sh[i] + vt.sh[i];
93 vs.sh[i] = SATSH(r);
94 }
95 return vs.d;
96 }
97
98 uint64_t helper_paddush(uint64_t fs, uint64_t ft)
99 {
100 LMIValue vs, vt;
101 unsigned int i;
102
103 vs.d = fs;
104 vt.d = ft;
105 for (i = 0; i < 4; ++i) {
106 int r = vs.uh[i] + vt.uh[i];
107 vs.uh[i] = SATUH(r);
108 }
109 return vs.d;
110 }
111
112 uint64_t helper_paddb(uint64_t fs, uint64_t ft)
113 {
114 LMIValue vs, vt;
115 unsigned int i;
116
117 vs.d = fs;
118 vt.d = ft;
119 for (i = 0; i < 8; ++i) {
120 vs.ub[i] += vt.ub[i];
121 }
122 return vs.d;
123 }
124
125 uint64_t helper_paddh(uint64_t fs, uint64_t ft)
126 {
127 LMIValue vs, vt;
128 unsigned int i;
129
130 vs.d = fs;
131 vt.d = ft;
132 for (i = 0; i < 4; ++i) {
133 vs.uh[i] += vt.uh[i];
134 }
135 return vs.d;
136 }
137
138 uint64_t helper_paddw(uint64_t fs, uint64_t ft)
139 {
140 LMIValue vs, vt;
141 unsigned int i;
142
143 vs.d = fs;
144 vt.d = ft;
145 for (i = 0; i < 2; ++i) {
146 vs.uw[i] += vt.uw[i];
147 }
148 return vs.d;
149 }
150
151 uint64_t helper_psubsb(uint64_t fs, uint64_t ft)
152 {
153 LMIValue vs, vt;
154 unsigned int i;
155
156 vs.d = fs;
157 vt.d = ft;
158 for (i = 0; i < 8; ++i) {
159 int r = vs.sb[i] - vt.sb[i];
160 vs.sb[i] = SATSB(r);
161 }
162 return vs.d;
163 }
164
165 uint64_t helper_psubusb(uint64_t fs, uint64_t ft)
166 {
167 LMIValue vs, vt;
168 unsigned int i;
169
170 vs.d = fs;
171 vt.d = ft;
172 for (i = 0; i < 8; ++i) {
173 int r = vs.ub[i] - vt.ub[i];
174 vs.ub[i] = SATUB(r);
175 }
176 return vs.d;
177 }
178
179 uint64_t helper_psubsh(uint64_t fs, uint64_t ft)
180 {
181 LMIValue vs, vt;
182 unsigned int i;
183
184 vs.d = fs;
185 vt.d = ft;
186 for (i = 0; i < 4; ++i) {
187 int r = vs.sh[i] - vt.sh[i];
188 vs.sh[i] = SATSH(r);
189 }
190 return vs.d;
191 }
192
193 uint64_t helper_psubush(uint64_t fs, uint64_t ft)
194 {
195 LMIValue vs, vt;
196 unsigned int i;
197
198 vs.d = fs;
199 vt.d = ft;
200 for (i = 0; i < 4; ++i) {
201 int r = vs.uh[i] - vt.uh[i];
202 vs.uh[i] = SATUH(r);
203 }
204 return vs.d;
205 }
206
207 uint64_t helper_psubb(uint64_t fs, uint64_t ft)
208 {
209 LMIValue vs, vt;
210 unsigned int i;
211
212 vs.d = fs;
213 vt.d = ft;
214 for (i = 0; i < 8; ++i) {
215 vs.ub[i] -= vt.ub[i];
216 }
217 return vs.d;
218 }
219
220 uint64_t helper_psubh(uint64_t fs, uint64_t ft)
221 {
222 LMIValue vs, vt;
223 unsigned int i;
224
225 vs.d = fs;
226 vt.d = ft;
227 for (i = 0; i < 4; ++i) {
228 vs.uh[i] -= vt.uh[i];
229 }
230 return vs.d;
231 }
232
233 uint64_t helper_psubw(uint64_t fs, uint64_t ft)
234 {
235 LMIValue vs, vt;
236 unsigned int i;
237
238 vs.d = fs;
239 vt.d = ft;
240 for (i = 0; i < 2; ++i) {
241 vs.uw[i] -= vt.uw[i];
242 }
243 return vs.d;
244 }
245
246 uint64_t helper_pshufh(uint64_t fs, uint64_t ft)
247 {
248 unsigned host = BYTE_ORDER_XOR(3);
249 LMIValue vd, vs;
250 unsigned i;
251
252 vs.d = fs;
253 vd.d = 0;
254 for (i = 0; i < 4; i++, ft >>= 2) {
255 vd.uh[i ^ host] = vs.uh[(ft & 3) ^ host];
256 }
257 return vd.d;
258 }
259
260 uint64_t helper_packsswh(uint64_t fs, uint64_t ft)
261 {
262 uint64_t fd = 0;
263 int64_t tmp;
264
265 tmp = (int32_t)(fs >> 0);
266 tmp = SATSH(tmp);
267 fd |= (tmp & 0xffff) << 0;
268
269 tmp = (int32_t)(fs >> 32);
270 tmp = SATSH(tmp);
271 fd |= (tmp & 0xffff) << 16;
272
273 tmp = (int32_t)(ft >> 0);
274 tmp = SATSH(tmp);
275 fd |= (tmp & 0xffff) << 32;
276
277 tmp = (int32_t)(ft >> 32);
278 tmp = SATSH(tmp);
279 fd |= (tmp & 0xffff) << 48;
280
281 return fd;
282 }
283
284 uint64_t helper_packsshb(uint64_t fs, uint64_t ft)
285 {
286 uint64_t fd = 0;
287 unsigned int i;
288
289 for (i = 0; i < 4; ++i) {
290 int16_t tmp = fs >> (i * 16);
291 tmp = SATSB(tmp);
292 fd |= (uint64_t)(tmp & 0xff) << (i * 8);
293 }
294 for (i = 0; i < 4; ++i) {
295 int16_t tmp = ft >> (i * 16);
296 tmp = SATSB(tmp);
297 fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
298 }
299
300 return fd;
301 }
302
303 uint64_t helper_packushb(uint64_t fs, uint64_t ft)
304 {
305 uint64_t fd = 0;
306 unsigned int i;
307
308 for (i = 0; i < 4; ++i) {
309 int16_t tmp = fs >> (i * 16);
310 tmp = SATUB(tmp);
311 fd |= (uint64_t)(tmp & 0xff) << (i * 8);
312 }
313 for (i = 0; i < 4; ++i) {
314 int16_t tmp = ft >> (i * 16);
315 tmp = SATUB(tmp);
316 fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
317 }
318
319 return fd;
320 }
321
322 uint64_t helper_punpcklwd(uint64_t fs, uint64_t ft)
323 {
324 return (fs & 0xffffffff) | (ft << 32);
325 }
326
327 uint64_t helper_punpckhwd(uint64_t fs, uint64_t ft)
328 {
329 return (fs >> 32) | (ft & ~0xffffffffull);
330 }
331
332 uint64_t helper_punpcklhw(uint64_t fs, uint64_t ft)
333 {
334 unsigned host = BYTE_ORDER_XOR(3);
335 LMIValue vd, vs, vt;
336
337 vs.d = fs;
338 vt.d = ft;
339 vd.uh[0 ^ host] = vs.uh[0 ^ host];
340 vd.uh[1 ^ host] = vt.uh[0 ^ host];
341 vd.uh[2 ^ host] = vs.uh[1 ^ host];
342 vd.uh[3 ^ host] = vt.uh[1 ^ host];
343
344 return vd.d;
345 }
346
347 uint64_t helper_punpckhhw(uint64_t fs, uint64_t ft)
348 {
349 unsigned host = BYTE_ORDER_XOR(3);
350 LMIValue vd, vs, vt;
351
352 vs.d = fs;
353 vt.d = ft;
354 vd.uh[0 ^ host] = vs.uh[2 ^ host];
355 vd.uh[1 ^ host] = vt.uh[2 ^ host];
356 vd.uh[2 ^ host] = vs.uh[3 ^ host];
357 vd.uh[3 ^ host] = vt.uh[3 ^ host];
358
359 return vd.d;
360 }
361
362 uint64_t helper_punpcklbh(uint64_t fs, uint64_t ft)
363 {
364 unsigned host = BYTE_ORDER_XOR(7);
365 LMIValue vd, vs, vt;
366
367 vs.d = fs;
368 vt.d = ft;
369 vd.ub[0 ^ host] = vs.ub[0 ^ host];
370 vd.ub[1 ^ host] = vt.ub[0 ^ host];
371 vd.ub[2 ^ host] = vs.ub[1 ^ host];
372 vd.ub[3 ^ host] = vt.ub[1 ^ host];
373 vd.ub[4 ^ host] = vs.ub[2 ^ host];
374 vd.ub[5 ^ host] = vt.ub[2 ^ host];
375 vd.ub[6 ^ host] = vs.ub[3 ^ host];
376 vd.ub[7 ^ host] = vt.ub[3 ^ host];
377
378 return vd.d;
379 }
380
381 uint64_t helper_punpckhbh(uint64_t fs, uint64_t ft)
382 {
383 unsigned host = BYTE_ORDER_XOR(7);
384 LMIValue vd, vs, vt;
385
386 vs.d = fs;
387 vt.d = ft;
388 vd.ub[0 ^ host] = vs.ub[4 ^ host];
389 vd.ub[1 ^ host] = vt.ub[4 ^ host];
390 vd.ub[2 ^ host] = vs.ub[5 ^ host];
391 vd.ub[3 ^ host] = vt.ub[5 ^ host];
392 vd.ub[4 ^ host] = vs.ub[6 ^ host];
393 vd.ub[5 ^ host] = vt.ub[6 ^ host];
394 vd.ub[6 ^ host] = vs.ub[7 ^ host];
395 vd.ub[7 ^ host] = vt.ub[7 ^ host];
396
397 return vd.d;
398 }
399
400 uint64_t helper_pavgh(uint64_t fs, uint64_t ft)
401 {
402 LMIValue vs, vt;
403 unsigned i;
404
405 vs.d = fs;
406 vt.d = ft;
407 for (i = 0; i < 4; i++) {
408 vs.uh[i] = (vs.uh[i] + vt.uh[i] + 1) >> 1;
409 }
410 return vs.d;
411 }
412
413 uint64_t helper_pavgb(uint64_t fs, uint64_t ft)
414 {
415 LMIValue vs, vt;
416 unsigned i;
417
418 vs.d = fs;
419 vt.d = ft;
420 for (i = 0; i < 8; i++) {
421 vs.ub[i] = (vs.ub[i] + vt.ub[i] + 1) >> 1;
422 }
423 return vs.d;
424 }
425
426 uint64_t helper_pmaxsh(uint64_t fs, uint64_t ft)
427 {
428 LMIValue vs, vt;
429 unsigned i;
430
431 vs.d = fs;
432 vt.d = ft;
433 for (i = 0; i < 4; i++) {
434 vs.sh[i] = (vs.sh[i] >= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
435 }
436 return vs.d;
437 }
438
439 uint64_t helper_pminsh(uint64_t fs, uint64_t ft)
440 {
441 LMIValue vs, vt;
442 unsigned i;
443
444 vs.d = fs;
445 vt.d = ft;
446 for (i = 0; i < 4; i++) {
447 vs.sh[i] = (vs.sh[i] <= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
448 }
449 return vs.d;
450 }
451
452 uint64_t helper_pmaxub(uint64_t fs, uint64_t ft)
453 {
454 LMIValue vs, vt;
455 unsigned i;
456
457 vs.d = fs;
458 vt.d = ft;
459 for (i = 0; i < 4; i++) {
460 vs.ub[i] = (vs.ub[i] >= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
461 }
462 return vs.d;
463 }
464
465 uint64_t helper_pminub(uint64_t fs, uint64_t ft)
466 {
467 LMIValue vs, vt;
468 unsigned i;
469
470 vs.d = fs;
471 vt.d = ft;
472 for (i = 0; i < 4; i++) {
473 vs.ub[i] = (vs.ub[i] <= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
474 }
475 return vs.d;
476 }
477
478 uint64_t helper_pcmpeqw(uint64_t fs, uint64_t ft)
479 {
480 LMIValue vs, vt;
481 unsigned i;
482
483 vs.d = fs;
484 vt.d = ft;
485 for (i = 0; i < 2; i++) {
486 vs.uw[i] = -(vs.uw[i] == vt.uw[i]);
487 }
488 return vs.d;
489 }
490
491 uint64_t helper_pcmpgtw(uint64_t fs, uint64_t ft)
492 {
493 LMIValue vs, vt;
494 unsigned i;
495
496 vs.d = fs;
497 vt.d = ft;
498 for (i = 0; i < 2; i++) {
499 vs.uw[i] = -(vs.uw[i] > vt.uw[i]);
500 }
501 return vs.d;
502 }
503
504 uint64_t helper_pcmpeqh(uint64_t fs, uint64_t ft)
505 {
506 LMIValue vs, vt;
507 unsigned i;
508
509 vs.d = fs;
510 vt.d = ft;
511 for (i = 0; i < 4; i++) {
512 vs.uh[i] = -(vs.uh[i] == vt.uh[i]);
513 }
514 return vs.d;
515 }
516
517 uint64_t helper_pcmpgth(uint64_t fs, uint64_t ft)
518 {
519 LMIValue vs, vt;
520 unsigned i;
521
522 vs.d = fs;
523 vt.d = ft;
524 for (i = 0; i < 4; i++) {
525 vs.uh[i] = -(vs.uh[i] > vt.uh[i]);
526 }
527 return vs.d;
528 }
529
530 uint64_t helper_pcmpeqb(uint64_t fs, uint64_t ft)
531 {
532 LMIValue vs, vt;
533 unsigned i;
534
535 vs.d = fs;
536 vt.d = ft;
537 for (i = 0; i < 8; i++) {
538 vs.ub[i] = -(vs.ub[i] == vt.ub[i]);
539 }
540 return vs.d;
541 }
542
543 uint64_t helper_pcmpgtb(uint64_t fs, uint64_t ft)
544 {
545 LMIValue vs, vt;
546 unsigned i;
547
548 vs.d = fs;
549 vt.d = ft;
550 for (i = 0; i < 8; i++) {
551 vs.ub[i] = -(vs.ub[i] > vt.ub[i]);
552 }
553 return vs.d;
554 }
555
556 uint64_t helper_psllw(uint64_t fs, uint64_t ft)
557 {
558 LMIValue vs;
559 unsigned i;
560
561 ft &= 0x7f;
562 if (ft > 31) {
563 return 0;
564 }
565 vs.d = fs;
566 for (i = 0; i < 2; ++i) {
567 vs.uw[i] <<= ft;
568 }
569 return vs.d;
570 }
571
572 uint64_t helper_psrlw(uint64_t fs, uint64_t ft)
573 {
574 LMIValue vs;
575 unsigned i;
576
577 ft &= 0x7f;
578 if (ft > 31) {
579 return 0;
580 }
581 vs.d = fs;
582 for (i = 0; i < 2; ++i) {
583 vs.uw[i] >>= ft;
584 }
585 return vs.d;
586 }
587
588 uint64_t helper_psraw(uint64_t fs, uint64_t ft)
589 {
590 LMIValue vs;
591 unsigned i;
592
593 ft &= 0x7f;
594 if (ft > 31) {
595 ft = 31;
596 }
597 vs.d = fs;
598 for (i = 0; i < 2; ++i) {
599 vs.sw[i] >>= ft;
600 }
601 return vs.d;
602 }
603
604 uint64_t helper_psllh(uint64_t fs, uint64_t ft)
605 {
606 LMIValue vs;
607 unsigned i;
608
609 ft &= 0x7f;
610 if (ft > 15) {
611 return 0;
612 }
613 vs.d = fs;
614 for (i = 0; i < 4; ++i) {
615 vs.uh[i] <<= ft;
616 }
617 return vs.d;
618 }
619
620 uint64_t helper_psrlh(uint64_t fs, uint64_t ft)
621 {
622 LMIValue vs;
623 unsigned i;
624
625 ft &= 0x7f;
626 if (ft > 15) {
627 return 0;
628 }
629 vs.d = fs;
630 for (i = 0; i < 4; ++i) {
631 vs.uh[i] >>= ft;
632 }
633 return vs.d;
634 }
635
636 uint64_t helper_psrah(uint64_t fs, uint64_t ft)
637 {
638 LMIValue vs;
639 unsigned i;
640
641 ft &= 0x7f;
642 if (ft > 15) {
643 ft = 15;
644 }
645 vs.d = fs;
646 for (i = 0; i < 4; ++i) {
647 vs.sh[i] >>= ft;
648 }
649 return vs.d;
650 }
651
652 uint64_t helper_pmullh(uint64_t fs, uint64_t ft)
653 {
654 LMIValue vs, vt;
655 unsigned i;
656
657 vs.d = fs;
658 vt.d = ft;
659 for (i = 0; i < 4; ++i) {
660 vs.sh[i] *= vt.sh[i];
661 }
662 return vs.d;
663 }
664
665 uint64_t helper_pmulhh(uint64_t fs, uint64_t ft)
666 {
667 LMIValue vs, vt;
668 unsigned i;
669
670 vs.d = fs;
671 vt.d = ft;
672 for (i = 0; i < 4; ++i) {
673 int32_t r = vs.sh[i] * vt.sh[i];
674 vs.sh[i] = r >> 16;
675 }
676 return vs.d;
677 }
678
679 uint64_t helper_pmulhuh(uint64_t fs, uint64_t ft)
680 {
681 LMIValue vs, vt;
682 unsigned i;
683
684 vs.d = fs;
685 vt.d = ft;
686 for (i = 0; i < 4; ++i) {
687 uint32_t r = vs.uh[i] * vt.uh[i];
688 vs.uh[i] = r >> 16;
689 }
690 return vs.d;
691 }
692
693 uint64_t helper_pmaddhw(uint64_t fs, uint64_t ft)
694 {
695 unsigned host = BYTE_ORDER_XOR(3);
696 LMIValue vs, vt;
697 uint32_t p0, p1;
698
699 vs.d = fs;
700 vt.d = ft;
701 p0 = vs.sh[0 ^ host] * vt.sh[0 ^ host];
702 p0 += vs.sh[1 ^ host] * vt.sh[1 ^ host];
703 p1 = vs.sh[2 ^ host] * vt.sh[2 ^ host];
704 p1 += vs.sh[3 ^ host] * vt.sh[3 ^ host];
705
706 return ((uint64_t)p1 << 32) | p0;
707 }
708
709 uint64_t helper_pasubub(uint64_t fs, uint64_t ft)
710 {
711 LMIValue vs, vt;
712 unsigned i;
713
714 vs.d = fs;
715 vt.d = ft;
716 for (i = 0; i < 8; ++i) {
717 int r = vs.ub[i] - vt.ub[i];
718 vs.ub[i] = (r < 0 ? -r : r);
719 }
720 return vs.d;
721 }
722
723 uint64_t helper_biadd(uint64_t fs)
724 {
725 unsigned i, fd;
726
727 for (i = fd = 0; i < 8; ++i) {
728 fd += (fs >> (i * 8)) & 0xff;
729 }
730 return fd & 0xffff;
731 }
732
733 uint64_t helper_pmovmskb(uint64_t fs)
734 {
735 unsigned fd = 0;
736
737 fd |= ((fs >> 7) & 1) << 0;
738 fd |= ((fs >> 15) & 1) << 1;
739 fd |= ((fs >> 23) & 1) << 2;
740 fd |= ((fs >> 31) & 1) << 3;
741 fd |= ((fs >> 39) & 1) << 4;
742 fd |= ((fs >> 47) & 1) << 5;
743 fd |= ((fs >> 55) & 1) << 6;
744 fd |= ((fs >> 63) & 1) << 7;
745
746 return fd & 0xff;
747 }