?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qmp: Convert QMP code to use object property iterators
[qemu/ar7.git] / target-mips / dsp_helper.c
blob46528de325c44e8b7a593c95eff0bd28ace851cf
1 /*
2 * MIPS ASE DSP Instruction emulation helpers for QEMU.
3 *
4 * Copyright (c) 2012 Jia Liu <proljc@gmail.com>
5 * Dongxue Zhang <elta.era@gmail.com>
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 "cpu.h"
21 #include "exec/helper-proto.h"
22 #include "qemu/bitops.h"
23
24 /* As the byte ordering doesn't matter, i.e. all columns are treated
25 identically, these unions can be used directly. */
26 typedef union {
27 uint8_t ub[4];
28 int8_t sb[4];
29 uint16_t uh[2];
30 int16_t sh[2];
31 uint32_t uw[1];
32 int32_t sw[1];
33 } DSP32Value;
34
35 typedef union {
36 uint8_t ub[8];
37 int8_t sb[8];
38 uint16_t uh[4];
39 int16_t sh[4];
40 uint32_t uw[2];
41 int32_t sw[2];
42 uint64_t ul[1];
43 int64_t sl[1];
44 } DSP64Value;
45
46 /*** MIPS DSP internal functions begin ***/
47 #define MIPSDSP_ABS(x) (((x) >= 0) ? x : -x)
48 #define MIPSDSP_OVERFLOW_ADD(a, b, c, d) (~(a ^ b) & (a ^ c) & d)
49 #define MIPSDSP_OVERFLOW_SUB(a, b, c, d) ((a ^ b) & (a ^ c) & d)
50
51 static inline void set_DSPControl_overflow_flag(uint32_t flag, int position,
52 CPUMIPSState *env)
53 {
54 env->active_tc.DSPControl |= (target_ulong)flag << position;
55 }
56
57 static inline void set_DSPControl_carryflag(bool flag, CPUMIPSState *env)
58 {
59 env->active_tc.DSPControl &= ~(1 << 13);
60 env->active_tc.DSPControl |= flag << 13;
61 }
62
63 static inline uint32_t get_DSPControl_carryflag(CPUMIPSState *env)
64 {
65 return (env->active_tc.DSPControl >> 13) & 0x01;
66 }
67
68 static inline void set_DSPControl_24(uint32_t flag, int len, CPUMIPSState *env)
69 {
70 uint32_t filter;
71
72 filter = ((0x01 << len) - 1) << 24;
73 filter = ~filter;
74
75 env->active_tc.DSPControl &= filter;
76 env->active_tc.DSPControl |= (target_ulong)flag << 24;
77 }
78
79 static inline void set_DSPControl_pos(uint32_t pos, CPUMIPSState *env)
80 {
81 target_ulong dspc;
82
83 dspc = env->active_tc.DSPControl;
84 #ifndef TARGET_MIPS64
85 dspc = dspc & 0xFFFFFFC0;
86 dspc |= (pos & 0x3F);
87 #else
88 dspc = dspc & 0xFFFFFF80;
89 dspc |= (pos & 0x7F);
90 #endif
91 env->active_tc.DSPControl = dspc;
92 }
93
94 static inline uint32_t get_DSPControl_pos(CPUMIPSState *env)
95 {
96 target_ulong dspc;
97 uint32_t pos;
98
99 dspc = env->active_tc.DSPControl;
100
101 #ifndef TARGET_MIPS64
102 pos = dspc & 0x3F;
103 #else
104 pos = dspc & 0x7F;
105 #endif
106
107 return pos;
108 }
109
110 static inline void set_DSPControl_efi(uint32_t flag, CPUMIPSState *env)
111 {
112 env->active_tc.DSPControl &= 0xFFFFBFFF;
113 env->active_tc.DSPControl |= (target_ulong)flag << 14;
114 }
115
116 #define DO_MIPS_SAT_ABS(size) \
117 static inline int##size##_t mipsdsp_sat_abs##size(int##size##_t a, \
118 CPUMIPSState *env) \
119 { \
120 if (a == INT##size##_MIN) { \
121 set_DSPControl_overflow_flag(1, 20, env); \
122 return INT##size##_MAX; \
123 } else { \
124 return MIPSDSP_ABS(a); \
125 } \
126 }
127 DO_MIPS_SAT_ABS(8)
128 DO_MIPS_SAT_ABS(16)
129 DO_MIPS_SAT_ABS(32)
130 #undef DO_MIPS_SAT_ABS
131
132 /* get sum value */
133 static inline int16_t mipsdsp_add_i16(int16_t a, int16_t b, CPUMIPSState *env)
134 {
135 int16_t tempI;
136
137 tempI = a + b;
138
139 if (MIPSDSP_OVERFLOW_ADD(a, b, tempI, 0x8000)) {
140 set_DSPControl_overflow_flag(1, 20, env);
141 }
142
143 return tempI;
144 }
145
146 static inline int16_t mipsdsp_sat_add_i16(int16_t a, int16_t b,
147 CPUMIPSState *env)
148 {
149 int16_t tempS;
150
151 tempS = a + b;
152
153 if (MIPSDSP_OVERFLOW_ADD(a, b, tempS, 0x8000)) {
154 if (a > 0) {
155 tempS = 0x7FFF;
156 } else {
157 tempS = 0x8000;
158 }
159 set_DSPControl_overflow_flag(1, 20, env);
160 }
161
162 return tempS;
163 }
164
165 static inline int32_t mipsdsp_sat_add_i32(int32_t a, int32_t b,
166 CPUMIPSState *env)
167 {
168 int32_t tempI;
169
170 tempI = a + b;
171
172 if (MIPSDSP_OVERFLOW_ADD(a, b, tempI, 0x80000000)) {
173 if (a > 0) {
174 tempI = 0x7FFFFFFF;
175 } else {
176 tempI = 0x80000000;
177 }
178 set_DSPControl_overflow_flag(1, 20, env);
179 }
180
181 return tempI;
182 }
183
184 static inline uint8_t mipsdsp_add_u8(uint8_t a, uint8_t b, CPUMIPSState *env)
185 {
186 uint16_t temp;
187
188 temp = (uint16_t)a + (uint16_t)b;
189
190 if (temp & 0x0100) {
191 set_DSPControl_overflow_flag(1, 20, env);
192 }
193
194 return temp & 0xFF;
195 }
196
197 static inline uint16_t mipsdsp_add_u16(uint16_t a, uint16_t b,
198 CPUMIPSState *env)
199 {
200 uint32_t temp;
201
202 temp = (uint32_t)a + (uint32_t)b;
203
204 if (temp & 0x00010000) {
205 set_DSPControl_overflow_flag(1, 20, env);
206 }
207
208 return temp & 0xFFFF;
209 }
210
211 static inline uint8_t mipsdsp_sat_add_u8(uint8_t a, uint8_t b,
212 CPUMIPSState *env)
213 {
214 uint8_t result;
215 uint16_t temp;
216
217 temp = (uint16_t)a + (uint16_t)b;
218 result = temp & 0xFF;
219
220 if (0x0100 & temp) {
221 result = 0xFF;
222 set_DSPControl_overflow_flag(1, 20, env);
223 }
224
225 return result;
226 }
227
228 static inline uint16_t mipsdsp_sat_add_u16(uint16_t a, uint16_t b,
229 CPUMIPSState *env)
230 {
231 uint16_t result;
232 uint32_t temp;
233
234 temp = (uint32_t)a + (uint32_t)b;
235 result = temp & 0xFFFF;
236
237 if (0x00010000 & temp) {
238 result = 0xFFFF;
239 set_DSPControl_overflow_flag(1, 20, env);
240 }
241
242 return result;
243 }
244
245 static inline int32_t mipsdsp_sat32_acc_q31(int32_t acc, int32_t a,
246 CPUMIPSState *env)
247 {
248 int64_t temp;
249 int32_t temp32, temp31, result;
250 int64_t temp_sum;
251
252 #ifndef TARGET_MIPS64
253 temp = ((uint64_t)env->active_tc.HI[acc] << 32) |
254 (uint64_t)env->active_tc.LO[acc];
255 #else
256 temp = (uint64_t)env->active_tc.LO[acc];
257 #endif
258
259 temp_sum = (int64_t)a + temp;
260
261 temp32 = (temp_sum >> 32) & 0x01;
262 temp31 = (temp_sum >> 31) & 0x01;
263 result = temp_sum & 0xFFFFFFFF;
264
265 if (temp32 != temp31) {
266 if (temp32 == 0) {
267 result = 0x7FFFFFFF;
268 } else {
269 result = 0x80000000;
270 }
271 set_DSPControl_overflow_flag(1, 16 + acc, env);
272 }
273
274 return result;
275 }
276
277 #ifdef TARGET_MIPS64
278 /* a[0] is LO, a[1] is HI. */
279 static inline void mipsdsp_sat64_acc_add_q63(int64_t *ret,
280 int32_t ac,
281 int64_t *a,
282 CPUMIPSState *env)
283 {
284 bool temp64;
285
286 ret[0] = env->active_tc.LO[ac] + a[0];
287 ret[1] = env->active_tc.HI[ac] + a[1];
288
289 if (((uint64_t)ret[0] < (uint64_t)env->active_tc.LO[ac]) &&
290 ((uint64_t)ret[0] < (uint64_t)a[0])) {
291 ret[1] += 1;
292 }
293 temp64 = ret[1] & 1;
294 if (temp64 != ((ret[0] >> 63) & 0x01)) {
295 if (temp64) {
296 ret[0] = (0x01ull << 63);
297 ret[1] = ~0ull;
298 } else {
299 ret[0] = (0x01ull << 63) - 1;
300 ret[1] = 0x00;
301 }
302 set_DSPControl_overflow_flag(1, 16 + ac, env);
303 }
304 }
305
306 static inline void mipsdsp_sat64_acc_sub_q63(int64_t *ret,
307 int32_t ac,
308 int64_t *a,
309 CPUMIPSState *env)
310 {
311 bool temp64;
312
313 ret[0] = env->active_tc.LO[ac] - a[0];
314 ret[1] = env->active_tc.HI[ac] - a[1];
315
316 if ((uint64_t)ret[0] > (uint64_t)env->active_tc.LO[ac]) {
317 ret[1] -= 1;
318 }
319 temp64 = ret[1] & 1;
320 if (temp64 != ((ret[0] >> 63) & 0x01)) {
321 if (temp64) {
322 ret[0] = (0x01ull << 63);
323 ret[1] = ~0ull;
324 } else {
325 ret[0] = (0x01ull << 63) - 1;
326 ret[1] = 0x00;
327 }
328 set_DSPControl_overflow_flag(1, 16 + ac, env);
329 }
330 }
331 #endif
332
333 static inline int32_t mipsdsp_mul_i16_i16(int16_t a, int16_t b,
334 CPUMIPSState *env)
335 {
336 int32_t temp;
337
338 temp = (int32_t)a * (int32_t)b;
339
340 if ((temp > (int)0x7FFF) || (temp < (int)0xFFFF8000)) {
341 set_DSPControl_overflow_flag(1, 21, env);
342 }
343 temp &= 0x0000FFFF;
344
345 return temp;
346 }
347
348 static inline int32_t mipsdsp_mul_u16_u16(int32_t a, int32_t b)
349 {
350 return a * b;
351 }
352
353 #ifdef TARGET_MIPS64
354 static inline int32_t mipsdsp_mul_i32_i32(int32_t a, int32_t b)
355 {
356 return a * b;
357 }
358 #endif
359
360 static inline int32_t mipsdsp_sat16_mul_i16_i16(int16_t a, int16_t b,
361 CPUMIPSState *env)
362 {
363 int32_t temp;
364
365 temp = (int32_t)a * (int32_t)b;
366
367 if (temp > (int)0x7FFF) {
368 temp = 0x00007FFF;
369 set_DSPControl_overflow_flag(1, 21, env);
370 } else if (temp < (int)0xffff8000) {
371 temp = 0xFFFF8000;
372 set_DSPControl_overflow_flag(1, 21, env);
373 }
374 temp &= 0x0000FFFF;
375
376 return temp;
377 }
378
379 static inline int32_t mipsdsp_mul_q15_q15_overflowflag21(uint16_t a, uint16_t b,
380 CPUMIPSState *env)
381 {
382 int32_t temp;
383
384 if ((a == 0x8000) && (b == 0x8000)) {
385 temp = 0x7FFFFFFF;
386 set_DSPControl_overflow_flag(1, 21, env);
387 } else {
388 temp = ((int16_t)a * (int16_t)b) << 1;
389 }
390
391 return temp;
392 }
393
394 /* right shift */
395 static inline uint8_t mipsdsp_rshift_u8(uint8_t a, target_ulong mov)
396 {
397 return a >> mov;
398 }
399
400 static inline uint16_t mipsdsp_rshift_u16(uint16_t a, target_ulong mov)
401 {
402 return a >> mov;
403 }
404
405 static inline int8_t mipsdsp_rashift8(int8_t a, target_ulong mov)
406 {
407 return a >> mov;
408 }
409
410 static inline int16_t mipsdsp_rashift16(int16_t a, target_ulong mov)
411 {
412 return a >> mov;
413 }
414
415 #ifdef TARGET_MIPS64
416 static inline int32_t mipsdsp_rashift32(int32_t a, target_ulong mov)
417 {
418 return a >> mov;
419 }
420 #endif
421
422 static inline int16_t mipsdsp_rshift1_add_q16(int16_t a, int16_t b)
423 {
424 int32_t temp;
425
426 temp = (int32_t)a + (int32_t)b;
427
428 return (temp >> 1) & 0xFFFF;
429 }
430
431 /* round right shift */
432 static inline int16_t mipsdsp_rrshift1_add_q16(int16_t a, int16_t b)
433 {
434 int32_t temp;
435
436 temp = (int32_t)a + (int32_t)b;
437 temp += 1;
438
439 return (temp >> 1) & 0xFFFF;
440 }
441
442 static inline int32_t mipsdsp_rshift1_add_q32(int32_t a, int32_t b)
443 {
444 int64_t temp;
445
446 temp = (int64_t)a + (int64_t)b;
447
448 return (temp >> 1) & 0xFFFFFFFF;
449 }
450
451 static inline int32_t mipsdsp_rrshift1_add_q32(int32_t a, int32_t b)
452 {
453 int64_t temp;
454
455 temp = (int64_t)a + (int64_t)b;
456 temp += 1;
457
458 return (temp >> 1) & 0xFFFFFFFF;
459 }
460
461 static inline uint8_t mipsdsp_rshift1_add_u8(uint8_t a, uint8_t b)
462 {
463 uint16_t temp;
464
465 temp = (uint16_t)a + (uint16_t)b;
466
467 return (temp >> 1) & 0x00FF;
468 }
469
470 static inline uint8_t mipsdsp_rrshift1_add_u8(uint8_t a, uint8_t b)
471 {
472 uint16_t temp;
473
474 temp = (uint16_t)a + (uint16_t)b + 1;
475
476 return (temp >> 1) & 0x00FF;
477 }
478
479 #ifdef TARGET_MIPS64
480 static inline uint8_t mipsdsp_rshift1_sub_u8(uint8_t a, uint8_t b)
481 {
482 uint16_t temp;
483
484 temp = (uint16_t)a - (uint16_t)b;
485
486 return (temp >> 1) & 0x00FF;
487 }
488
489 static inline uint8_t mipsdsp_rrshift1_sub_u8(uint8_t a, uint8_t b)
490 {
491 uint16_t temp;
492
493 temp = (uint16_t)a - (uint16_t)b + 1;
494
495 return (temp >> 1) & 0x00FF;
496 }
497 #endif
498
499 /* 128 bits long. p[0] is LO, p[1] is HI. */
500 static inline void mipsdsp_rndrashift_short_acc(int64_t *p,
501 int32_t ac,
502 int32_t shift,
503 CPUMIPSState *env)
504 {
505 int64_t acc;
506
507 acc = ((int64_t)env->active_tc.HI[ac] << 32) |
508 ((int64_t)env->active_tc.LO[ac] & 0xFFFFFFFF);
509 p[0] = (shift == 0) ? (acc << 1) : (acc >> (shift - 1));
510 p[1] = (acc >> 63) & 0x01;
511 }
512
513 #ifdef TARGET_MIPS64
514 /* 128 bits long. p[0] is LO, p[1] is HI */
515 static inline void mipsdsp_rashift_acc(uint64_t *p,
516 uint32_t ac,
517 uint32_t shift,
518 CPUMIPSState *env)
519 {
520 uint64_t tempB, tempA;
521
522 tempB = env->active_tc.HI[ac];
523 tempA = env->active_tc.LO[ac];
524 shift = shift & 0x1F;
525
526 if (shift == 0) {
527 p[1] = tempB;
528 p[0] = tempA;
529 } else {
530 p[0] = (tempB << (64 - shift)) | (tempA >> shift);
531 p[1] = (int64_t)tempB >> shift;
532 }
533 }
534
535 /* 128 bits long. p[0] is LO, p[1] is HI , p[2] is sign of HI.*/
536 static inline void mipsdsp_rndrashift_acc(uint64_t *p,
537 uint32_t ac,
538 uint32_t shift,
539 CPUMIPSState *env)
540 {
541 int64_t tempB, tempA;
542
543 tempB = env->active_tc.HI[ac];
544 tempA = env->active_tc.LO[ac];
545 shift = shift & 0x3F;
546
547 if (shift == 0) {
548 p[2] = tempB >> 63;
549 p[1] = (tempB << 1) | (tempA >> 63);
550 p[0] = tempA << 1;
551 } else {
552 p[0] = (tempB << (65 - shift)) | (tempA >> (shift - 1));
553 p[1] = (int64_t)tempB >> (shift - 1);
554 if (tempB >= 0) {
555 p[2] = 0x0;
556 } else {
557 p[2] = ~0ull;
558 }
559 }
560 }
561 #endif
562
563 static inline int32_t mipsdsp_mul_q15_q15(int32_t ac, uint16_t a, uint16_t b,
564 CPUMIPSState *env)
565 {
566 int32_t temp;
567
568 if ((a == 0x8000) && (b == 0x8000)) {
569 temp = 0x7FFFFFFF;
570 set_DSPControl_overflow_flag(1, 16 + ac, env);
571 } else {
572 temp = ((int16_t)a * (int16_t)b) << 1;
573 }
574
575 return temp;
576 }
577
578 static inline int64_t mipsdsp_mul_q31_q31(int32_t ac, uint32_t a, uint32_t b,
579 CPUMIPSState *env)
580 {
581 uint64_t temp;
582
583 if ((a == 0x80000000) && (b == 0x80000000)) {
584 temp = (0x01ull << 63) - 1;
585 set_DSPControl_overflow_flag(1, 16 + ac, env);
586 } else {
587 temp = ((int64_t)(int32_t)a * (int32_t)b) << 1;
588 }
589
590 return temp;
591 }
592
593 static inline uint16_t mipsdsp_mul_u8_u8(uint8_t a, uint8_t b)
594 {
595 return (uint16_t)a * (uint16_t)b;
596 }
597
598 static inline uint16_t mipsdsp_mul_u8_u16(uint8_t a, uint16_t b,
599 CPUMIPSState *env)
600 {
601 uint32_t tempI;
602
603 tempI = (uint32_t)a * (uint32_t)b;
604 if (tempI > 0x0000FFFF) {
605 tempI = 0x0000FFFF;
606 set_DSPControl_overflow_flag(1, 21, env);
607 }
608
609 return tempI & 0x0000FFFF;
610 }
611
612 #ifdef TARGET_MIPS64
613 static inline uint64_t mipsdsp_mul_u32_u32(uint32_t a, uint32_t b)
614 {
615 return (uint64_t)a * (uint64_t)b;
616 }
617 #endif
618
619 static inline int16_t mipsdsp_rndq15_mul_q15_q15(uint16_t a, uint16_t b,
620 CPUMIPSState *env)
621 {
622 uint32_t temp;
623
624 if ((a == 0x8000) && (b == 0x8000)) {
625 temp = 0x7FFF0000;
626 set_DSPControl_overflow_flag(1, 21, env);
627 } else {
628 temp = ((int16_t)a * (int16_t)b) << 1;
629 temp = temp + 0x00008000;
630 }
631
632 return (temp & 0xFFFF0000) >> 16;
633 }
634
635 static inline int32_t mipsdsp_sat16_mul_q15_q15(uint16_t a, uint16_t b,
636 CPUMIPSState *env)
637 {
638 int32_t temp;
639
640 if ((a == 0x8000) && (b == 0x8000)) {
641 temp = 0x7FFF0000;
642 set_DSPControl_overflow_flag(1, 21, env);
643 } else {
644 temp = (int16_t)a * (int16_t)b;
645 temp = temp << 1;
646 }
647
648 return (temp >> 16) & 0x0000FFFF;
649 }
650
651 static inline uint16_t mipsdsp_trunc16_sat16_round(int32_t a,
652 CPUMIPSState *env)
653 {
654 uint16_t temp;
655
656
657 /*
658 * The value 0x00008000 will be added to the input Q31 value, and the code
659 * needs to check if the addition causes an overflow. Since a positive value
660 * is added, overflow can happen in one direction only.
661 */
662 if (a > 0x7FFF7FFF) {
663 temp = 0x7FFF;
664 set_DSPControl_overflow_flag(1, 22, env);
665 } else {
666 temp = ((a + 0x8000) >> 16) & 0xFFFF;
667 }
668
669 return temp;
670 }
671
672 static inline uint8_t mipsdsp_sat8_reduce_precision(uint16_t a,
673 CPUMIPSState *env)
674 {
675 uint16_t mag;
676 uint32_t sign;
677
678 sign = (a >> 15) & 0x01;
679 mag = a & 0x7FFF;
680
681 if (sign == 0) {
682 if (mag > 0x7F80) {
683 set_DSPControl_overflow_flag(1, 22, env);
684 return 0xFF;
685 } else {
686 return (mag >> 7) & 0xFFFF;
687 }
688 } else {
689 set_DSPControl_overflow_flag(1, 22, env);
690 return 0x00;
691 }
692 }
693
694 static inline uint8_t mipsdsp_lshift8(uint8_t a, uint8_t s, CPUMIPSState *env)
695 {
696 uint8_t discard;
697
698 if (s != 0) {
699 discard = a >> (8 - s);
700
701 if (discard != 0x00) {
702 set_DSPControl_overflow_flag(1, 22, env);
703 }
704 }
705 return a << s;
706 }
707
708 static inline uint16_t mipsdsp_lshift16(uint16_t a, uint8_t s,
709 CPUMIPSState *env)
710 {
711 uint16_t discard;
712
713 if (s != 0) {
714 discard = (int16_t)a >> (15 - s);
715
716 if ((discard != 0x0000) && (discard != 0xFFFF)) {
717 set_DSPControl_overflow_flag(1, 22, env);
718 }
719 }
720 return a << s;
721 }
722
723 #ifdef TARGET_MIPS64
724 static inline uint32_t mipsdsp_lshift32(uint32_t a, uint8_t s,
725 CPUMIPSState *env)
726 {
727 uint32_t discard;
728
729 if (s == 0) {
730 return a;
731 } else {
732 discard = (int32_t)a >> (31 - (s - 1));
733
734 if ((discard != 0x00000000) && (discard != 0xFFFFFFFF)) {
735 set_DSPControl_overflow_flag(1, 22, env);
736 }
737 return a << s;
738 }
739 }
740 #endif
741
742 static inline uint16_t mipsdsp_sat16_lshift(uint16_t a, uint8_t s,
743 CPUMIPSState *env)
744 {
745 uint8_t sign;
746 uint16_t discard;
747
748 if (s == 0) {
749 return a;
750 } else {
751 sign = (a >> 15) & 0x01;
752 if (sign != 0) {
753 discard = (((0x01 << (16 - s)) - 1) << s) |
754 ((a >> (14 - (s - 1))) & ((0x01 << s) - 1));
755 } else {
756 discard = a >> (14 - (s - 1));
757 }
758
759 if ((discard != 0x0000) && (discard != 0xFFFF)) {
760 set_DSPControl_overflow_flag(1, 22, env);
761 return (sign == 0) ? 0x7FFF : 0x8000;
762 } else {
763 return a << s;
764 }
765 }
766 }
767
768 static inline uint32_t mipsdsp_sat32_lshift(uint32_t a, uint8_t s,
769 CPUMIPSState *env)
770 {
771 uint8_t sign;
772 uint32_t discard;
773
774 if (s == 0) {
775 return a;
776 } else {
777 sign = (a >> 31) & 0x01;
778 if (sign != 0) {
779 discard = (((0x01 << (32 - s)) - 1) << s) |
780 ((a >> (30 - (s - 1))) & ((0x01 << s) - 1));
781 } else {
782 discard = a >> (30 - (s - 1));
783 }
784
785 if ((discard != 0x00000000) && (discard != 0xFFFFFFFF)) {
786 set_DSPControl_overflow_flag(1, 22, env);
787 return (sign == 0) ? 0x7FFFFFFF : 0x80000000;
788 } else {
789 return a << s;
790 }
791 }
792 }
793
794 static inline uint8_t mipsdsp_rnd8_rashift(uint8_t a, uint8_t s)
795 {
796 uint32_t temp;
797
798 if (s == 0) {
799 temp = (uint32_t)a << 1;
800 } else {
801 temp = (int32_t)(int8_t)a >> (s - 1);
802 }
803
804 return (temp + 1) >> 1;
805 }
806
807 static inline uint16_t mipsdsp_rnd16_rashift(uint16_t a, uint8_t s)
808 {
809 uint32_t temp;
810
811 if (s == 0) {
812 temp = (uint32_t)a << 1;
813 } else {
814 temp = (int32_t)(int16_t)a >> (s - 1);
815 }
816
817 return (temp + 1) >> 1;
818 }
819
820 static inline uint32_t mipsdsp_rnd32_rashift(uint32_t a, uint8_t s)
821 {
822 int64_t temp;
823
824 if (s == 0) {
825 temp = (uint64_t)a << 1;
826 } else {
827 temp = (int64_t)(int32_t)a >> (s - 1);
828 }
829 temp += 1;
830
831 return (temp >> 1) & 0xFFFFFFFFull;
832 }
833
834 static inline uint16_t mipsdsp_sub_i16(int16_t a, int16_t b, CPUMIPSState *env)
835 {
836 int16_t temp;
837
838 temp = a - b;
839 if (MIPSDSP_OVERFLOW_SUB(a, b, temp, 0x8000)) {
840 set_DSPControl_overflow_flag(1, 20, env);
841 }
842
843 return temp;
844 }
845
846 static inline uint16_t mipsdsp_sat16_sub(int16_t a, int16_t b,
847 CPUMIPSState *env)
848 {
849 int16_t temp;
850
851 temp = a - b;
852 if (MIPSDSP_OVERFLOW_SUB(a, b, temp, 0x8000)) {
853 if (a >= 0) {
854 temp = 0x7FFF;
855 } else {
856 temp = 0x8000;
857 }
858 set_DSPControl_overflow_flag(1, 20, env);
859 }
860
861 return temp;
862 }
863
864 static inline uint32_t mipsdsp_sat32_sub(int32_t a, int32_t b,
865 CPUMIPSState *env)
866 {
867 int32_t temp;
868
869 temp = a - b;
870 if (MIPSDSP_OVERFLOW_SUB(a, b, temp, 0x80000000)) {
871 if (a >= 0) {
872 temp = 0x7FFFFFFF;
873 } else {
874 temp = 0x80000000;
875 }
876 set_DSPControl_overflow_flag(1, 20, env);
877 }
878
879 return temp & 0xFFFFFFFFull;
880 }
881
882 static inline uint16_t mipsdsp_rshift1_sub_q16(int16_t a, int16_t b)
883 {
884 int32_t temp;
885
886 temp = (int32_t)a - (int32_t)b;
887
888 return (temp >> 1) & 0x0000FFFF;
889 }
890
891 static inline uint16_t mipsdsp_rrshift1_sub_q16(int16_t a, int16_t b)
892 {
893 int32_t temp;
894
895 temp = (int32_t)a - (int32_t)b;
896 temp += 1;
897
898 return (temp >> 1) & 0x0000FFFF;
899 }
900
901 static inline uint32_t mipsdsp_rshift1_sub_q32(int32_t a, int32_t b)
902 {
903 int64_t temp;
904
905 temp = (int64_t)a - (int64_t)b;
906
907 return (temp >> 1) & 0xFFFFFFFFull;
908 }
909
910 static inline uint32_t mipsdsp_rrshift1_sub_q32(int32_t a, int32_t b)
911 {
912 int64_t temp;
913
914 temp = (int64_t)a - (int64_t)b;
915 temp += 1;
916
917 return (temp >> 1) & 0xFFFFFFFFull;
918 }
919
920 static inline uint16_t mipsdsp_sub_u16_u16(uint16_t a, uint16_t b,
921 CPUMIPSState *env)
922 {
923 uint8_t temp16;
924 uint32_t temp;
925
926 temp = (uint32_t)a - (uint32_t)b;
927 temp16 = (temp >> 16) & 0x01;
928 if (temp16 == 1) {
929 set_DSPControl_overflow_flag(1, 20, env);
930 }
931 return temp & 0x0000FFFF;
932 }
933
934 static inline uint16_t mipsdsp_satu16_sub_u16_u16(uint16_t a, uint16_t b,
935 CPUMIPSState *env)
936 {
937 uint8_t temp16;
938 uint32_t temp;
939
940 temp = (uint32_t)a - (uint32_t)b;
941 temp16 = (temp >> 16) & 0x01;
942
943 if (temp16 == 1) {
944 temp = 0x0000;
945 set_DSPControl_overflow_flag(1, 20, env);
946 }
947
948 return temp & 0x0000FFFF;
949 }
950
951 static inline uint8_t mipsdsp_sub_u8(uint8_t a, uint8_t b, CPUMIPSState *env)
952 {
953 uint8_t temp8;
954 uint16_t temp;
955
956 temp = (uint16_t)a - (uint16_t)b;
957 temp8 = (temp >> 8) & 0x01;
958 if (temp8 == 1) {
959 set_DSPControl_overflow_flag(1, 20, env);
960 }
961
962 return temp & 0x00FF;
963 }
964
965 static inline uint8_t mipsdsp_satu8_sub(uint8_t a, uint8_t b, CPUMIPSState *env)
966 {
967 uint8_t temp8;
968 uint16_t temp;
969
970 temp = (uint16_t)a - (uint16_t)b;
971 temp8 = (temp >> 8) & 0x01;
972 if (temp8 == 1) {
973 temp = 0x00;
974 set_DSPControl_overflow_flag(1, 20, env);
975 }
976
977 return temp & 0x00FF;
978 }
979
980 #ifdef TARGET_MIPS64
981 static inline uint32_t mipsdsp_sub32(int32_t a, int32_t b, CPUMIPSState *env)
982 {
983 int32_t temp;
984
985 temp = a - b;
986 if (MIPSDSP_OVERFLOW_SUB(a, b, temp, 0x80000000)) {
987 set_DSPControl_overflow_flag(1, 20, env);
988 }
989
990 return temp;
991 }
992
993 static inline int32_t mipsdsp_add_i32(int32_t a, int32_t b, CPUMIPSState *env)
994 {
995 int32_t temp;
996
997 temp = a + b;
998
999 if (MIPSDSP_OVERFLOW_ADD(a, b, temp, 0x80000000)) {
1000 set_DSPControl_overflow_flag(1, 20, env);
1001 }
1002
1003 return temp;
1004 }
1005 #endif
1006
1007 static inline int32_t mipsdsp_cmp_eq(int32_t a, int32_t b)
1008 {
1009 return a == b;
1010 }
1011
1012 static inline int32_t mipsdsp_cmp_le(int32_t a, int32_t b)
1013 {
1014 return a <= b;
1015 }
1016
1017 static inline int32_t mipsdsp_cmp_lt(int32_t a, int32_t b)
1018 {
1019 return a < b;
1020 }
1021
1022 static inline int32_t mipsdsp_cmpu_eq(uint32_t a, uint32_t b)
1023 {
1024 return a == b;
1025 }
1026
1027 static inline int32_t mipsdsp_cmpu_le(uint32_t a, uint32_t b)
1028 {
1029 return a <= b;
1030 }
1031
1032 static inline int32_t mipsdsp_cmpu_lt(uint32_t a, uint32_t b)
1033 {
1034 return a < b;
1035 }
1036 /*** MIPS DSP internal functions end ***/
1037
1038 #define MIPSDSP_LHI 0xFFFFFFFF00000000ull
1039 #define MIPSDSP_LLO 0x00000000FFFFFFFFull
1040 #define MIPSDSP_HI 0xFFFF0000
1041 #define MIPSDSP_LO 0x0000FFFF
1042 #define MIPSDSP_Q3 0xFF000000
1043 #define MIPSDSP_Q2 0x00FF0000
1044 #define MIPSDSP_Q1 0x0000FF00
1045 #define MIPSDSP_Q0 0x000000FF
1046
1047 #define MIPSDSP_SPLIT32_8(num, a, b, c, d) \
1048 do { \
1049 a = (num >> 24) & MIPSDSP_Q0; \
1050 b = (num >> 16) & MIPSDSP_Q0; \
1051 c = (num >> 8) & MIPSDSP_Q0; \
1052 d = num & MIPSDSP_Q0; \
1053 } while (0)
1054
1055 #define MIPSDSP_SPLIT32_16(num, a, b) \
1056 do { \
1057 a = (num >> 16) & MIPSDSP_LO; \
1058 b = num & MIPSDSP_LO; \
1059 } while (0)
1060
1061 #define MIPSDSP_RETURN32_8(a, b, c, d) ((target_long)(int32_t) \
1062 (((uint32_t)a << 24) | \
1063 (((uint32_t)b << 16) | \
1064 (((uint32_t)c << 8) | \
1065 ((uint32_t)d & 0xFF)))))
1066 #define MIPSDSP_RETURN32_16(a, b) ((target_long)(int32_t) \
1067 (((uint32_t)a << 16) | \
1068 ((uint32_t)b & 0xFFFF)))
1069
1070 #ifdef TARGET_MIPS64
1071 #define MIPSDSP_SPLIT64_16(num, a, b, c, d) \
1072 do { \
1073 a = (num >> 48) & MIPSDSP_LO; \
1074 b = (num >> 32) & MIPSDSP_LO; \
1075 c = (num >> 16) & MIPSDSP_LO; \
1076 d = num & MIPSDSP_LO; \
1077 } while (0)
1078
1079 #define MIPSDSP_SPLIT64_32(num, a, b) \
1080 do { \
1081 a = (num >> 32) & MIPSDSP_LLO; \
1082 b = num & MIPSDSP_LLO; \
1083 } while (0)
1084
1085 #define MIPSDSP_RETURN64_16(a, b, c, d) (((uint64_t)a << 48) | \
1086 ((uint64_t)b << 32) | \
1087 ((uint64_t)c << 16) | \
1088 (uint64_t)d)
1089 #define MIPSDSP_RETURN64_32(a, b) (((uint64_t)a << 32) | (uint64_t)b)
1090 #endif
1091
1092 /** DSP Arithmetic Sub-class insns **/
1093 #define MIPSDSP32_UNOP_ENV(name, func, element) \
1094 target_ulong helper_##name(target_ulong rt, CPUMIPSState *env) \
1095 { \
1096 DSP32Value dt; \
1097 unsigned int i; \
1098 \
1099 dt.sw[0] = rt; \
1100 \
1101 for (i = 0; i < ARRAY_SIZE(dt.element); i++) { \
1102 dt.element[i] = mipsdsp_##func(dt.element[i], env); \
1103 } \
1104 \
1105 return (target_long)dt.sw[0]; \
1106 }
1107 MIPSDSP32_UNOP_ENV(absq_s_ph, sat_abs16, sh)
1108 MIPSDSP32_UNOP_ENV(absq_s_qb, sat_abs8, sb)
1109 MIPSDSP32_UNOP_ENV(absq_s_w, sat_abs32, sw)
1110 #undef MIPSDSP32_UNOP_ENV
1111
1112 #if defined(TARGET_MIPS64)
1113 #define MIPSDSP64_UNOP_ENV(name, func, element) \
1114 target_ulong helper_##name(target_ulong rt, CPUMIPSState *env) \
1115 { \
1116 DSP64Value dt; \
1117 unsigned int i; \
1118 \
1119 dt.sl[0] = rt; \
1120 \
1121 for (i = 0; i < ARRAY_SIZE(dt.element); i++) { \
1122 dt.element[i] = mipsdsp_##func(dt.element[i], env); \
1123 } \
1124 \
1125 return dt.sl[0]; \
1126 }
1127 MIPSDSP64_UNOP_ENV(absq_s_ob, sat_abs8, sb)
1128 MIPSDSP64_UNOP_ENV(absq_s_qh, sat_abs16, sh)
1129 MIPSDSP64_UNOP_ENV(absq_s_pw, sat_abs32, sw)
1130 #undef MIPSDSP64_UNOP_ENV
1131 #endif
1132
1133 #define MIPSDSP32_BINOP(name, func, element) \
1134 target_ulong helper_##name(target_ulong rs, target_ulong rt) \
1135 { \
1136 DSP32Value ds, dt; \
1137 unsigned int i; \
1138 \
1139 ds.sw[0] = rs; \
1140 dt.sw[0] = rt; \
1141 \
1142 for (i = 0; i < ARRAY_SIZE(ds.element); i++) { \
1143 ds.element[i] = mipsdsp_##func(ds.element[i], dt.element[i]); \
1144 } \
1145 \
1146 return (target_long)ds.sw[0]; \
1147 }
1148 MIPSDSP32_BINOP(addqh_ph, rshift1_add_q16, sh);
1149 MIPSDSP32_BINOP(addqh_r_ph, rrshift1_add_q16, sh);
1150 MIPSDSP32_BINOP(addqh_r_w, rrshift1_add_q32, sw);
1151 MIPSDSP32_BINOP(addqh_w, rshift1_add_q32, sw);
1152 MIPSDSP32_BINOP(adduh_qb, rshift1_add_u8, ub);
1153 MIPSDSP32_BINOP(adduh_r_qb, rrshift1_add_u8, ub);
1154 MIPSDSP32_BINOP(subqh_ph, rshift1_sub_q16, sh);
1155 MIPSDSP32_BINOP(subqh_r_ph, rrshift1_sub_q16, sh);
1156 MIPSDSP32_BINOP(subqh_r_w, rrshift1_sub_q32, sw);
1157 MIPSDSP32_BINOP(subqh_w, rshift1_sub_q32, sw);
1158 #undef MIPSDSP32_BINOP
1159
1160 #define MIPSDSP32_BINOP_ENV(name, func, element) \
1161 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
1162 CPUMIPSState *env) \
1163 { \
1164 DSP32Value ds, dt; \
1165 unsigned int i; \
1166 \
1167 ds.sw[0] = rs; \
1168 dt.sw[0] = rt; \
1169 \
1170 for (i = 0 ; i < ARRAY_SIZE(ds.element); i++) { \
1171 ds.element[i] = mipsdsp_##func(ds.element[i], dt.element[i], env); \
1172 } \
1173 \
1174 return (target_long)ds.sw[0]; \
1175 }
1176 MIPSDSP32_BINOP_ENV(addq_ph, add_i16, sh)
1177 MIPSDSP32_BINOP_ENV(addq_s_ph, sat_add_i16, sh)
1178 MIPSDSP32_BINOP_ENV(addq_s_w, sat_add_i32, sw);
1179 MIPSDSP32_BINOP_ENV(addu_ph, add_u16, sh)
1180 MIPSDSP32_BINOP_ENV(addu_qb, add_u8, ub);
1181 MIPSDSP32_BINOP_ENV(addu_s_ph, sat_add_u16, sh)
1182 MIPSDSP32_BINOP_ENV(addu_s_qb, sat_add_u8, ub);
1183 MIPSDSP32_BINOP_ENV(subq_ph, sub_i16, sh);
1184 MIPSDSP32_BINOP_ENV(subq_s_ph, sat16_sub, sh);
1185 MIPSDSP32_BINOP_ENV(subq_s_w, sat32_sub, sw);
1186 MIPSDSP32_BINOP_ENV(subu_ph, sub_u16_u16, sh);
1187 MIPSDSP32_BINOP_ENV(subu_qb, sub_u8, ub);
1188 MIPSDSP32_BINOP_ENV(subu_s_ph, satu16_sub_u16_u16, sh);
1189 MIPSDSP32_BINOP_ENV(subu_s_qb, satu8_sub, ub);
1190 #undef MIPSDSP32_BINOP_ENV
1191
1192 #ifdef TARGET_MIPS64
1193 #define MIPSDSP64_BINOP(name, func, element) \
1194 target_ulong helper_##name(target_ulong rs, target_ulong rt) \
1195 { \
1196 DSP64Value ds, dt; \
1197 unsigned int i; \
1198 \
1199 ds.sl[0] = rs; \
1200 dt.sl[0] = rt; \
1201 \
1202 for (i = 0 ; i < ARRAY_SIZE(ds.element); i++) { \
1203 ds.element[i] = mipsdsp_##func(ds.element[i], dt.element[i]); \
1204 } \
1205 \
1206 return ds.sl[0]; \
1207 }
1208 MIPSDSP64_BINOP(adduh_ob, rshift1_add_u8, ub);
1209 MIPSDSP64_BINOP(adduh_r_ob, rrshift1_add_u8, ub);
1210 MIPSDSP64_BINOP(subuh_ob, rshift1_sub_u8, ub);
1211 MIPSDSP64_BINOP(subuh_r_ob, rrshift1_sub_u8, ub);
1212 #undef MIPSDSP64_BINOP
1213
1214 #define MIPSDSP64_BINOP_ENV(name, func, element) \
1215 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
1216 CPUMIPSState *env) \
1217 { \
1218 DSP64Value ds, dt; \
1219 unsigned int i; \
1220 \
1221 ds.sl[0] = rs; \
1222 dt.sl[0] = rt; \
1223 \
1224 for (i = 0 ; i < ARRAY_SIZE(ds.element); i++) { \
1225 ds.element[i] = mipsdsp_##func(ds.element[i], dt.element[i], env); \
1226 } \
1227 \
1228 return ds.sl[0]; \
1229 }
1230 MIPSDSP64_BINOP_ENV(addq_pw, add_i32, sw);
1231 MIPSDSP64_BINOP_ENV(addq_qh, add_i16, sh);
1232 MIPSDSP64_BINOP_ENV(addq_s_pw, sat_add_i32, sw);
1233 MIPSDSP64_BINOP_ENV(addq_s_qh, sat_add_i16, sh);
1234 MIPSDSP64_BINOP_ENV(addu_ob, add_u8, uh);
1235 MIPSDSP64_BINOP_ENV(addu_qh, add_u16, uh);
1236 MIPSDSP64_BINOP_ENV(addu_s_ob, sat_add_u8, uh);
1237 MIPSDSP64_BINOP_ENV(addu_s_qh, sat_add_u16, uh);
1238 MIPSDSP64_BINOP_ENV(subq_pw, sub32, sw);
1239 MIPSDSP64_BINOP_ENV(subq_qh, sub_i16, sh);
1240 MIPSDSP64_BINOP_ENV(subq_s_pw, sat32_sub, sw);
1241 MIPSDSP64_BINOP_ENV(subq_s_qh, sat16_sub, sh);
1242 MIPSDSP64_BINOP_ENV(subu_ob, sub_u8, uh);
1243 MIPSDSP64_BINOP_ENV(subu_qh, sub_u16_u16, uh);
1244 MIPSDSP64_BINOP_ENV(subu_s_ob, satu8_sub, uh);
1245 MIPSDSP64_BINOP_ENV(subu_s_qh, satu16_sub_u16_u16, uh);
1246 #undef MIPSDSP64_BINOP_ENV
1247
1248 #endif
1249
1250 #define SUBUH_QB(name, var) \
1251 target_ulong helper_##name##_qb(target_ulong rs, target_ulong rt) \
1252 { \
1253 uint8_t rs3, rs2, rs1, rs0; \
1254 uint8_t rt3, rt2, rt1, rt0; \
1255 uint8_t tempD, tempC, tempB, tempA; \
1256 \
1257 MIPSDSP_SPLIT32_8(rs, rs3, rs2, rs1, rs0); \
1258 MIPSDSP_SPLIT32_8(rt, rt3, rt2, rt1, rt0); \
1259 \
1260 tempD = ((uint16_t)rs3 - (uint16_t)rt3 + var) >> 1; \
1261 tempC = ((uint16_t)rs2 - (uint16_t)rt2 + var) >> 1; \
1262 tempB = ((uint16_t)rs1 - (uint16_t)rt1 + var) >> 1; \
1263 tempA = ((uint16_t)rs0 - (uint16_t)rt0 + var) >> 1; \
1264 \
1265 return ((uint32_t)tempD << 24) | ((uint32_t)tempC << 16) | \
1266 ((uint32_t)tempB << 8) | ((uint32_t)tempA); \
1267 }
1268
1269 SUBUH_QB(subuh, 0);
1270 SUBUH_QB(subuh_r, 1);
1271
1272 #undef SUBUH_QB
1273
1274 target_ulong helper_addsc(target_ulong rs, target_ulong rt, CPUMIPSState *env)
1275 {
1276 uint64_t temp, tempRs, tempRt;
1277 bool flag;
1278
1279 tempRs = (uint64_t)rs & MIPSDSP_LLO;
1280 tempRt = (uint64_t)rt & MIPSDSP_LLO;
1281
1282 temp = tempRs + tempRt;
1283 flag = (temp & 0x0100000000ull) >> 32;
1284 set_DSPControl_carryflag(flag, env);
1285
1286 return (target_long)(int32_t)(temp & MIPSDSP_LLO);
1287 }
1288
1289 target_ulong helper_addwc(target_ulong rs, target_ulong rt, CPUMIPSState *env)
1290 {
1291 uint32_t rd;
1292 int32_t temp32, temp31;
1293 int64_t tempL;
1294
1295 tempL = (int64_t)(int32_t)rs + (int64_t)(int32_t)rt +
1296 get_DSPControl_carryflag(env);
1297 temp31 = (tempL >> 31) & 0x01;
1298 temp32 = (tempL >> 32) & 0x01;
1299
1300 if (temp31 != temp32) {
1301 set_DSPControl_overflow_flag(1, 20, env);
1302 }
1303
1304 rd = tempL & MIPSDSP_LLO;
1305
1306 return (target_long)(int32_t)rd;
1307 }
1308
1309 target_ulong helper_modsub(target_ulong rs, target_ulong rt)
1310 {
1311 int32_t decr;
1312 uint16_t lastindex;
1313 target_ulong rd;
1314
1315 decr = rt & MIPSDSP_Q0;
1316 lastindex = (rt >> 8) & MIPSDSP_LO;
1317
1318 if ((rs & MIPSDSP_LLO) == 0x00000000) {
1319 rd = (target_ulong)lastindex;
1320 } else {
1321 rd = rs - decr;
1322 }
1323
1324 return rd;
1325 }
1326
1327 target_ulong helper_raddu_w_qb(target_ulong rs)
1328 {
1329 target_ulong ret = 0;
1330 DSP32Value ds;
1331 unsigned int i;
1332
1333 ds.uw[0] = rs;
1334 for (i = 0; i < 4; i++) {
1335 ret += ds.ub[i];
1336 }
1337 return ret;
1338 }
1339
1340 #if defined(TARGET_MIPS64)
1341 target_ulong helper_raddu_l_ob(target_ulong rs)
1342 {
1343 target_ulong ret = 0;
1344 DSP64Value ds;
1345 unsigned int i;
1346
1347 ds.ul[0] = rs;
1348 for (i = 0; i < 8; i++) {
1349 ret += ds.ub[i];
1350 }
1351 return ret;
1352 }
1353 #endif
1354
1355 #define PRECR_QB_PH(name, a, b)\
1356 target_ulong helper_##name##_qb_ph(target_ulong rs, target_ulong rt) \
1357 { \
1358 uint8_t tempD, tempC, tempB, tempA; \
1359 \
1360 tempD = (rs >> a) & MIPSDSP_Q0; \
1361 tempC = (rs >> b) & MIPSDSP_Q0; \
1362 tempB = (rt >> a) & MIPSDSP_Q0; \
1363 tempA = (rt >> b) & MIPSDSP_Q0; \
1364 \
1365 return MIPSDSP_RETURN32_8(tempD, tempC, tempB, tempA); \
1366 }
1367
1368 PRECR_QB_PH(precr, 16, 0);
1369 PRECR_QB_PH(precrq, 24, 8);
1370
1371 #undef PRECR_QB_OH
1372
1373 target_ulong helper_precr_sra_ph_w(uint32_t sa, target_ulong rs,
1374 target_ulong rt)
1375 {
1376 uint16_t tempB, tempA;
1377
1378 tempB = ((int32_t)rt >> sa) & MIPSDSP_LO;
1379 tempA = ((int32_t)rs >> sa) & MIPSDSP_LO;
1380
1381 return MIPSDSP_RETURN32_16(tempB, tempA);
1382 }
1383
1384 target_ulong helper_precr_sra_r_ph_w(uint32_t sa,
1385 target_ulong rs, target_ulong rt)
1386 {
1387 uint64_t tempB, tempA;
1388
1389 /* If sa = 0, then (sa - 1) = -1 will case shift error, so we need else. */
1390 if (sa == 0) {
1391 tempB = (rt & MIPSDSP_LO) << 1;
1392 tempA = (rs & MIPSDSP_LO) << 1;
1393 } else {
1394 tempB = ((int32_t)rt >> (sa - 1)) + 1;
1395 tempA = ((int32_t)rs >> (sa - 1)) + 1;
1396 }
1397 rt = (((tempB >> 1) & MIPSDSP_LO) << 16) | ((tempA >> 1) & MIPSDSP_LO);
1398
1399 return (target_long)(int32_t)rt;
1400 }
1401
1402 target_ulong helper_precrq_ph_w(target_ulong rs, target_ulong rt)
1403 {
1404 uint16_t tempB, tempA;
1405
1406 tempB = (rs & MIPSDSP_HI) >> 16;
1407 tempA = (rt & MIPSDSP_HI) >> 16;
1408
1409 return MIPSDSP_RETURN32_16(tempB, tempA);
1410 }
1411
1412 target_ulong helper_precrq_rs_ph_w(target_ulong rs, target_ulong rt,
1413 CPUMIPSState *env)
1414 {
1415 uint16_t tempB, tempA;
1416
1417 tempB = mipsdsp_trunc16_sat16_round(rs, env);
1418 tempA = mipsdsp_trunc16_sat16_round(rt, env);
1419
1420 return MIPSDSP_RETURN32_16(tempB, tempA);
1421 }
1422
1423 #if defined(TARGET_MIPS64)
1424 target_ulong helper_precr_ob_qh(target_ulong rs, target_ulong rt)
1425 {
1426 uint8_t rs6, rs4, rs2, rs0;
1427 uint8_t rt6, rt4, rt2, rt0;
1428 uint64_t temp;
1429
1430 rs6 = (rs >> 48) & MIPSDSP_Q0;
1431 rs4 = (rs >> 32) & MIPSDSP_Q0;
1432 rs2 = (rs >> 16) & MIPSDSP_Q0;
1433 rs0 = rs & MIPSDSP_Q0;
1434 rt6 = (rt >> 48) & MIPSDSP_Q0;
1435 rt4 = (rt >> 32) & MIPSDSP_Q0;
1436 rt2 = (rt >> 16) & MIPSDSP_Q0;
1437 rt0 = rt & MIPSDSP_Q0;
1438
1439 temp = ((uint64_t)rs6 << 56) | ((uint64_t)rs4 << 48) |
1440 ((uint64_t)rs2 << 40) | ((uint64_t)rs0 << 32) |
1441 ((uint64_t)rt6 << 24) | ((uint64_t)rt4 << 16) |
1442 ((uint64_t)rt2 << 8) | (uint64_t)rt0;
1443
1444 return temp;
1445 }
1446
1447 #define PRECR_QH_PW(name, var) \
1448 target_ulong helper_precr_##name##_qh_pw(target_ulong rs, target_ulong rt, \
1449 uint32_t sa) \
1450 { \
1451 uint16_t rs3, rs2, rs1, rs0; \
1452 uint16_t rt3, rt2, rt1, rt0; \
1453 uint16_t tempD, tempC, tempB, tempA; \
1454 \
1455 MIPSDSP_SPLIT64_16(rs, rs3, rs2, rs1, rs0); \
1456 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0); \
1457 \
1458 /* When sa = 0, we use rt2, rt0, rs2, rs0; \
1459 * when sa != 0, we use rt3, rt1, rs3, rs1. */ \
1460 if (sa == 0) { \
1461 tempD = rt2 << var; \
1462 tempC = rt0 << var; \
1463 tempB = rs2 << var; \
1464 tempA = rs0 << var; \
1465 } else { \
1466 tempD = (((int16_t)rt3 >> sa) + var) >> var; \
1467 tempC = (((int16_t)rt1 >> sa) + var) >> var; \
1468 tempB = (((int16_t)rs3 >> sa) + var) >> var; \
1469 tempA = (((int16_t)rs1 >> sa) + var) >> var; \
1470 } \
1471 \
1472 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA); \
1473 }
1474
1475 PRECR_QH_PW(sra, 0);
1476 PRECR_QH_PW(sra_r, 1);
1477
1478 #undef PRECR_QH_PW
1479
1480 target_ulong helper_precrq_ob_qh(target_ulong rs, target_ulong rt)
1481 {
1482 uint8_t rs6, rs4, rs2, rs0;
1483 uint8_t rt6, rt4, rt2, rt0;
1484 uint64_t temp;
1485
1486 rs6 = (rs >> 56) & MIPSDSP_Q0;
1487 rs4 = (rs >> 40) & MIPSDSP_Q0;
1488 rs2 = (rs >> 24) & MIPSDSP_Q0;
1489 rs0 = (rs >> 8) & MIPSDSP_Q0;
1490 rt6 = (rt >> 56) & MIPSDSP_Q0;
1491 rt4 = (rt >> 40) & MIPSDSP_Q0;
1492 rt2 = (rt >> 24) & MIPSDSP_Q0;
1493 rt0 = (rt >> 8) & MIPSDSP_Q0;
1494
1495 temp = ((uint64_t)rs6 << 56) | ((uint64_t)rs4 << 48) |
1496 ((uint64_t)rs2 << 40) | ((uint64_t)rs0 << 32) |
1497 ((uint64_t)rt6 << 24) | ((uint64_t)rt4 << 16) |
1498 ((uint64_t)rt2 << 8) | (uint64_t)rt0;
1499
1500 return temp;
1501 }
1502
1503 target_ulong helper_precrq_qh_pw(target_ulong rs, target_ulong rt)
1504 {
1505 uint16_t tempD, tempC, tempB, tempA;
1506
1507 tempD = (rs >> 48) & MIPSDSP_LO;
1508 tempC = (rs >> 16) & MIPSDSP_LO;
1509 tempB = (rt >> 48) & MIPSDSP_LO;
1510 tempA = (rt >> 16) & MIPSDSP_LO;
1511
1512 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA);
1513 }
1514
1515 target_ulong helper_precrq_rs_qh_pw(target_ulong rs, target_ulong rt,
1516 CPUMIPSState *env)
1517 {
1518 uint32_t rs2, rs0;
1519 uint32_t rt2, rt0;
1520 uint16_t tempD, tempC, tempB, tempA;
1521
1522 rs2 = (rs >> 32) & MIPSDSP_LLO;
1523 rs0 = rs & MIPSDSP_LLO;
1524 rt2 = (rt >> 32) & MIPSDSP_LLO;
1525 rt0 = rt & MIPSDSP_LLO;
1526
1527 tempD = mipsdsp_trunc16_sat16_round(rs2, env);
1528 tempC = mipsdsp_trunc16_sat16_round(rs0, env);
1529 tempB = mipsdsp_trunc16_sat16_round(rt2, env);
1530 tempA = mipsdsp_trunc16_sat16_round(rt0, env);
1531
1532 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA);
1533 }
1534
1535 target_ulong helper_precrq_pw_l(target_ulong rs, target_ulong rt)
1536 {
1537 uint32_t tempB, tempA;
1538
1539 tempB = (rs >> 32) & MIPSDSP_LLO;
1540 tempA = (rt >> 32) & MIPSDSP_LLO;
1541
1542 return MIPSDSP_RETURN64_32(tempB, tempA);
1543 }
1544 #endif
1545
1546 target_ulong helper_precrqu_s_qb_ph(target_ulong rs, target_ulong rt,
1547 CPUMIPSState *env)
1548 {
1549 uint8_t tempD, tempC, tempB, tempA;
1550 uint16_t rsh, rsl, rth, rtl;
1551
1552 rsh = (rs & MIPSDSP_HI) >> 16;
1553 rsl = rs & MIPSDSP_LO;
1554 rth = (rt & MIPSDSP_HI) >> 16;
1555 rtl = rt & MIPSDSP_LO;
1556
1557 tempD = mipsdsp_sat8_reduce_precision(rsh, env);
1558 tempC = mipsdsp_sat8_reduce_precision(rsl, env);
1559 tempB = mipsdsp_sat8_reduce_precision(rth, env);
1560 tempA = mipsdsp_sat8_reduce_precision(rtl, env);
1561
1562 return MIPSDSP_RETURN32_8(tempD, tempC, tempB, tempA);
1563 }
1564
1565 #if defined(TARGET_MIPS64)
1566 target_ulong helper_precrqu_s_ob_qh(target_ulong rs, target_ulong rt,
1567 CPUMIPSState *env)
1568 {
1569 int i;
1570 uint16_t rs3, rs2, rs1, rs0;
1571 uint16_t rt3, rt2, rt1, rt0;
1572 uint8_t temp[8];
1573 uint64_t result;
1574
1575 result = 0;
1576
1577 MIPSDSP_SPLIT64_16(rs, rs3, rs2, rs1, rs0);
1578 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0);
1579
1580 temp[7] = mipsdsp_sat8_reduce_precision(rs3, env);
1581 temp[6] = mipsdsp_sat8_reduce_precision(rs2, env);
1582 temp[5] = mipsdsp_sat8_reduce_precision(rs1, env);
1583 temp[4] = mipsdsp_sat8_reduce_precision(rs0, env);
1584 temp[3] = mipsdsp_sat8_reduce_precision(rt3, env);
1585 temp[2] = mipsdsp_sat8_reduce_precision(rt2, env);
1586 temp[1] = mipsdsp_sat8_reduce_precision(rt1, env);
1587 temp[0] = mipsdsp_sat8_reduce_precision(rt0, env);
1588
1589 for (i = 0; i < 8; i++) {
1590 result |= (uint64_t)temp[i] << (8 * i);
1591 }
1592
1593 return result;
1594 }
1595
1596 #define PRECEQ_PW(name, a, b) \
1597 target_ulong helper_preceq_pw_##name(target_ulong rt) \
1598 { \
1599 uint16_t tempB, tempA; \
1600 uint32_t tempBI, tempAI; \
1601 \
1602 tempB = (rt >> a) & MIPSDSP_LO; \
1603 tempA = (rt >> b) & MIPSDSP_LO; \
1604 \
1605 tempBI = (uint32_t)tempB << 16; \
1606 tempAI = (uint32_t)tempA << 16; \
1607 \
1608 return MIPSDSP_RETURN64_32(tempBI, tempAI); \
1609 }
1610
1611 PRECEQ_PW(qhl, 48, 32);
1612 PRECEQ_PW(qhr, 16, 0);
1613 PRECEQ_PW(qhla, 48, 16);
1614 PRECEQ_PW(qhra, 32, 0);
1615
1616 #undef PRECEQ_PW
1617
1618 #endif
1619
1620 #define PRECEQU_PH(name, a, b) \
1621 target_ulong helper_precequ_ph_##name(target_ulong rt) \
1622 { \
1623 uint16_t tempB, tempA; \
1624 \
1625 tempB = (rt >> a) & MIPSDSP_Q0; \
1626 tempA = (rt >> b) & MIPSDSP_Q0; \
1627 \
1628 tempB = tempB << 7; \
1629 tempA = tempA << 7; \
1630 \
1631 return MIPSDSP_RETURN32_16(tempB, tempA); \
1632 }
1633
1634 PRECEQU_PH(qbl, 24, 16);
1635 PRECEQU_PH(qbr, 8, 0);
1636 PRECEQU_PH(qbla, 24, 8);
1637 PRECEQU_PH(qbra, 16, 0);
1638
1639 #undef PRECEQU_PH
1640
1641 #if defined(TARGET_MIPS64)
1642 #define PRECEQU_QH(name, a, b, c, d) \
1643 target_ulong helper_precequ_qh_##name(target_ulong rt) \
1644 { \
1645 uint16_t tempD, tempC, tempB, tempA; \
1646 \
1647 tempD = (rt >> a) & MIPSDSP_Q0; \
1648 tempC = (rt >> b) & MIPSDSP_Q0; \
1649 tempB = (rt >> c) & MIPSDSP_Q0; \
1650 tempA = (rt >> d) & MIPSDSP_Q0; \
1651 \
1652 tempD = tempD << 7; \
1653 tempC = tempC << 7; \
1654 tempB = tempB << 7; \
1655 tempA = tempA << 7; \
1656 \
1657 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA); \
1658 }
1659
1660 PRECEQU_QH(obl, 56, 48, 40, 32);
1661 PRECEQU_QH(obr, 24, 16, 8, 0);
1662 PRECEQU_QH(obla, 56, 40, 24, 8);
1663 PRECEQU_QH(obra, 48, 32, 16, 0);
1664
1665 #undef PRECEQU_QH
1666
1667 #endif
1668
1669 #define PRECEU_PH(name, a, b) \
1670 target_ulong helper_preceu_ph_##name(target_ulong rt) \
1671 { \
1672 uint16_t tempB, tempA; \
1673 \
1674 tempB = (rt >> a) & MIPSDSP_Q0; \
1675 tempA = (rt >> b) & MIPSDSP_Q0; \
1676 \
1677 return MIPSDSP_RETURN32_16(tempB, tempA); \
1678 }
1679
1680 PRECEU_PH(qbl, 24, 16);
1681 PRECEU_PH(qbr, 8, 0);
1682 PRECEU_PH(qbla, 24, 8);
1683 PRECEU_PH(qbra, 16, 0);
1684
1685 #undef PRECEU_PH
1686
1687 #if defined(TARGET_MIPS64)
1688 #define PRECEU_QH(name, a, b, c, d) \
1689 target_ulong helper_preceu_qh_##name(target_ulong rt) \
1690 { \
1691 uint16_t tempD, tempC, tempB, tempA; \
1692 \
1693 tempD = (rt >> a) & MIPSDSP_Q0; \
1694 tempC = (rt >> b) & MIPSDSP_Q0; \
1695 tempB = (rt >> c) & MIPSDSP_Q0; \
1696 tempA = (rt >> d) & MIPSDSP_Q0; \
1697 \
1698 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA); \
1699 }
1700
1701 PRECEU_QH(obl, 56, 48, 40, 32);
1702 PRECEU_QH(obr, 24, 16, 8, 0);
1703 PRECEU_QH(obla, 56, 40, 24, 8);
1704 PRECEU_QH(obra, 48, 32, 16, 0);
1705
1706 #undef PRECEU_QH
1707
1708 #endif
1709
1710 /** DSP GPR-Based Shift Sub-class insns **/
1711 #define SHIFT_QB(name, func) \
1712 target_ulong helper_##name##_qb(target_ulong sa, target_ulong rt) \
1713 { \
1714 uint8_t rt3, rt2, rt1, rt0; \
1715 \
1716 sa = sa & 0x07; \
1717 \
1718 MIPSDSP_SPLIT32_8(rt, rt3, rt2, rt1, rt0); \
1719 \
1720 rt3 = mipsdsp_##func(rt3, sa); \
1721 rt2 = mipsdsp_##func(rt2, sa); \
1722 rt1 = mipsdsp_##func(rt1, sa); \
1723 rt0 = mipsdsp_##func(rt0, sa); \
1724 \
1725 return MIPSDSP_RETURN32_8(rt3, rt2, rt1, rt0); \
1726 }
1727
1728 #define SHIFT_QB_ENV(name, func) \
1729 target_ulong helper_##name##_qb(target_ulong sa, target_ulong rt,\
1730 CPUMIPSState *env) \
1731 { \
1732 uint8_t rt3, rt2, rt1, rt0; \
1733 \
1734 sa = sa & 0x07; \
1735 \
1736 MIPSDSP_SPLIT32_8(rt, rt3, rt2, rt1, rt0); \
1737 \
1738 rt3 = mipsdsp_##func(rt3, sa, env); \
1739 rt2 = mipsdsp_##func(rt2, sa, env); \
1740 rt1 = mipsdsp_##func(rt1, sa, env); \
1741 rt0 = mipsdsp_##func(rt0, sa, env); \
1742 \
1743 return MIPSDSP_RETURN32_8(rt3, rt2, rt1, rt0); \
1744 }
1745
1746 SHIFT_QB_ENV(shll, lshift8);
1747 SHIFT_QB(shrl, rshift_u8);
1748
1749 SHIFT_QB(shra, rashift8);
1750 SHIFT_QB(shra_r, rnd8_rashift);
1751
1752 #undef SHIFT_QB
1753 #undef SHIFT_QB_ENV
1754
1755 #if defined(TARGET_MIPS64)
1756 #define SHIFT_OB(name, func) \
1757 target_ulong helper_##name##_ob(target_ulong rt, target_ulong sa) \
1758 { \
1759 int i; \
1760 uint8_t rt_t[8]; \
1761 uint64_t temp; \
1762 \
1763 sa = sa & 0x07; \
1764 temp = 0; \
1765 \
1766 for (i = 0; i < 8; i++) { \
1767 rt_t[i] = (rt >> (8 * i)) & MIPSDSP_Q0; \
1768 rt_t[i] = mipsdsp_##func(rt_t[i], sa); \
1769 temp |= (uint64_t)rt_t[i] << (8 * i); \
1770 } \
1771 \
1772 return temp; \
1773 }
1774
1775 #define SHIFT_OB_ENV(name, func) \
1776 target_ulong helper_##name##_ob(target_ulong rt, target_ulong sa, \
1777 CPUMIPSState *env) \
1778 { \
1779 int i; \
1780 uint8_t rt_t[8]; \
1781 uint64_t temp; \
1782 \
1783 sa = sa & 0x07; \
1784 temp = 0; \
1785 \
1786 for (i = 0; i < 8; i++) { \
1787 rt_t[i] = (rt >> (8 * i)) & MIPSDSP_Q0; \
1788 rt_t[i] = mipsdsp_##func(rt_t[i], sa, env); \
1789 temp |= (uint64_t)rt_t[i] << (8 * i); \
1790 } \
1791 \
1792 return temp; \
1793 }
1794
1795 SHIFT_OB_ENV(shll, lshift8);
1796 SHIFT_OB(shrl, rshift_u8);
1797
1798 SHIFT_OB(shra, rashift8);
1799 SHIFT_OB(shra_r, rnd8_rashift);
1800
1801 #undef SHIFT_OB
1802 #undef SHIFT_OB_ENV
1803
1804 #endif
1805
1806 #define SHIFT_PH(name, func) \
1807 target_ulong helper_##name##_ph(target_ulong sa, target_ulong rt, \
1808 CPUMIPSState *env) \
1809 { \
1810 uint16_t rth, rtl; \
1811 \
1812 sa = sa & 0x0F; \
1813 \
1814 MIPSDSP_SPLIT32_16(rt, rth, rtl); \
1815 \
1816 rth = mipsdsp_##func(rth, sa, env); \
1817 rtl = mipsdsp_##func(rtl, sa, env); \
1818 \
1819 return MIPSDSP_RETURN32_16(rth, rtl); \
1820 }
1821
1822 SHIFT_PH(shll, lshift16);
1823 SHIFT_PH(shll_s, sat16_lshift);
1824
1825 #undef SHIFT_PH
1826
1827 #if defined(TARGET_MIPS64)
1828 #define SHIFT_QH(name, func) \
1829 target_ulong helper_##name##_qh(target_ulong rt, target_ulong sa) \
1830 { \
1831 uint16_t rt3, rt2, rt1, rt0; \
1832 \
1833 sa = sa & 0x0F; \
1834 \
1835 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0); \
1836 \
1837 rt3 = mipsdsp_##func(rt3, sa); \
1838 rt2 = mipsdsp_##func(rt2, sa); \
1839 rt1 = mipsdsp_##func(rt1, sa); \
1840 rt0 = mipsdsp_##func(rt0, sa); \
1841 \
1842 return MIPSDSP_RETURN64_16(rt3, rt2, rt1, rt0); \
1843 }
1844
1845 #define SHIFT_QH_ENV(name, func) \
1846 target_ulong helper_##name##_qh(target_ulong rt, target_ulong sa, \
1847 CPUMIPSState *env) \
1848 { \
1849 uint16_t rt3, rt2, rt1, rt0; \
1850 \
1851 sa = sa & 0x0F; \
1852 \
1853 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0); \
1854 \
1855 rt3 = mipsdsp_##func(rt3, sa, env); \
1856 rt2 = mipsdsp_##func(rt2, sa, env); \
1857 rt1 = mipsdsp_##func(rt1, sa, env); \
1858 rt0 = mipsdsp_##func(rt0, sa, env); \
1859 \
1860 return MIPSDSP_RETURN64_16(rt3, rt2, rt1, rt0); \
1861 }
1862
1863 SHIFT_QH_ENV(shll, lshift16);
1864 SHIFT_QH_ENV(shll_s, sat16_lshift);
1865
1866 SHIFT_QH(shrl, rshift_u16);
1867 SHIFT_QH(shra, rashift16);
1868 SHIFT_QH(shra_r, rnd16_rashift);
1869
1870 #undef SHIFT_QH
1871 #undef SHIFT_QH_ENV
1872
1873 #endif
1874
1875 #define SHIFT_W(name, func) \
1876 target_ulong helper_##name##_w(target_ulong sa, target_ulong rt) \
1877 { \
1878 uint32_t temp; \
1879 \
1880 sa = sa & 0x1F; \
1881 temp = mipsdsp_##func(rt, sa); \
1882 \
1883 return (target_long)(int32_t)temp; \
1884 }
1885
1886 #define SHIFT_W_ENV(name, func) \
1887 target_ulong helper_##name##_w(target_ulong sa, target_ulong rt, \
1888 CPUMIPSState *env) \
1889 { \
1890 uint32_t temp; \
1891 \
1892 sa = sa & 0x1F; \
1893 temp = mipsdsp_##func(rt, sa, env); \
1894 \
1895 return (target_long)(int32_t)temp; \
1896 }
1897
1898 SHIFT_W_ENV(shll_s, sat32_lshift);
1899 SHIFT_W(shra_r, rnd32_rashift);
1900
1901 #undef SHIFT_W
1902 #undef SHIFT_W_ENV
1903
1904 #if defined(TARGET_MIPS64)
1905 #define SHIFT_PW(name, func) \
1906 target_ulong helper_##name##_pw(target_ulong rt, target_ulong sa) \
1907 { \
1908 uint32_t rt1, rt0; \
1909 \
1910 sa = sa & 0x1F; \
1911 MIPSDSP_SPLIT64_32(rt, rt1, rt0); \
1912 \
1913 rt1 = mipsdsp_##func(rt1, sa); \
1914 rt0 = mipsdsp_##func(rt0, sa); \
1915 \
1916 return MIPSDSP_RETURN64_32(rt1, rt0); \
1917 }
1918
1919 #define SHIFT_PW_ENV(name, func) \
1920 target_ulong helper_##name##_pw(target_ulong rt, target_ulong sa, \
1921 CPUMIPSState *env) \
1922 { \
1923 uint32_t rt1, rt0; \
1924 \
1925 sa = sa & 0x1F; \
1926 MIPSDSP_SPLIT64_32(rt, rt1, rt0); \
1927 \
1928 rt1 = mipsdsp_##func(rt1, sa, env); \
1929 rt0 = mipsdsp_##func(rt0, sa, env); \
1930 \
1931 return MIPSDSP_RETURN64_32(rt1, rt0); \
1932 }
1933
1934 SHIFT_PW_ENV(shll, lshift32);
1935 SHIFT_PW_ENV(shll_s, sat32_lshift);
1936
1937 SHIFT_PW(shra, rashift32);
1938 SHIFT_PW(shra_r, rnd32_rashift);
1939
1940 #undef SHIFT_PW
1941 #undef SHIFT_PW_ENV
1942
1943 #endif
1944
1945 #define SHIFT_PH(name, func) \
1946 target_ulong helper_##name##_ph(target_ulong sa, target_ulong rt) \
1947 { \
1948 uint16_t rth, rtl; \
1949 \
1950 sa = sa & 0x0F; \
1951 \
1952 MIPSDSP_SPLIT32_16(rt, rth, rtl); \
1953 \
1954 rth = mipsdsp_##func(rth, sa); \
1955 rtl = mipsdsp_##func(rtl, sa); \
1956 \
1957 return MIPSDSP_RETURN32_16(rth, rtl); \
1958 }
1959
1960 SHIFT_PH(shrl, rshift_u16);
1961 SHIFT_PH(shra, rashift16);
1962 SHIFT_PH(shra_r, rnd16_rashift);
1963
1964 #undef SHIFT_PH
1965
1966 /** DSP Multiply Sub-class insns **/
1967 /* Return value made up by two 16bits value.
1968 * FIXME give the macro a better name.
1969 */
1970 #define MUL_RETURN32_16_PH(name, func, \
1971 rsmov1, rsmov2, rsfilter, \
1972 rtmov1, rtmov2, rtfilter) \
1973 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
1974 CPUMIPSState *env) \
1975 { \
1976 uint16_t rsB, rsA, rtB, rtA; \
1977 \
1978 rsB = (rs >> rsmov1) & rsfilter; \
1979 rsA = (rs >> rsmov2) & rsfilter; \
1980 rtB = (rt >> rtmov1) & rtfilter; \
1981 rtA = (rt >> rtmov2) & rtfilter; \
1982 \
1983 rsB = mipsdsp_##func(rsB, rtB, env); \
1984 rsA = mipsdsp_##func(rsA, rtA, env); \
1985 \
1986 return MIPSDSP_RETURN32_16(rsB, rsA); \
1987 }
1988
1989 MUL_RETURN32_16_PH(muleu_s_ph_qbl, mul_u8_u16, \
1990 24, 16, MIPSDSP_Q0, \
1991 16, 0, MIPSDSP_LO);
1992 MUL_RETURN32_16_PH(muleu_s_ph_qbr, mul_u8_u16, \
1993 8, 0, MIPSDSP_Q0, \
1994 16, 0, MIPSDSP_LO);
1995 MUL_RETURN32_16_PH(mulq_rs_ph, rndq15_mul_q15_q15, \
1996 16, 0, MIPSDSP_LO, \
1997 16, 0, MIPSDSP_LO);
1998 MUL_RETURN32_16_PH(mul_ph, mul_i16_i16, \
1999 16, 0, MIPSDSP_LO, \
2000 16, 0, MIPSDSP_LO);
2001 MUL_RETURN32_16_PH(mul_s_ph, sat16_mul_i16_i16, \
2002 16, 0, MIPSDSP_LO, \
2003 16, 0, MIPSDSP_LO);
2004 MUL_RETURN32_16_PH(mulq_s_ph, sat16_mul_q15_q15, \
2005 16, 0, MIPSDSP_LO, \
2006 16, 0, MIPSDSP_LO);
2007
2008 #undef MUL_RETURN32_16_PH
2009
2010 #define MUL_RETURN32_32_ph(name, func, movbits) \
2011 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
2012 CPUMIPSState *env) \
2013 { \
2014 int16_t rsh, rth; \
2015 int32_t temp; \
2016 \
2017 rsh = (rs >> movbits) & MIPSDSP_LO; \
2018 rth = (rt >> movbits) & MIPSDSP_LO; \
2019 temp = mipsdsp_##func(rsh, rth, env); \
2020 \
2021 return (target_long)(int32_t)temp; \
2022 }
2023
2024 MUL_RETURN32_32_ph(muleq_s_w_phl, mul_q15_q15_overflowflag21, 16);
2025 MUL_RETURN32_32_ph(muleq_s_w_phr, mul_q15_q15_overflowflag21, 0);
2026
2027 #undef MUL_RETURN32_32_ph
2028
2029 #define MUL_VOID_PH(name, use_ac_env) \
2030 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2031 CPUMIPSState *env) \
2032 { \
2033 int16_t rsh, rsl, rth, rtl; \
2034 int32_t tempB, tempA; \
2035 int64_t acc, dotp; \
2036 \
2037 MIPSDSP_SPLIT32_16(rs, rsh, rsl); \
2038 MIPSDSP_SPLIT32_16(rt, rth, rtl); \
2039 \
2040 if (use_ac_env == 1) { \
2041 tempB = mipsdsp_mul_q15_q15(ac, rsh, rth, env); \
2042 tempA = mipsdsp_mul_q15_q15(ac, rsl, rtl, env); \
2043 } else { \
2044 tempB = mipsdsp_mul_u16_u16(rsh, rth); \
2045 tempA = mipsdsp_mul_u16_u16(rsl, rtl); \
2046 } \
2047 \
2048 dotp = (int64_t)tempB - (int64_t)tempA; \
2049 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2050 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2051 dotp = dotp + acc; \
2052 env->active_tc.HI[ac] = (target_long)(int32_t) \
2053 ((dotp & MIPSDSP_LHI) >> 32); \
2054 env->active_tc.LO[ac] = (target_long)(int32_t)(dotp & MIPSDSP_LLO); \
2055 }
2056
2057 MUL_VOID_PH(mulsaq_s_w_ph, 1);
2058 MUL_VOID_PH(mulsa_w_ph, 0);
2059
2060 #undef MUL_VOID_PH
2061
2062 #if defined(TARGET_MIPS64)
2063 #define MUL_RETURN64_16_QH(name, func, \
2064 rsmov1, rsmov2, rsmov3, rsmov4, rsfilter, \
2065 rtmov1, rtmov2, rtmov3, rtmov4, rtfilter) \
2066 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
2067 CPUMIPSState *env) \
2068 { \
2069 uint16_t rs3, rs2, rs1, rs0; \
2070 uint16_t rt3, rt2, rt1, rt0; \
2071 uint16_t tempD, tempC, tempB, tempA; \
2072 \
2073 rs3 = (rs >> rsmov1) & rsfilter; \
2074 rs2 = (rs >> rsmov2) & rsfilter; \
2075 rs1 = (rs >> rsmov3) & rsfilter; \
2076 rs0 = (rs >> rsmov4) & rsfilter; \
2077 rt3 = (rt >> rtmov1) & rtfilter; \
2078 rt2 = (rt >> rtmov2) & rtfilter; \
2079 rt1 = (rt >> rtmov3) & rtfilter; \
2080 rt0 = (rt >> rtmov4) & rtfilter; \
2081 \
2082 tempD = mipsdsp_##func(rs3, rt3, env); \
2083 tempC = mipsdsp_##func(rs2, rt2, env); \
2084 tempB = mipsdsp_##func(rs1, rt1, env); \
2085 tempA = mipsdsp_##func(rs0, rt0, env); \
2086 \
2087 return MIPSDSP_RETURN64_16(tempD, tempC, tempB, tempA); \
2088 }
2089
2090 MUL_RETURN64_16_QH(muleu_s_qh_obl, mul_u8_u16, \
2091 56, 48, 40, 32, MIPSDSP_Q0, \
2092 48, 32, 16, 0, MIPSDSP_LO);
2093 MUL_RETURN64_16_QH(muleu_s_qh_obr, mul_u8_u16, \
2094 24, 16, 8, 0, MIPSDSP_Q0, \
2095 48, 32, 16, 0, MIPSDSP_LO);
2096 MUL_RETURN64_16_QH(mulq_rs_qh, rndq15_mul_q15_q15, \
2097 48, 32, 16, 0, MIPSDSP_LO, \
2098 48, 32, 16, 0, MIPSDSP_LO);
2099
2100 #undef MUL_RETURN64_16_QH
2101
2102 #define MUL_RETURN64_32_QH(name, \
2103 rsmov1, rsmov2, \
2104 rtmov1, rtmov2) \
2105 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
2106 CPUMIPSState *env) \
2107 { \
2108 uint16_t rsB, rsA; \
2109 uint16_t rtB, rtA; \
2110 uint32_t tempB, tempA; \
2111 \
2112 rsB = (rs >> rsmov1) & MIPSDSP_LO; \
2113 rsA = (rs >> rsmov2) & MIPSDSP_LO; \
2114 rtB = (rt >> rtmov1) & MIPSDSP_LO; \
2115 rtA = (rt >> rtmov2) & MIPSDSP_LO; \
2116 \
2117 tempB = mipsdsp_mul_q15_q15(5, rsB, rtB, env); \
2118 tempA = mipsdsp_mul_q15_q15(5, rsA, rtA, env); \
2119 \
2120 return ((uint64_t)tempB << 32) | (uint64_t)tempA; \
2121 }
2122
2123 MUL_RETURN64_32_QH(muleq_s_pw_qhl, 48, 32, 48, 32);
2124 MUL_RETURN64_32_QH(muleq_s_pw_qhr, 16, 0, 16, 0);
2125
2126 #undef MUL_RETURN64_32_QH
2127
2128 void helper_mulsaq_s_w_qh(target_ulong rs, target_ulong rt, uint32_t ac,
2129 CPUMIPSState *env)
2130 {
2131 int16_t rs3, rs2, rs1, rs0;
2132 int16_t rt3, rt2, rt1, rt0;
2133 int32_t tempD, tempC, tempB, tempA;
2134 int64_t acc[2];
2135 int64_t temp[2];
2136 int64_t temp_sum;
2137
2138 MIPSDSP_SPLIT64_16(rs, rs3, rs2, rs1, rs0);
2139 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0);
2140
2141 tempD = mipsdsp_mul_q15_q15(ac, rs3, rt3, env);
2142 tempC = mipsdsp_mul_q15_q15(ac, rs2, rt2, env);
2143 tempB = mipsdsp_mul_q15_q15(ac, rs1, rt1, env);
2144 tempA = mipsdsp_mul_q15_q15(ac, rs0, rt0, env);
2145
2146 temp[0] = ((int32_t)tempD - (int32_t)tempC) +
2147 ((int32_t)tempB - (int32_t)tempA);
2148 temp[0] = (int64_t)(temp[0] << 30) >> 30;
2149 if (((temp[0] >> 33) & 0x01) == 0) {
2150 temp[1] = 0x00;
2151 } else {
2152 temp[1] = ~0ull;
2153 }
2154
2155 acc[0] = env->active_tc.LO[ac];
2156 acc[1] = env->active_tc.HI[ac];
2157
2158 temp_sum = acc[0] + temp[0];
2159 if (((uint64_t)temp_sum < (uint64_t)acc[0]) &&
2160 ((uint64_t)temp_sum < (uint64_t)temp[0])) {
2161 acc[1] += 1;
2162 }
2163 acc[0] = temp_sum;
2164 acc[1] += temp[1];
2165
2166 env->active_tc.HI[ac] = acc[1];
2167 env->active_tc.LO[ac] = acc[0];
2168 }
2169 #endif
2170
2171 #define DP_QB(name, func, is_add, rsmov1, rsmov2, rtmov1, rtmov2) \
2172 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2173 CPUMIPSState *env) \
2174 { \
2175 uint8_t rs3, rs2; \
2176 uint8_t rt3, rt2; \
2177 uint16_t tempB, tempA; \
2178 uint64_t tempC, dotp; \
2179 \
2180 rs3 = (rs >> rsmov1) & MIPSDSP_Q0; \
2181 rs2 = (rs >> rsmov2) & MIPSDSP_Q0; \
2182 rt3 = (rt >> rtmov1) & MIPSDSP_Q0; \
2183 rt2 = (rt >> rtmov2) & MIPSDSP_Q0; \
2184 tempB = mipsdsp_##func(rs3, rt3); \
2185 tempA = mipsdsp_##func(rs2, rt2); \
2186 dotp = (int64_t)tempB + (int64_t)tempA; \
2187 if (is_add) { \
2188 tempC = (((uint64_t)env->active_tc.HI[ac] << 32) | \
2189 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO)) \
2190 + dotp; \
2191 } else { \
2192 tempC = (((uint64_t)env->active_tc.HI[ac] << 32) | \
2193 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO)) \
2194 - dotp; \
2195 } \
2196 \
2197 env->active_tc.HI[ac] = (target_long)(int32_t) \
2198 ((tempC & MIPSDSP_LHI) >> 32); \
2199 env->active_tc.LO[ac] = (target_long)(int32_t)(tempC & MIPSDSP_LLO); \
2200 }
2201
2202 DP_QB(dpau_h_qbl, mul_u8_u8, 1, 24, 16, 24, 16);
2203 DP_QB(dpau_h_qbr, mul_u8_u8, 1, 8, 0, 8, 0);
2204 DP_QB(dpsu_h_qbl, mul_u8_u8, 0, 24, 16, 24, 16);
2205 DP_QB(dpsu_h_qbr, mul_u8_u8, 0, 8, 0, 8, 0);
2206
2207 #undef DP_QB
2208
2209 #if defined(TARGET_MIPS64)
2210 #define DP_OB(name, add_sub, \
2211 rsmov1, rsmov2, rsmov3, rsmov4, \
2212 rtmov1, rtmov2, rtmov3, rtmov4) \
2213 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2214 CPUMIPSState *env) \
2215 { \
2216 uint8_t rsD, rsC, rsB, rsA; \
2217 uint8_t rtD, rtC, rtB, rtA; \
2218 uint16_t tempD, tempC, tempB, tempA; \
2219 uint64_t temp[2]; \
2220 uint64_t acc[2]; \
2221 uint64_t temp_sum; \
2222 \
2223 temp[0] = 0; \
2224 temp[1] = 0; \
2225 \
2226 rsD = (rs >> rsmov1) & MIPSDSP_Q0; \
2227 rsC = (rs >> rsmov2) & MIPSDSP_Q0; \
2228 rsB = (rs >> rsmov3) & MIPSDSP_Q0; \
2229 rsA = (rs >> rsmov4) & MIPSDSP_Q0; \
2230 rtD = (rt >> rtmov1) & MIPSDSP_Q0; \
2231 rtC = (rt >> rtmov2) & MIPSDSP_Q0; \
2232 rtB = (rt >> rtmov3) & MIPSDSP_Q0; \
2233 rtA = (rt >> rtmov4) & MIPSDSP_Q0; \
2234 \
2235 tempD = mipsdsp_mul_u8_u8(rsD, rtD); \
2236 tempC = mipsdsp_mul_u8_u8(rsC, rtC); \
2237 tempB = mipsdsp_mul_u8_u8(rsB, rtB); \
2238 tempA = mipsdsp_mul_u8_u8(rsA, rtA); \
2239 \
2240 temp[0] = (uint64_t)tempD + (uint64_t)tempC + \
2241 (uint64_t)tempB + (uint64_t)tempA; \
2242 \
2243 acc[0] = env->active_tc.LO[ac]; \
2244 acc[1] = env->active_tc.HI[ac]; \
2245 \
2246 if (add_sub) { \
2247 temp_sum = acc[0] + temp[0]; \
2248 if (((uint64_t)temp_sum < (uint64_t)acc[0]) && \
2249 ((uint64_t)temp_sum < (uint64_t)temp[0])) { \
2250 acc[1] += 1; \
2251 } \
2252 temp[0] = temp_sum; \
2253 temp[1] = acc[1] + temp[1]; \
2254 } else { \
2255 temp_sum = acc[0] - temp[0]; \
2256 if ((uint64_t)temp_sum > (uint64_t)acc[0]) { \
2257 acc[1] -= 1; \
2258 } \
2259 temp[0] = temp_sum; \
2260 temp[1] = acc[1] - temp[1]; \
2261 } \
2262 \
2263 env->active_tc.HI[ac] = temp[1]; \
2264 env->active_tc.LO[ac] = temp[0]; \
2265 }
2266
2267 DP_OB(dpau_h_obl, 1, 56, 48, 40, 32, 56, 48, 40, 32);
2268 DP_OB(dpau_h_obr, 1, 24, 16, 8, 0, 24, 16, 8, 0);
2269 DP_OB(dpsu_h_obl, 0, 56, 48, 40, 32, 56, 48, 40, 32);
2270 DP_OB(dpsu_h_obr, 0, 24, 16, 8, 0, 24, 16, 8, 0);
2271
2272 #undef DP_OB
2273 #endif
2274
2275 #define DP_NOFUNC_PH(name, is_add, rsmov1, rsmov2, rtmov1, rtmov2) \
2276 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2277 CPUMIPSState *env) \
2278 { \
2279 int16_t rsB, rsA, rtB, rtA; \
2280 int32_t tempA, tempB; \
2281 int64_t acc; \
2282 \
2283 rsB = (rs >> rsmov1) & MIPSDSP_LO; \
2284 rsA = (rs >> rsmov2) & MIPSDSP_LO; \
2285 rtB = (rt >> rtmov1) & MIPSDSP_LO; \
2286 rtA = (rt >> rtmov2) & MIPSDSP_LO; \
2287 \
2288 tempB = (int32_t)rsB * (int32_t)rtB; \
2289 tempA = (int32_t)rsA * (int32_t)rtA; \
2290 \
2291 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2292 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2293 \
2294 if (is_add) { \
2295 acc = acc + ((int64_t)tempB + (int64_t)tempA); \
2296 } else { \
2297 acc = acc - ((int64_t)tempB + (int64_t)tempA); \
2298 } \
2299 \
2300 env->active_tc.HI[ac] = (target_long)(int32_t)((acc & MIPSDSP_LHI) >> 32); \
2301 env->active_tc.LO[ac] = (target_long)(int32_t)(acc & MIPSDSP_LLO); \
2302 }
2303
2304 DP_NOFUNC_PH(dpa_w_ph, 1, 16, 0, 16, 0);
2305 DP_NOFUNC_PH(dpax_w_ph, 1, 16, 0, 0, 16);
2306 DP_NOFUNC_PH(dps_w_ph, 0, 16, 0, 16, 0);
2307 DP_NOFUNC_PH(dpsx_w_ph, 0, 16, 0, 0, 16);
2308 #undef DP_NOFUNC_PH
2309
2310 #define DP_HASFUNC_PH(name, is_add, rsmov1, rsmov2, rtmov1, rtmov2) \
2311 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2312 CPUMIPSState *env) \
2313 { \
2314 int16_t rsB, rsA, rtB, rtA; \
2315 int32_t tempB, tempA; \
2316 int64_t acc, dotp; \
2317 \
2318 rsB = (rs >> rsmov1) & MIPSDSP_LO; \
2319 rsA = (rs >> rsmov2) & MIPSDSP_LO; \
2320 rtB = (rt >> rtmov1) & MIPSDSP_LO; \
2321 rtA = (rt >> rtmov2) & MIPSDSP_LO; \
2322 \
2323 tempB = mipsdsp_mul_q15_q15(ac, rsB, rtB, env); \
2324 tempA = mipsdsp_mul_q15_q15(ac, rsA, rtA, env); \
2325 \
2326 dotp = (int64_t)tempB + (int64_t)tempA; \
2327 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2328 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2329 \
2330 if (is_add) { \
2331 acc = acc + dotp; \
2332 } else { \
2333 acc = acc - dotp; \
2334 } \
2335 \
2336 env->active_tc.HI[ac] = (target_long)(int32_t) \
2337 ((acc & MIPSDSP_LHI) >> 32); \
2338 env->active_tc.LO[ac] = (target_long)(int32_t) \
2339 (acc & MIPSDSP_LLO); \
2340 }
2341
2342 DP_HASFUNC_PH(dpaq_s_w_ph, 1, 16, 0, 16, 0);
2343 DP_HASFUNC_PH(dpaqx_s_w_ph, 1, 16, 0, 0, 16);
2344 DP_HASFUNC_PH(dpsq_s_w_ph, 0, 16, 0, 16, 0);
2345 DP_HASFUNC_PH(dpsqx_s_w_ph, 0, 16, 0, 0, 16);
2346
2347 #undef DP_HASFUNC_PH
2348
2349 #define DP_128OPERATION_PH(name, is_add) \
2350 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2351 CPUMIPSState *env) \
2352 { \
2353 int16_t rsh, rsl, rth, rtl; \
2354 int32_t tempB, tempA, tempC62_31, tempC63; \
2355 int64_t acc, dotp, tempC; \
2356 \
2357 MIPSDSP_SPLIT32_16(rs, rsh, rsl); \
2358 MIPSDSP_SPLIT32_16(rt, rth, rtl); \
2359 \
2360 tempB = mipsdsp_mul_q15_q15(ac, rsh, rtl, env); \
2361 tempA = mipsdsp_mul_q15_q15(ac, rsl, rth, env); \
2362 \
2363 dotp = (int64_t)tempB + (int64_t)tempA; \
2364 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2365 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2366 if (is_add) { \
2367 tempC = acc + dotp; \
2368 } else { \
2369 tempC = acc - dotp; \
2370 } \
2371 tempC63 = (tempC >> 63) & 0x01; \
2372 tempC62_31 = (tempC >> 31) & 0xFFFFFFFF; \
2373 \
2374 if ((tempC63 == 0) && (tempC62_31 != 0x00000000)) { \
2375 tempC = 0x7FFFFFFF; \
2376 set_DSPControl_overflow_flag(1, 16 + ac, env); \
2377 } \
2378 \
2379 if ((tempC63 == 1) && (tempC62_31 != 0xFFFFFFFF)) { \
2380 tempC = (int64_t)(int32_t)0x80000000; \
2381 set_DSPControl_overflow_flag(1, 16 + ac, env); \
2382 } \
2383 \
2384 env->active_tc.HI[ac] = (target_long)(int32_t) \
2385 ((tempC & MIPSDSP_LHI) >> 32); \
2386 env->active_tc.LO[ac] = (target_long)(int32_t) \
2387 (tempC & MIPSDSP_LLO); \
2388 }
2389
2390 DP_128OPERATION_PH(dpaqx_sa_w_ph, 1);
2391 DP_128OPERATION_PH(dpsqx_sa_w_ph, 0);
2392
2393 #undef DP_128OPERATION_HP
2394
2395 #if defined(TARGET_MIPS64)
2396 #define DP_QH(name, is_add, use_ac_env) \
2397 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2398 CPUMIPSState *env) \
2399 { \
2400 int32_t rs3, rs2, rs1, rs0; \
2401 int32_t rt3, rt2, rt1, rt0; \
2402 int32_t tempD, tempC, tempB, tempA; \
2403 int64_t acc[2]; \
2404 int64_t temp[2]; \
2405 int64_t temp_sum; \
2406 \
2407 MIPSDSP_SPLIT64_16(rs, rs3, rs2, rs1, rs0); \
2408 MIPSDSP_SPLIT64_16(rt, rt3, rt2, rt1, rt0); \
2409 \
2410 if (use_ac_env) { \
2411 tempD = mipsdsp_mul_q15_q15(ac, rs3, rt3, env); \
2412 tempC = mipsdsp_mul_q15_q15(ac, rs2, rt2, env); \
2413 tempB = mipsdsp_mul_q15_q15(ac, rs1, rt1, env); \
2414 tempA = mipsdsp_mul_q15_q15(ac, rs0, rt0, env); \
2415 } else { \
2416 tempD = mipsdsp_mul_u16_u16(rs3, rt3); \
2417 tempC = mipsdsp_mul_u16_u16(rs2, rt2); \
2418 tempB = mipsdsp_mul_u16_u16(rs1, rt1); \
2419 tempA = mipsdsp_mul_u16_u16(rs0, rt0); \
2420 } \
2421 \
2422 temp[0] = (int64_t)tempD + (int64_t)tempC + \
2423 (int64_t)tempB + (int64_t)tempA; \
2424 \
2425 if (temp[0] >= 0) { \
2426 temp[1] = 0; \
2427 } else { \
2428 temp[1] = ~0ull; \
2429 } \
2430 \
2431 acc[1] = env->active_tc.HI[ac]; \
2432 acc[0] = env->active_tc.LO[ac]; \
2433 \
2434 if (is_add) { \
2435 temp_sum = acc[0] + temp[0]; \
2436 if (((uint64_t)temp_sum < (uint64_t)acc[0]) && \
2437 ((uint64_t)temp_sum < (uint64_t)temp[0])) { \
2438 acc[1] = acc[1] + 1; \
2439 } \
2440 temp[0] = temp_sum; \
2441 temp[1] = acc[1] + temp[1]; \
2442 } else { \
2443 temp_sum = acc[0] - temp[0]; \
2444 if ((uint64_t)temp_sum > (uint64_t)acc[0]) { \
2445 acc[1] = acc[1] - 1; \
2446 } \
2447 temp[0] = temp_sum; \
2448 temp[1] = acc[1] - temp[1]; \
2449 } \
2450 \
2451 env->active_tc.HI[ac] = temp[1]; \
2452 env->active_tc.LO[ac] = temp[0]; \
2453 }
2454
2455 DP_QH(dpa_w_qh, 1, 0);
2456 DP_QH(dpaq_s_w_qh, 1, 1);
2457 DP_QH(dps_w_qh, 0, 0);
2458 DP_QH(dpsq_s_w_qh, 0, 1);
2459
2460 #undef DP_QH
2461
2462 #endif
2463
2464 #define DP_L_W(name, is_add) \
2465 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2466 CPUMIPSState *env) \
2467 { \
2468 int32_t temp63; \
2469 int64_t dotp, acc; \
2470 uint64_t temp; \
2471 bool overflow; \
2472 \
2473 dotp = mipsdsp_mul_q31_q31(ac, rs, rt, env); \
2474 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2475 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2476 if (is_add) { \
2477 temp = acc + dotp; \
2478 overflow = MIPSDSP_OVERFLOW_ADD((uint64_t)acc, (uint64_t)dotp, \
2479 temp, (0x01ull << 63)); \
2480 } else { \
2481 temp = acc - dotp; \
2482 overflow = MIPSDSP_OVERFLOW_SUB((uint64_t)acc, (uint64_t)dotp, \
2483 temp, (0x01ull << 63)); \
2484 } \
2485 \
2486 if (overflow) { \
2487 temp63 = (temp >> 63) & 0x01; \
2488 if (temp63 == 1) { \
2489 temp = (0x01ull << 63) - 1; \
2490 } else { \
2491 temp = 0x01ull << 63; \
2492 } \
2493 \
2494 set_DSPControl_overflow_flag(1, 16 + ac, env); \
2495 } \
2496 \
2497 env->active_tc.HI[ac] = (target_long)(int32_t) \
2498 ((temp & MIPSDSP_LHI) >> 32); \
2499 env->active_tc.LO[ac] = (target_long)(int32_t) \
2500 (temp & MIPSDSP_LLO); \
2501 }
2502
2503 DP_L_W(dpaq_sa_l_w, 1);
2504 DP_L_W(dpsq_sa_l_w, 0);
2505
2506 #undef DP_L_W
2507
2508 #if defined(TARGET_MIPS64)
2509 #define DP_L_PW(name, func) \
2510 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2511 CPUMIPSState *env) \
2512 { \
2513 int32_t rs1, rs0; \
2514 int32_t rt1, rt0; \
2515 int64_t tempB[2], tempA[2]; \
2516 int64_t temp[2]; \
2517 int64_t acc[2]; \
2518 int64_t temp_sum; \
2519 \
2520 temp[0] = 0; \
2521 temp[1] = 0; \
2522 \
2523 MIPSDSP_SPLIT64_32(rs, rs1, rs0); \
2524 MIPSDSP_SPLIT64_32(rt, rt1, rt0); \
2525 \
2526 tempB[0] = mipsdsp_mul_q31_q31(ac, rs1, rt1, env); \
2527 tempA[0] = mipsdsp_mul_q31_q31(ac, rs0, rt0, env); \
2528 \
2529 if (tempB[0] >= 0) { \
2530 tempB[1] = 0x00; \
2531 } else { \
2532 tempB[1] = ~0ull; \
2533 } \
2534 \
2535 if (tempA[0] >= 0) { \
2536 tempA[1] = 0x00; \
2537 } else { \
2538 tempA[1] = ~0ull; \
2539 } \
2540 \
2541 temp_sum = tempB[0] + tempA[0]; \
2542 if (((uint64_t)temp_sum < (uint64_t)tempB[0]) && \
2543 ((uint64_t)temp_sum < (uint64_t)tempA[0])) { \
2544 temp[1] += 1; \
2545 } \
2546 temp[0] = temp_sum; \
2547 temp[1] += tempB[1] + tempA[1]; \
2548 \
2549 mipsdsp_##func(acc, ac, temp, env); \
2550 \
2551 env->active_tc.HI[ac] = acc[1]; \
2552 env->active_tc.LO[ac] = acc[0]; \
2553 }
2554
2555 DP_L_PW(dpaq_sa_l_pw, sat64_acc_add_q63);
2556 DP_L_PW(dpsq_sa_l_pw, sat64_acc_sub_q63);
2557
2558 #undef DP_L_PW
2559
2560 void helper_mulsaq_s_l_pw(target_ulong rs, target_ulong rt, uint32_t ac,
2561 CPUMIPSState *env)
2562 {
2563 int32_t rs1, rs0;
2564 int32_t rt1, rt0;
2565 int64_t tempB[2], tempA[2];
2566 int64_t temp[2];
2567 int64_t acc[2];
2568 int64_t temp_sum;
2569
2570 rs1 = (rs >> 32) & MIPSDSP_LLO;
2571 rs0 = rs & MIPSDSP_LLO;
2572 rt1 = (rt >> 32) & MIPSDSP_LLO;
2573 rt0 = rt & MIPSDSP_LLO;
2574
2575 tempB[0] = mipsdsp_mul_q31_q31(ac, rs1, rt1, env);
2576 tempA[0] = mipsdsp_mul_q31_q31(ac, rs0, rt0, env);
2577
2578 if (tempB[0] >= 0) {
2579 tempB[1] = 0x00;
2580 } else {
2581 tempB[1] = ~0ull;
2582 }
2583
2584 if (tempA[0] >= 0) {
2585 tempA[1] = 0x00;
2586 } else {
2587 tempA[1] = ~0ull;
2588 }
2589
2590 acc[0] = env->active_tc.LO[ac];
2591 acc[1] = env->active_tc.HI[ac];
2592
2593 temp_sum = tempB[0] - tempA[0];
2594 if ((uint64_t)temp_sum > (uint64_t)tempB[0]) {
2595 tempB[1] -= 1;
2596 }
2597 temp[0] = temp_sum;
2598 temp[1] = tempB[1] - tempA[1];
2599
2600 if ((temp[1] & 0x01) == 0) {
2601 temp[1] = 0x00;
2602 } else {
2603 temp[1] = ~0ull;
2604 }
2605
2606 temp_sum = acc[0] + temp[0];
2607 if (((uint64_t)temp_sum < (uint64_t)acc[0]) &&
2608 ((uint64_t)temp_sum < (uint64_t)temp[0])) {
2609 acc[1] += 1;
2610 }
2611 acc[0] = temp_sum;
2612 acc[1] += temp[1];
2613
2614 env->active_tc.HI[ac] = acc[1];
2615 env->active_tc.LO[ac] = acc[0];
2616 }
2617 #endif
2618
2619 #define MAQ_S_W(name, mov) \
2620 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2621 CPUMIPSState *env) \
2622 { \
2623 int16_t rsh, rth; \
2624 int32_t tempA; \
2625 int64_t tempL, acc; \
2626 \
2627 rsh = (rs >> mov) & MIPSDSP_LO; \
2628 rth = (rt >> mov) & MIPSDSP_LO; \
2629 tempA = mipsdsp_mul_q15_q15(ac, rsh, rth, env); \
2630 acc = ((uint64_t)env->active_tc.HI[ac] << 32) | \
2631 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO); \
2632 tempL = (int64_t)tempA + acc; \
2633 env->active_tc.HI[ac] = (target_long)(int32_t) \
2634 ((tempL & MIPSDSP_LHI) >> 32); \
2635 env->active_tc.LO[ac] = (target_long)(int32_t) \
2636 (tempL & MIPSDSP_LLO); \
2637 }
2638
2639 MAQ_S_W(maq_s_w_phl, 16);
2640 MAQ_S_W(maq_s_w_phr, 0);
2641
2642 #undef MAQ_S_W
2643
2644 #define MAQ_SA_W(name, mov) \
2645 void helper_##name(uint32_t ac, target_ulong rs, target_ulong rt, \
2646 CPUMIPSState *env) \
2647 { \
2648 int16_t rsh, rth; \
2649 int32_t tempA; \
2650 \
2651 rsh = (rs >> mov) & MIPSDSP_LO; \
2652 rth = (rt >> mov) & MIPSDSP_LO; \
2653 tempA = mipsdsp_mul_q15_q15(ac, rsh, rth, env); \
2654 tempA = mipsdsp_sat32_acc_q31(ac, tempA, env); \
2655 \
2656 env->active_tc.HI[ac] = (target_long)(int32_t)(((int64_t)tempA & \
2657 MIPSDSP_LHI) >> 32); \
2658 env->active_tc.LO[ac] = (target_long)(int32_t)((int64_t)tempA & \
2659 MIPSDSP_LLO); \
2660 }
2661
2662 MAQ_SA_W(maq_sa_w_phl, 16);
2663 MAQ_SA_W(maq_sa_w_phr, 0);
2664
2665 #undef MAQ_SA_W
2666
2667 #define MULQ_W(name, addvar) \
2668 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
2669 CPUMIPSState *env) \
2670 { \
2671 int32_t rs_t, rt_t; \
2672 int32_t tempI; \
2673 int64_t tempL; \
2674 \
2675 rs_t = rs & MIPSDSP_LLO; \
2676 rt_t = rt & MIPSDSP_LLO; \
2677 \
2678 if ((rs_t == 0x80000000) && (rt_t == 0x80000000)) { \
2679 tempL = 0x7FFFFFFF00000000ull; \
2680 set_DSPControl_overflow_flag(1, 21, env); \
2681 } else { \
2682 tempL = ((int64_t)rs_t * (int64_t)rt_t) << 1; \
2683 tempL += addvar; \
2684 } \
2685 tempI = (tempL & MIPSDSP_LHI) >> 32; \
2686 \
2687 return (target_long)(int32_t)tempI; \
2688 }
2689
2690 MULQ_W(mulq_s_w, 0);
2691 MULQ_W(mulq_rs_w, 0x80000000ull);
2692
2693 #undef MULQ_W
2694
2695 #if defined(TARGET_MIPS64)
2696
2697 #define MAQ_S_W_QH(name, mov) \
2698 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2699 CPUMIPSState *env) \
2700 { \
2701 int16_t rs_t, rt_t; \
2702 int32_t temp_mul; \
2703 int64_t temp[2]; \
2704 int64_t acc[2]; \
2705 int64_t temp_sum; \
2706 \
2707 temp[0] = 0; \
2708 temp[1] = 0; \
2709 \
2710 rs_t = (rs >> mov) & MIPSDSP_LO; \
2711 rt_t = (rt >> mov) & MIPSDSP_LO; \
2712 temp_mul = mipsdsp_mul_q15_q15(ac, rs_t, rt_t, env); \
2713 \
2714 temp[0] = (int64_t)temp_mul; \
2715 if (temp[0] >= 0) { \
2716 temp[1] = 0x00; \
2717 } else { \
2718 temp[1] = ~0ull; \
2719 } \
2720 \
2721 acc[0] = env->active_tc.LO[ac]; \
2722 acc[1] = env->active_tc.HI[ac]; \
2723 \
2724 temp_sum = acc[0] + temp[0]; \
2725 if (((uint64_t)temp_sum < (uint64_t)acc[0]) && \
2726 ((uint64_t)temp_sum < (uint64_t)temp[0])) { \
2727 acc[1] += 1; \
2728 } \
2729 acc[0] = temp_sum; \
2730 acc[1] += temp[1]; \
2731 \
2732 env->active_tc.HI[ac] = acc[1]; \
2733 env->active_tc.LO[ac] = acc[0]; \
2734 }
2735
2736 MAQ_S_W_QH(maq_s_w_qhll, 48);
2737 MAQ_S_W_QH(maq_s_w_qhlr, 32);
2738 MAQ_S_W_QH(maq_s_w_qhrl, 16);
2739 MAQ_S_W_QH(maq_s_w_qhrr, 0);
2740
2741 #undef MAQ_S_W_QH
2742
2743 #define MAQ_SA_W(name, mov) \
2744 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2745 CPUMIPSState *env) \
2746 { \
2747 int16_t rs_t, rt_t; \
2748 int32_t temp; \
2749 int64_t acc[2]; \
2750 \
2751 rs_t = (rs >> mov) & MIPSDSP_LO; \
2752 rt_t = (rt >> mov) & MIPSDSP_LO; \
2753 temp = mipsdsp_mul_q15_q15(ac, rs_t, rt_t, env); \
2754 temp = mipsdsp_sat32_acc_q31(ac, temp, env); \
2755 \
2756 acc[0] = (int64_t)(int32_t)temp; \
2757 if (acc[0] >= 0) { \
2758 acc[1] = 0x00; \
2759 } else { \
2760 acc[1] = ~0ull; \
2761 } \
2762 \
2763 env->active_tc.HI[ac] = acc[1]; \
2764 env->active_tc.LO[ac] = acc[0]; \
2765 }
2766
2767 MAQ_SA_W(maq_sa_w_qhll, 48);
2768 MAQ_SA_W(maq_sa_w_qhlr, 32);
2769 MAQ_SA_W(maq_sa_w_qhrl, 16);
2770 MAQ_SA_W(maq_sa_w_qhrr, 0);
2771
2772 #undef MAQ_SA_W
2773
2774 #define MAQ_S_L_PW(name, mov) \
2775 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2776 CPUMIPSState *env) \
2777 { \
2778 int32_t rs_t, rt_t; \
2779 int64_t temp[2]; \
2780 int64_t acc[2]; \
2781 int64_t temp_sum; \
2782 \
2783 temp[0] = 0; \
2784 temp[1] = 0; \
2785 \
2786 rs_t = (rs >> mov) & MIPSDSP_LLO; \
2787 rt_t = (rt >> mov) & MIPSDSP_LLO; \
2788 \
2789 temp[0] = mipsdsp_mul_q31_q31(ac, rs_t, rt_t, env); \
2790 if (temp[0] >= 0) { \
2791 temp[1] = 0x00; \
2792 } else { \
2793 temp[1] = ~0ull; \
2794 } \
2795 \
2796 acc[0] = env->active_tc.LO[ac]; \
2797 acc[1] = env->active_tc.HI[ac]; \
2798 \
2799 temp_sum = acc[0] + temp[0]; \
2800 if (((uint64_t)temp_sum < (uint64_t)acc[0]) && \
2801 ((uint64_t)temp_sum < (uint64_t)temp[0])) { \
2802 acc[1] += 1; \
2803 } \
2804 acc[0] = temp_sum; \
2805 acc[1] += temp[1]; \
2806 \
2807 env->active_tc.HI[ac] = acc[1]; \
2808 env->active_tc.LO[ac] = acc[0]; \
2809 }
2810
2811 MAQ_S_L_PW(maq_s_l_pwl, 32);
2812 MAQ_S_L_PW(maq_s_l_pwr, 0);
2813
2814 #undef MAQ_S_L_PW
2815
2816 #define DM_OPERATE(name, func, is_add, sigext) \
2817 void helper_##name(target_ulong rs, target_ulong rt, uint32_t ac, \
2818 CPUMIPSState *env) \
2819 { \
2820 int32_t rs1, rs0; \
2821 int32_t rt1, rt0; \
2822 int64_t tempBL[2], tempAL[2]; \
2823 int64_t acc[2]; \
2824 int64_t temp[2]; \
2825 int64_t temp_sum; \
2826 \
2827 temp[0] = 0x00; \
2828 temp[1] = 0x00; \
2829 \
2830 MIPSDSP_SPLIT64_32(rs, rs1, rs0); \
2831 MIPSDSP_SPLIT64_32(rt, rt1, rt0); \
2832 \
2833 if (sigext) { \
2834 tempBL[0] = (int64_t)mipsdsp_##func(rs1, rt1); \
2835 tempAL[0] = (int64_t)mipsdsp_##func(rs0, rt0); \
2836 \
2837 if (tempBL[0] >= 0) { \
2838 tempBL[1] = 0x0; \
2839 } else { \
2840 tempBL[1] = ~0ull; \
2841 } \
2842 \
2843 if (tempAL[0] >= 0) { \
2844 tempAL[1] = 0x0; \
2845 } else { \
2846 tempAL[1] = ~0ull; \
2847 } \
2848 } else { \
2849 tempBL[0] = mipsdsp_##func(rs1, rt1); \
2850 tempAL[0] = mipsdsp_##func(rs0, rt0); \
2851 tempBL[1] = 0; \
2852 tempAL[1] = 0; \
2853 } \
2854 \
2855 acc[1] = env->active_tc.HI[ac]; \
2856 acc[0] = env->active_tc.LO[ac]; \
2857 \
2858 temp_sum = tempBL[0] + tempAL[0]; \
2859 if (((uint64_t)temp_sum < (uint64_t)tempBL[0]) && \
2860 ((uint64_t)temp_sum < (uint64_t)tempAL[0])) { \
2861 temp[1] += 1; \
2862 } \
2863 temp[0] = temp_sum; \
2864 temp[1] += tempBL[1] + tempAL[1]; \
2865 \
2866 if (is_add) { \
2867 temp_sum = acc[0] + temp[0]; \
2868 if (((uint64_t)temp_sum < (uint64_t)acc[0]) && \
2869 ((uint64_t)temp_sum < (uint64_t)temp[0])) { \
2870 acc[1] += 1; \
2871 } \
2872 temp[0] = temp_sum; \
2873 temp[1] = acc[1] + temp[1]; \
2874 } else { \
2875 temp_sum = acc[0] - temp[0]; \
2876 if ((uint64_t)temp_sum > (uint64_t)acc[0]) { \
2877 acc[1] -= 1; \
2878 } \
2879 temp[0] = temp_sum; \
2880 temp[1] = acc[1] - temp[1]; \
2881 } \
2882 \
2883 env->active_tc.HI[ac] = temp[1]; \
2884 env->active_tc.LO[ac] = temp[0]; \
2885 }
2886
2887 DM_OPERATE(dmadd, mul_i32_i32, 1, 1);
2888 DM_OPERATE(dmaddu, mul_u32_u32, 1, 0);
2889 DM_OPERATE(dmsub, mul_i32_i32, 0, 1);
2890 DM_OPERATE(dmsubu, mul_u32_u32, 0, 0);
2891 #undef DM_OPERATE
2892 #endif
2893
2894 /** DSP Bit/Manipulation Sub-class insns **/
2895 target_ulong helper_bitrev(target_ulong rt)
2896 {
2897 int32_t temp;
2898 uint32_t rd;
2899 int i;
2900
2901 temp = rt & MIPSDSP_LO;
2902 rd = 0;
2903 for (i = 0; i < 16; i++) {
2904 rd = (rd << 1) | (temp & 1);
2905 temp = temp >> 1;
2906 }
2907
2908 return (target_ulong)rd;
2909 }
2910
2911 #define BIT_INSV(name, posfilter, ret_type) \
2912 target_ulong helper_##name(CPUMIPSState *env, target_ulong rs, \
2913 target_ulong rt) \
2914 { \
2915 uint32_t pos, size, msb, lsb; \
2916 uint32_t const sizefilter = 0x3F; \
2917 target_ulong temp; \
2918 target_ulong dspc; \
2919 \
2920 dspc = env->active_tc.DSPControl; \
2921 \
2922 pos = dspc & posfilter; \
2923 size = (dspc >> 7) & sizefilter; \
2924 \
2925 msb = pos + size - 1; \
2926 lsb = pos; \
2927 \
2928 if (lsb > msb || (msb > TARGET_LONG_BITS)) { \
2929 return rt; \
2930 } \
2931 \
2932 temp = deposit64(rt, pos, size, rs); \
2933 \
2934 return (target_long)(ret_type)temp; \
2935 }
2936
2937 BIT_INSV(insv, 0x1F, int32_t);
2938 #ifdef TARGET_MIPS64
2939 BIT_INSV(dinsv, 0x7F, target_long);
2940 #endif
2941
2942 #undef BIT_INSV
2943
2944
2945 /** DSP Compare-Pick Sub-class insns **/
2946 #define CMP_HAS_RET(name, func, split_num, filter, bit_size) \
2947 target_ulong helper_##name(target_ulong rs, target_ulong rt) \
2948 { \
2949 uint32_t rs_t, rt_t; \
2950 uint8_t cc; \
2951 uint32_t temp = 0; \
2952 int i; \
2953 \
2954 for (i = 0; i < split_num; i++) { \
2955 rs_t = (rs >> (bit_size * i)) & filter; \
2956 rt_t = (rt >> (bit_size * i)) & filter; \
2957 cc = mipsdsp_##func(rs_t, rt_t); \
2958 temp |= cc << i; \
2959 } \
2960 \
2961 return (target_ulong)temp; \
2962 }
2963
2964 CMP_HAS_RET(cmpgu_eq_qb, cmpu_eq, 4, MIPSDSP_Q0, 8);
2965 CMP_HAS_RET(cmpgu_lt_qb, cmpu_lt, 4, MIPSDSP_Q0, 8);
2966 CMP_HAS_RET(cmpgu_le_qb, cmpu_le, 4, MIPSDSP_Q0, 8);
2967
2968 #ifdef TARGET_MIPS64
2969 CMP_HAS_RET(cmpgu_eq_ob, cmpu_eq, 8, MIPSDSP_Q0, 8);
2970 CMP_HAS_RET(cmpgu_lt_ob, cmpu_lt, 8, MIPSDSP_Q0, 8);
2971 CMP_HAS_RET(cmpgu_le_ob, cmpu_le, 8, MIPSDSP_Q0, 8);
2972 #endif
2973
2974 #undef CMP_HAS_RET
2975
2976
2977 #define CMP_NO_RET(name, func, split_num, filter, bit_size) \
2978 void helper_##name(target_ulong rs, target_ulong rt, \
2979 CPUMIPSState *env) \
2980 { \
2981 int##bit_size##_t rs_t, rt_t; \
2982 int##bit_size##_t flag = 0; \
2983 int##bit_size##_t cc; \
2984 int i; \
2985 \
2986 for (i = 0; i < split_num; i++) { \
2987 rs_t = (rs >> (bit_size * i)) & filter; \
2988 rt_t = (rt >> (bit_size * i)) & filter; \
2989 \
2990 cc = mipsdsp_##func((int32_t)rs_t, (int32_t)rt_t); \
2991 flag |= cc << i; \
2992 } \
2993 \
2994 set_DSPControl_24(flag, split_num, env); \
2995 }
2996
2997 CMP_NO_RET(cmpu_eq_qb, cmpu_eq, 4, MIPSDSP_Q0, 8);
2998 CMP_NO_RET(cmpu_lt_qb, cmpu_lt, 4, MIPSDSP_Q0, 8);
2999 CMP_NO_RET(cmpu_le_qb, cmpu_le, 4, MIPSDSP_Q0, 8);
3000
3001 CMP_NO_RET(cmp_eq_ph, cmp_eq, 2, MIPSDSP_LO, 16);
3002 CMP_NO_RET(cmp_lt_ph, cmp_lt, 2, MIPSDSP_LO, 16);
3003 CMP_NO_RET(cmp_le_ph, cmp_le, 2, MIPSDSP_LO, 16);
3004
3005 #ifdef TARGET_MIPS64
3006 CMP_NO_RET(cmpu_eq_ob, cmpu_eq, 8, MIPSDSP_Q0, 8);
3007 CMP_NO_RET(cmpu_lt_ob, cmpu_lt, 8, MIPSDSP_Q0, 8);
3008 CMP_NO_RET(cmpu_le_ob, cmpu_le, 8, MIPSDSP_Q0, 8);
3009
3010 CMP_NO_RET(cmp_eq_qh, cmp_eq, 4, MIPSDSP_LO, 16);
3011 CMP_NO_RET(cmp_lt_qh, cmp_lt, 4, MIPSDSP_LO, 16);
3012 CMP_NO_RET(cmp_le_qh, cmp_le, 4, MIPSDSP_LO, 16);
3013
3014 CMP_NO_RET(cmp_eq_pw, cmp_eq, 2, MIPSDSP_LLO, 32);
3015 CMP_NO_RET(cmp_lt_pw, cmp_lt, 2, MIPSDSP_LLO, 32);
3016 CMP_NO_RET(cmp_le_pw, cmp_le, 2, MIPSDSP_LLO, 32);
3017 #endif
3018 #undef CMP_NO_RET
3019
3020 #if defined(TARGET_MIPS64)
3021
3022 #define CMPGDU_OB(name) \
3023 target_ulong helper_cmpgdu_##name##_ob(target_ulong rs, target_ulong rt, \
3024 CPUMIPSState *env) \
3025 { \
3026 int i; \
3027 uint8_t rs_t, rt_t; \
3028 uint32_t cond; \
3029 \
3030 cond = 0; \
3031 \
3032 for (i = 0; i < 8; i++) { \
3033 rs_t = (rs >> (8 * i)) & MIPSDSP_Q0; \
3034 rt_t = (rt >> (8 * i)) & MIPSDSP_Q0; \
3035 \
3036 if (mipsdsp_cmpu_##name(rs_t, rt_t)) { \
3037 cond |= 0x01 << i; \
3038 } \
3039 } \
3040 \
3041 set_DSPControl_24(cond, 8, env); \
3042 \
3043 return (uint64_t)cond; \
3044 }
3045
3046 CMPGDU_OB(eq)
3047 CMPGDU_OB(lt)
3048 CMPGDU_OB(le)
3049 #undef CMPGDU_OB
3050 #endif
3051
3052 #define PICK_INSN(name, split_num, filter, bit_size, ret32bit) \
3053 target_ulong helper_##name(target_ulong rs, target_ulong rt, \
3054 CPUMIPSState *env) \
3055 { \
3056 uint32_t rs_t, rt_t; \
3057 uint32_t cc; \
3058 target_ulong dsp; \
3059 int i; \
3060 target_ulong result = 0; \
3061 \
3062 dsp = env->active_tc.DSPControl; \
3063 for (i = 0; i < split_num; i++) { \
3064 rs_t = (rs >> (bit_size * i)) & filter; \
3065 rt_t = (rt >> (bit_size * i)) & filter; \
3066 cc = (dsp >> (24 + i)) & 0x01; \
3067 cc = cc == 1 ? rs_t : rt_t; \
3068 \
3069 result |= (target_ulong)cc << (bit_size * i); \
3070 } \
3071 \
3072 if (ret32bit) { \
3073 result = (target_long)(int32_t)(result & MIPSDSP_LLO); \
3074 } \
3075 \
3076 return result; \
3077 }
3078
3079 PICK_INSN(pick_qb, 4, MIPSDSP_Q0, 8, 1);
3080 PICK_INSN(pick_ph, 2, MIPSDSP_LO, 16, 1);
3081
3082 #ifdef TARGET_MIPS64
3083 PICK_INSN(pick_ob, 8, MIPSDSP_Q0, 8, 0);
3084 PICK_INSN(pick_qh, 4, MIPSDSP_LO, 16, 0);
3085 PICK_INSN(pick_pw, 2, MIPSDSP_LLO, 32, 0);
3086 #endif
3087 #undef PICK_INSN
3088
3089 target_ulong helper_packrl_ph(target_ulong rs, target_ulong rt)
3090 {
3091 uint32_t rsl, rth;
3092
3093 rsl = rs & MIPSDSP_LO;
3094 rth = (rt & MIPSDSP_HI) >> 16;
3095
3096 return (target_long)(int32_t)((rsl << 16) | rth);
3097 }
3098
3099 #if defined(TARGET_MIPS64)
3100 target_ulong helper_packrl_pw(target_ulong rs, target_ulong rt)
3101 {
3102 uint32_t rs0, rt1;
3103
3104 rs0 = rs & MIPSDSP_LLO;
3105 rt1 = (rt >> 32) & MIPSDSP_LLO;
3106
3107 return ((uint64_t)rs0 << 32) | (uint64_t)rt1;
3108 }
3109 #endif
3110
3111 /** DSP Accumulator and DSPControl Access Sub-class insns **/
3112 target_ulong helper_extr_w(target_ulong ac, target_ulong shift,
3113 CPUMIPSState *env)
3114 {
3115 int32_t tempI;
3116 int64_t tempDL[2];
3117
3118 shift = shift & 0x1F;
3119
3120 mipsdsp_rndrashift_short_acc(tempDL, ac, shift, env);
3121 if ((tempDL[1] != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3122 (tempDL[1] != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3123 set_DSPControl_overflow_flag(1, 23, env);
3124 }
3125
3126 tempI = (tempDL[0] >> 1) & MIPSDSP_LLO;
3127
3128 tempDL[0] += 1;
3129 if (tempDL[0] == 0) {
3130 tempDL[1] += 1;
3131 }
3132
3133 if (((tempDL[1] & 0x01) != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3134 ((tempDL[1] & 0x01) != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3135 set_DSPControl_overflow_flag(1, 23, env);
3136 }
3137
3138 return (target_long)tempI;
3139 }
3140
3141 target_ulong helper_extr_r_w(target_ulong ac, target_ulong shift,
3142 CPUMIPSState *env)
3143 {
3144 int64_t tempDL[2];
3145
3146 shift = shift & 0x1F;
3147
3148 mipsdsp_rndrashift_short_acc(tempDL, ac, shift, env);
3149 if ((tempDL[1] != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3150 (tempDL[1] != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3151 set_DSPControl_overflow_flag(1, 23, env);
3152 }
3153
3154 tempDL[0] += 1;
3155 if (tempDL[0] == 0) {
3156 tempDL[1] += 1;
3157 }
3158
3159 if (((tempDL[1] & 0x01) != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3160 ((tempDL[1] & 0x01) != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3161 set_DSPControl_overflow_flag(1, 23, env);
3162 }
3163
3164 return (target_long)(int32_t)(tempDL[0] >> 1);
3165 }
3166
3167 target_ulong helper_extr_rs_w(target_ulong ac, target_ulong shift,
3168 CPUMIPSState *env)
3169 {
3170 int32_t tempI, temp64;
3171 int64_t tempDL[2];
3172
3173 shift = shift & 0x1F;
3174
3175 mipsdsp_rndrashift_short_acc(tempDL, ac, shift, env);
3176 if ((tempDL[1] != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3177 (tempDL[1] != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3178 set_DSPControl_overflow_flag(1, 23, env);
3179 }
3180 tempDL[0] += 1;
3181 if (tempDL[0] == 0) {
3182 tempDL[1] += 1;
3183 }
3184 tempI = tempDL[0] >> 1;
3185
3186 if (((tempDL[1] & 0x01) != 0 || (tempDL[0] & MIPSDSP_LHI) != 0) &&
3187 ((tempDL[1] & 0x01) != 1 || (tempDL[0] & MIPSDSP_LHI) != MIPSDSP_LHI)) {
3188 temp64 = tempDL[1] & 0x01;
3189 if (temp64 == 0) {
3190 tempI = 0x7FFFFFFF;
3191 } else {
3192 tempI = 0x80000000;
3193 }
3194 set_DSPControl_overflow_flag(1, 23, env);
3195 }
3196
3197 return (target_long)tempI;
3198 }
3199
3200 #if defined(TARGET_MIPS64)
3201 target_ulong helper_dextr_w(target_ulong ac, target_ulong shift,
3202 CPUMIPSState *env)
3203 {
3204 uint64_t temp[3];
3205
3206 shift = shift & 0x3F;
3207
3208 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3209
3210 return (int64_t)(int32_t)(temp[0] >> 1);
3211 }
3212
3213 target_ulong helper_dextr_r_w(target_ulong ac, target_ulong shift,
3214 CPUMIPSState *env)
3215 {
3216 uint64_t temp[3];
3217 uint32_t temp128;
3218
3219 shift = shift & 0x3F;
3220 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3221
3222 temp[0] += 1;
3223 if (temp[0] == 0) {
3224 temp[1] += 1;
3225 if (temp[1] == 0) {
3226 temp[2] += 1;
3227 }
3228 }
3229
3230 temp128 = temp[2] & 0x01;
3231
3232 if ((temp128 != 0 || temp[1] != 0) &&
3233 (temp128 != 1 || temp[1] != ~0ull)) {
3234 set_DSPControl_overflow_flag(1, 23, env);
3235 }
3236
3237 return (int64_t)(int32_t)(temp[0] >> 1);
3238 }
3239
3240 target_ulong helper_dextr_rs_w(target_ulong ac, target_ulong shift,
3241 CPUMIPSState *env)
3242 {
3243 uint64_t temp[3];
3244 uint32_t temp128;
3245
3246 shift = shift & 0x3F;
3247 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3248
3249 temp[0] += 1;
3250 if (temp[0] == 0) {
3251 temp[1] += 1;
3252 if (temp[1] == 0) {
3253 temp[2] += 1;
3254 }
3255 }
3256
3257 temp128 = temp[2] & 0x01;
3258
3259 if ((temp128 != 0 || temp[1] != 0) &&
3260 (temp128 != 1 || temp[1] != ~0ull)) {
3261 if (temp128 == 0) {
3262 temp[0] = 0x0FFFFFFFF;
3263 } else {
3264 temp[0] = 0x0100000000ULL;
3265 }
3266 set_DSPControl_overflow_flag(1, 23, env);
3267 }
3268
3269 return (int64_t)(int32_t)(temp[0] >> 1);
3270 }
3271
3272 target_ulong helper_dextr_l(target_ulong ac, target_ulong shift,
3273 CPUMIPSState *env)
3274 {
3275 uint64_t temp[3];
3276 target_ulong result;
3277
3278 shift = shift & 0x3F;
3279
3280 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3281 result = (temp[1] << 63) | (temp[0] >> 1);
3282
3283 return result;
3284 }
3285
3286 target_ulong helper_dextr_r_l(target_ulong ac, target_ulong shift,
3287 CPUMIPSState *env)
3288 {
3289 uint64_t temp[3];
3290 uint32_t temp128;
3291 target_ulong result;
3292
3293 shift = shift & 0x3F;
3294 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3295
3296 temp[0] += 1;
3297 if (temp[0] == 0) {
3298 temp[1] += 1;
3299 if (temp[1] == 0) {
3300 temp[2] += 1;
3301 }
3302 }
3303
3304 temp128 = temp[2] & 0x01;
3305
3306 if ((temp128 != 0 || temp[1] != 0) &&
3307 (temp128 != 1 || temp[1] != ~0ull)) {
3308 set_DSPControl_overflow_flag(1, 23, env);
3309 }
3310
3311 result = (temp[1] << 63) | (temp[0] >> 1);
3312
3313 return result;
3314 }
3315
3316 target_ulong helper_dextr_rs_l(target_ulong ac, target_ulong shift,
3317 CPUMIPSState *env)
3318 {
3319 uint64_t temp[3];
3320 uint32_t temp128;
3321 target_ulong result;
3322
3323 shift = shift & 0x3F;
3324 mipsdsp_rndrashift_acc(temp, ac, shift, env);
3325
3326 temp[0] += 1;
3327 if (temp[0] == 0) {
3328 temp[1] += 1;
3329 if (temp[1] == 0) {
3330 temp[2] += 1;
3331 }
3332 }
3333
3334 temp128 = temp[2] & 0x01;
3335
3336 if ((temp128 != 0 || temp[1] != 0) &&
3337 (temp128 != 1 || temp[1] != ~0ull)) {
3338 if (temp128 == 0) {
3339 temp[1] &= ~0x00ull - 1;
3340 temp[0] |= ~0x00ull - 1;
3341 } else {
3342 temp[1] |= 0x01;
3343 temp[0] &= 0x01;
3344 }
3345 set_DSPControl_overflow_flag(1, 23, env);
3346 }
3347 result = (temp[1] << 63) | (temp[0] >> 1);
3348
3349 return result;
3350 }
3351 #endif
3352
3353 target_ulong helper_extr_s_h(target_ulong ac, target_ulong shift,
3354 CPUMIPSState *env)
3355 {
3356 int64_t temp, acc;
3357
3358 shift = shift & 0x1F;
3359
3360 acc = ((int64_t)env->active_tc.HI[ac] << 32) |
3361 ((int64_t)env->active_tc.LO[ac] & 0xFFFFFFFF);
3362
3363 temp = acc >> shift;
3364
3365 if (temp > (int64_t)0x7FFF) {
3366 temp = 0x00007FFF;
3367 set_DSPControl_overflow_flag(1, 23, env);
3368 } else if (temp < (int64_t)0xFFFFFFFFFFFF8000ULL) {
3369 temp = 0xFFFF8000;
3370 set_DSPControl_overflow_flag(1, 23, env);
3371 }
3372
3373 return (target_long)(int32_t)(temp & 0xFFFFFFFF);
3374 }
3375
3376
3377 #if defined(TARGET_MIPS64)
3378 target_ulong helper_dextr_s_h(target_ulong ac, target_ulong shift,
3379 CPUMIPSState *env)
3380 {
3381 int64_t temp[2];
3382 uint32_t temp127;
3383
3384 shift = shift & 0x1F;
3385
3386 mipsdsp_rashift_acc((uint64_t *)temp, ac, shift, env);
3387
3388 temp127 = (temp[1] >> 63) & 0x01;
3389
3390 if ((temp127 == 0) && (temp[1] > 0 || temp[0] > 32767)) {
3391 temp[0] &= 0xFFFF0000;
3392 temp[0] |= 0x00007FFF;
3393 set_DSPControl_overflow_flag(1, 23, env);
3394 } else if ((temp127 == 1) &&
3395 (temp[1] < 0xFFFFFFFFFFFFFFFFll
3396 || temp[0] < 0xFFFFFFFFFFFF1000ll)) {
3397 temp[0] &= 0xFFFF0000;
3398 temp[0] |= 0x00008000;
3399 set_DSPControl_overflow_flag(1, 23, env);
3400 }
3401
3402 return (int64_t)(int16_t)(temp[0] & MIPSDSP_LO);
3403 }
3404
3405 #endif
3406
3407 target_ulong helper_extp(target_ulong ac, target_ulong size, CPUMIPSState *env)
3408 {
3409 int32_t start_pos;
3410 int sub;
3411 uint32_t temp;
3412 uint64_t acc;
3413
3414 size = size & 0x1F;
3415
3416 temp = 0;
3417 start_pos = get_DSPControl_pos(env);
3418 sub = start_pos - (size + 1);
3419 if (sub >= -1) {
3420 acc = ((uint64_t)env->active_tc.HI[ac] << 32) |
3421 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO);
3422 temp = (acc >> (start_pos - size)) & (~0U >> (31 - size));
3423 set_DSPControl_efi(0, env);
3424 } else {
3425 set_DSPControl_efi(1, env);
3426 }
3427
3428 return (target_ulong)temp;
3429 }
3430
3431 target_ulong helper_extpdp(target_ulong ac, target_ulong size,
3432 CPUMIPSState *env)
3433 {
3434 int32_t start_pos;
3435 int sub;
3436 uint32_t temp;
3437 uint64_t acc;
3438
3439 size = size & 0x1F;
3440 temp = 0;
3441 start_pos = get_DSPControl_pos(env);
3442 sub = start_pos - (size + 1);
3443 if (sub >= -1) {
3444 acc = ((uint64_t)env->active_tc.HI[ac] << 32) |
3445 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO);
3446 temp = extract64(acc, start_pos - size, size + 1);
3447
3448 set_DSPControl_pos(sub, env);
3449 set_DSPControl_efi(0, env);
3450 } else {
3451 set_DSPControl_efi(1, env);
3452 }
3453
3454 return (target_ulong)temp;
3455 }
3456
3457
3458 #if defined(TARGET_MIPS64)
3459 target_ulong helper_dextp(target_ulong ac, target_ulong size, CPUMIPSState *env)
3460 {
3461 int start_pos;
3462 int len;
3463 int sub;
3464 uint64_t tempB, tempA;
3465 uint64_t temp;
3466
3467 temp = 0;
3468
3469 size = size & 0x3F;
3470 start_pos = get_DSPControl_pos(env);
3471 len = start_pos - size;
3472 tempB = env->active_tc.HI[ac];
3473 tempA = env->active_tc.LO[ac];
3474
3475 sub = start_pos - (size + 1);
3476
3477 if (sub >= -1) {
3478 temp = (tempB << (64 - len)) | (tempA >> len);
3479 temp = temp & ((0x01 << (size + 1)) - 1);
3480 set_DSPControl_efi(0, env);
3481 } else {
3482 set_DSPControl_efi(1, env);
3483 }
3484
3485 return temp;
3486 }
3487
3488 target_ulong helper_dextpdp(target_ulong ac, target_ulong size,
3489 CPUMIPSState *env)
3490 {
3491 int start_pos;
3492 int len;
3493 int sub;
3494 uint64_t tempB, tempA;
3495 uint64_t temp;
3496
3497 temp = 0;
3498 size = size & 0x3F;
3499 start_pos = get_DSPControl_pos(env);
3500 len = start_pos - size;
3501 tempB = env->active_tc.HI[ac];
3502 tempA = env->active_tc.LO[ac];
3503
3504 sub = start_pos - (size + 1);
3505
3506 if (sub >= -1) {
3507 temp = (tempB << (64 - len)) | (tempA >> len);
3508 temp = temp & ((0x01 << (size + 1)) - 1);
3509 set_DSPControl_pos(sub, env);
3510 set_DSPControl_efi(0, env);
3511 } else {
3512 set_DSPControl_efi(1, env);
3513 }
3514
3515 return temp;
3516 }
3517
3518 #endif
3519
3520 void helper_shilo(target_ulong ac, target_ulong rs, CPUMIPSState *env)
3521 {
3522 int8_t rs5_0;
3523 uint64_t temp, acc;
3524
3525 rs5_0 = rs & 0x3F;
3526 rs5_0 = (int8_t)(rs5_0 << 2) >> 2;
3527
3528 if (unlikely(rs5_0 == 0)) {
3529 return;
3530 }
3531
3532 acc = (((uint64_t)env->active_tc.HI[ac] << 32) & MIPSDSP_LHI) |
3533 ((uint64_t)env->active_tc.LO[ac] & MIPSDSP_LLO);
3534
3535 if (rs5_0 > 0) {
3536 temp = acc >> rs5_0;
3537 } else {
3538 temp = acc << -rs5_0;
3539 }
3540
3541 env->active_tc.HI[ac] = (target_ulong)(int32_t)((temp & MIPSDSP_LHI) >> 32);
3542 env->active_tc.LO[ac] = (target_ulong)(int32_t)(temp & MIPSDSP_LLO);
3543 }
3544
3545 #if defined(TARGET_MIPS64)
3546 void helper_dshilo(target_ulong shift, target_ulong ac, CPUMIPSState *env)
3547 {
3548 int8_t shift_t;
3549 uint64_t tempB, tempA;
3550
3551 shift_t = (int8_t)(shift << 1) >> 1;
3552
3553 tempB = env->active_tc.HI[ac];
3554 tempA = env->active_tc.LO[ac];
3555
3556 if (shift_t != 0) {
3557 if (shift_t >= 0) {
3558 tempA = (tempB << (64 - shift_t)) | (tempA >> shift_t);
3559 tempB = tempB >> shift_t;
3560 } else {
3561 shift_t = -shift_t;
3562 tempB = (tempB << shift_t) | (tempA >> (64 - shift_t));
3563 tempA = tempA << shift_t;
3564 }
3565 }
3566
3567 env->active_tc.HI[ac] = tempB;
3568 env->active_tc.LO[ac] = tempA;
3569 }
3570
3571 #endif
3572 void helper_mthlip(target_ulong ac, target_ulong rs, CPUMIPSState *env)
3573 {
3574 int32_t tempA, tempB, pos;
3575
3576 tempA = rs;
3577 tempB = env->active_tc.LO[ac];
3578 env->active_tc.HI[ac] = (target_long)tempB;
3579 env->active_tc.LO[ac] = (target_long)tempA;
3580 pos = get_DSPControl_pos(env);
3581
3582 if (pos > 32) {
3583 return;
3584 } else {
3585 set_DSPControl_pos(pos + 32, env);
3586 }
3587 }
3588
3589 #if defined(TARGET_MIPS64)
3590 void helper_dmthlip(target_ulong rs, target_ulong ac, CPUMIPSState *env)
3591 {
3592 uint8_t ac_t;
3593 uint8_t pos;
3594 uint64_t tempB, tempA;
3595
3596 ac_t = ac & 0x3;
3597
3598 tempA = rs;
3599 tempB = env->active_tc.LO[ac_t];
3600
3601 env->active_tc.HI[ac_t] = tempB;
3602 env->active_tc.LO[ac_t] = tempA;
3603
3604 pos = get_DSPControl_pos(env);
3605
3606 if (pos <= 64) {
3607 pos = pos + 64;
3608 set_DSPControl_pos(pos, env);
3609 }
3610 }
3611 #endif
3612
3613 void cpu_wrdsp(uint32_t rs, uint32_t mask_num, CPUMIPSState *env)
3614 {
3615 uint8_t mask[6];
3616 uint8_t i;
3617 uint32_t newbits, overwrite;
3618 target_ulong dsp;
3619
3620 newbits = 0x00;
3621 overwrite = 0xFFFFFFFF;
3622 dsp = env->active_tc.DSPControl;
3623
3624 for (i = 0; i < 6; i++) {
3625 mask[i] = (mask_num >> i) & 0x01;
3626 }
3627
3628 if (mask[0] == 1) {
3629 #if defined(TARGET_MIPS64)
3630 overwrite &= 0xFFFFFF80;
3631 newbits &= 0xFFFFFF80;
3632 newbits |= 0x0000007F & rs;
3633 #else
3634 overwrite &= 0xFFFFFFC0;
3635 newbits &= 0xFFFFFFC0;
3636 newbits |= 0x0000003F & rs;
3637 #endif
3638 }
3639
3640 if (mask[1] == 1) {
3641 overwrite &= 0xFFFFE07F;
3642 newbits &= 0xFFFFE07F;
3643 newbits |= 0x00001F80 & rs;
3644 }
3645
3646 if (mask[2] == 1) {
3647 overwrite &= 0xFFFFDFFF;
3648 newbits &= 0xFFFFDFFF;
3649 newbits |= 0x00002000 & rs;
3650 }
3651
3652 if (mask[3] == 1) {
3653 overwrite &= 0xFF00FFFF;
3654 newbits &= 0xFF00FFFF;
3655 newbits |= 0x00FF0000 & rs;
3656 }
3657
3658 if (mask[4] == 1) {
3659 overwrite &= 0x00FFFFFF;
3660 newbits &= 0x00FFFFFF;
3661 #if defined(TARGET_MIPS64)
3662 newbits |= 0xFF000000 & rs;
3663 #else
3664 newbits |= 0x0F000000 & rs;
3665 #endif
3666 }
3667
3668 if (mask[5] == 1) {
3669 overwrite &= 0xFFFFBFFF;
3670 newbits &= 0xFFFFBFFF;
3671 newbits |= 0x00004000 & rs;
3672 }
3673
3674 dsp = dsp & overwrite;
3675 dsp = dsp | newbits;
3676 env->active_tc.DSPControl = dsp;
3677 }
3678
3679 void helper_wrdsp(target_ulong rs, target_ulong mask_num, CPUMIPSState *env)
3680 {
3681 cpu_wrdsp(rs, mask_num, env);
3682 }
3683
3684 uint32_t cpu_rddsp(uint32_t mask_num, CPUMIPSState *env)
3685 {
3686 uint8_t mask[6];
3687 uint32_t ruler, i;
3688 target_ulong temp;
3689 target_ulong dsp;
3690
3691 ruler = 0x01;
3692 for (i = 0; i < 6; i++) {
3693 mask[i] = (mask_num & ruler) >> i ;
3694 ruler = ruler << 1;
3695 }
3696
3697 temp = 0x00;
3698 dsp = env->active_tc.DSPControl;
3699
3700 if (mask[0] == 1) {
3701 #if defined(TARGET_MIPS64)
3702 temp |= dsp & 0x7F;
3703 #else
3704 temp |= dsp & 0x3F;
3705 #endif
3706 }
3707
3708 if (mask[1] == 1) {
3709 temp |= dsp & 0x1F80;
3710 }
3711
3712 if (mask[2] == 1) {
3713 temp |= dsp & 0x2000;
3714 }
3715
3716 if (mask[3] == 1) {
3717 temp |= dsp & 0x00FF0000;
3718 }
3719
3720 if (mask[4] == 1) {
3721 #if defined(TARGET_MIPS64)
3722 temp |= dsp & 0xFF000000;
3723 #else
3724 temp |= dsp & 0x0F000000;
3725 #endif
3726 }
3727
3728 if (mask[5] == 1) {
3729 temp |= dsp & 0x4000;
3730 }
3731
3732 return temp;
3733 }
3734
3735 target_ulong helper_rddsp(target_ulong mask_num, CPUMIPSState *env)
3736 {
3737 return cpu_rddsp(mask_num, env);
3738 }
3739
3740
3741 #undef MIPSDSP_LHI
3742 #undef MIPSDSP_LLO
3743 #undef MIPSDSP_HI
3744 #undef MIPSDSP_LO
3745 #undef MIPSDSP_Q3
3746 #undef MIPSDSP_Q2
3747 #undef MIPSDSP_Q1
3748 #undef MIPSDSP_Q0
3749
3750 #undef MIPSDSP_SPLIT32_8
3751 #undef MIPSDSP_SPLIT32_16
3752
3753 #undef MIPSDSP_RETURN32_8
3754 #undef MIPSDSP_RETURN32_16
3755
3756 #ifdef TARGET_MIPS64
3757 #undef MIPSDSP_SPLIT64_16
3758 #undef MIPSDSP_SPLIT64_32
3759 #undef MIPSDSP_RETURN64_16
3760 #undef MIPSDSP_RETURN64_32
3761 #endif
AR7 emulation for QEMU