?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kvm: qemu: make kvm_arch_load_regs() aware of in kernel APIC
[kvm-userspace.git] / qemu / target-sparc / op.c
blob921699e4c0945853c9c851a9969869209daa9f2d
1 /*
2 SPARC micro operations
3
4 Copyright (C) 2003 Thomas M. Ogrisegg <tom@fnord.at>
5
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2 of the License, or (at your option) any later version.
10
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with this library; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "exec.h"
22 #include "helper.h"
23
24 #define REGNAME f0
25 #define REG (env->fpr[0])
26 #include "fop_template.h"
27 #define REGNAME f1
28 #define REG (env->fpr[1])
29 #include "fop_template.h"
30 #define REGNAME f2
31 #define REG (env->fpr[2])
32 #include "fop_template.h"
33 #define REGNAME f3
34 #define REG (env->fpr[3])
35 #include "fop_template.h"
36 #define REGNAME f4
37 #define REG (env->fpr[4])
38 #include "fop_template.h"
39 #define REGNAME f5
40 #define REG (env->fpr[5])
41 #include "fop_template.h"
42 #define REGNAME f6
43 #define REG (env->fpr[6])
44 #include "fop_template.h"
45 #define REGNAME f7
46 #define REG (env->fpr[7])
47 #include "fop_template.h"
48 #define REGNAME f8
49 #define REG (env->fpr[8])
50 #include "fop_template.h"
51 #define REGNAME f9
52 #define REG (env->fpr[9])
53 #include "fop_template.h"
54 #define REGNAME f10
55 #define REG (env->fpr[10])
56 #include "fop_template.h"
57 #define REGNAME f11
58 #define REG (env->fpr[11])
59 #include "fop_template.h"
60 #define REGNAME f12
61 #define REG (env->fpr[12])
62 #include "fop_template.h"
63 #define REGNAME f13
64 #define REG (env->fpr[13])
65 #include "fop_template.h"
66 #define REGNAME f14
67 #define REG (env->fpr[14])
68 #include "fop_template.h"
69 #define REGNAME f15
70 #define REG (env->fpr[15])
71 #include "fop_template.h"
72 #define REGNAME f16
73 #define REG (env->fpr[16])
74 #include "fop_template.h"
75 #define REGNAME f17
76 #define REG (env->fpr[17])
77 #include "fop_template.h"
78 #define REGNAME f18
79 #define REG (env->fpr[18])
80 #include "fop_template.h"
81 #define REGNAME f19
82 #define REG (env->fpr[19])
83 #include "fop_template.h"
84 #define REGNAME f20
85 #define REG (env->fpr[20])
86 #include "fop_template.h"
87 #define REGNAME f21
88 #define REG (env->fpr[21])
89 #include "fop_template.h"
90 #define REGNAME f22
91 #define REG (env->fpr[22])
92 #include "fop_template.h"
93 #define REGNAME f23
94 #define REG (env->fpr[23])
95 #include "fop_template.h"
96 #define REGNAME f24
97 #define REG (env->fpr[24])
98 #include "fop_template.h"
99 #define REGNAME f25
100 #define REG (env->fpr[25])
101 #include "fop_template.h"
102 #define REGNAME f26
103 #define REG (env->fpr[26])
104 #include "fop_template.h"
105 #define REGNAME f27
106 #define REG (env->fpr[27])
107 #include "fop_template.h"
108 #define REGNAME f28
109 #define REG (env->fpr[28])
110 #include "fop_template.h"
111 #define REGNAME f29
112 #define REG (env->fpr[29])
113 #include "fop_template.h"
114 #define REGNAME f30
115 #define REG (env->fpr[30])
116 #include "fop_template.h"
117 #define REGNAME f31
118 #define REG (env->fpr[31])
119 #include "fop_template.h"
120
121 #ifdef TARGET_SPARC64
122 #define REGNAME f32
123 #define REG (env->fpr[32])
124 #include "fop_template.h"
125 #define REGNAME f34
126 #define REG (env->fpr[34])
127 #include "fop_template.h"
128 #define REGNAME f36
129 #define REG (env->fpr[36])
130 #include "fop_template.h"
131 #define REGNAME f38
132 #define REG (env->fpr[38])
133 #include "fop_template.h"
134 #define REGNAME f40
135 #define REG (env->fpr[40])
136 #include "fop_template.h"
137 #define REGNAME f42
138 #define REG (env->fpr[42])
139 #include "fop_template.h"
140 #define REGNAME f44
141 #define REG (env->fpr[44])
142 #include "fop_template.h"
143 #define REGNAME f46
144 #define REG (env->fpr[46])
145 #include "fop_template.h"
146 #define REGNAME f48
147 #define REG (env->fpr[47])
148 #include "fop_template.h"
149 #define REGNAME f50
150 #define REG (env->fpr[50])
151 #include "fop_template.h"
152 #define REGNAME f52
153 #define REG (env->fpr[52])
154 #include "fop_template.h"
155 #define REGNAME f54
156 #define REG (env->fpr[54])
157 #include "fop_template.h"
158 #define REGNAME f56
159 #define REG (env->fpr[56])
160 #include "fop_template.h"
161 #define REGNAME f58
162 #define REG (env->fpr[58])
163 #include "fop_template.h"
164 #define REGNAME f60
165 #define REG (env->fpr[60])
166 #include "fop_template.h"
167 #define REGNAME f62
168 #define REG (env->fpr[62])
169 #include "fop_template.h"
170 #endif
171
172 #define FLAG_SET(x) ((env->psr&x)?1:0)
173
174 void OPPROTO op_umul_T1_T0(void)
175 {
176 uint64_t res;
177 res = (uint64_t) T0 * (uint64_t) T1;
178 #ifdef TARGET_SPARC64
179 T0 = res;
180 #else
181 T0 = res & 0xffffffff;
182 #endif
183 env->y = res >> 32;
184 }
185
186 void OPPROTO op_smul_T1_T0(void)
187 {
188 uint64_t res;
189 res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1);
190 #ifdef TARGET_SPARC64
191 T0 = res;
192 #else
193 T0 = res & 0xffffffff;
194 #endif
195 env->y = res >> 32;
196 }
197
198 void OPPROTO op_mulscc_T1_T0(void)
199 {
200 unsigned int b1, N, V, b2;
201 target_ulong src1;
202
203 N = FLAG_SET(PSR_NEG);
204 V = FLAG_SET(PSR_OVF);
205 b1 = N ^ V;
206 b2 = T0 & 1;
207 T0 = (b1 << 31) | (T0 >> 1);
208 if (!(env->y & 1))
209 T1 = 0;
210 /* do addition and update flags */
211 src1 = T0;
212 T0 += T1;
213 env->psr = 0;
214 if (!T0)
215 env->psr |= PSR_ZERO;
216 if ((int32_t) T0 < 0)
217 env->psr |= PSR_NEG;
218 if (T0 < src1)
219 env->psr |= PSR_CARRY;
220 if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
221 env->psr |= PSR_OVF;
222 env->y = (b2 << 31) | (env->y >> 1);
223 FORCE_RET();
224 }
225
226 void OPPROTO op_udiv_T1_T0(void)
227 {
228 uint64_t x0;
229 uint32_t x1;
230
231 x0 = T0 | ((uint64_t) (env->y) << 32);
232 x1 = T1;
233
234 if (x1 == 0) {
235 raise_exception(TT_DIV_ZERO);
236 }
237
238 x0 = x0 / x1;
239 if (x0 > 0xffffffff) {
240 T0 = 0xffffffff;
241 T1 = 1;
242 } else {
243 T0 = x0;
244 T1 = 0;
245 }
246 FORCE_RET();
247 }
248
249 void OPPROTO op_sdiv_T1_T0(void)
250 {
251 int64_t x0;
252 int32_t x1;
253
254 x0 = T0 | ((int64_t) (env->y) << 32);
255 x1 = T1;
256
257 if (x1 == 0) {
258 raise_exception(TT_DIV_ZERO);
259 }
260
261 x0 = x0 / x1;
262 if ((int32_t) x0 != x0) {
263 T0 = x0 < 0? 0x80000000: 0x7fffffff;
264 T1 = 1;
265 } else {
266 T0 = x0;
267 T1 = 0;
268 }
269 FORCE_RET();
270 }
271
272 /* Load and store */
273 #define MEMSUFFIX _raw
274 #include "op_mem.h"
275 #if !defined(CONFIG_USER_ONLY)
276 #define MEMSUFFIX _user
277 #include "op_mem.h"
278
279 #define MEMSUFFIX _kernel
280 #include "op_mem.h"
281
282 #ifdef TARGET_SPARC64
283 #define MEMSUFFIX _hypv
284 #include "op_mem.h"
285 #endif
286 #endif
287
288 #ifndef TARGET_SPARC64
289 /* XXX: use another pointer for %iN registers to avoid slow wrapping
290 handling ? */
291 void OPPROTO op_save(void)
292 {
293 uint32_t cwp;
294 cwp = (env->cwp - 1) & (NWINDOWS - 1);
295 if (env->wim & (1 << cwp)) {
296 raise_exception(TT_WIN_OVF);
297 }
298 set_cwp(cwp);
299 FORCE_RET();
300 }
301
302 void OPPROTO op_restore(void)
303 {
304 uint32_t cwp;
305 cwp = (env->cwp + 1) & (NWINDOWS - 1);
306 if (env->wim & (1 << cwp)) {
307 raise_exception(TT_WIN_UNF);
308 }
309 set_cwp(cwp);
310 FORCE_RET();
311 }
312 #else
313 void OPPROTO op_rdccr(void)
314 {
315 T0 = GET_CCR(env);
316 }
317
318 void OPPROTO op_wrccr(void)
319 {
320 PUT_CCR(env, T0);
321 }
322
323 // CWP handling is reversed in V9, but we still use the V8 register
324 // order.
325 void OPPROTO op_rdcwp(void)
326 {
327 T0 = GET_CWP64(env);
328 }
329
330 void OPPROTO op_wrcwp(void)
331 {
332 PUT_CWP64(env, T0);
333 }
334
335 /* XXX: use another pointer for %iN registers to avoid slow wrapping
336 handling ? */
337 void OPPROTO op_save(void)
338 {
339 uint32_t cwp;
340 cwp = (env->cwp - 1) & (NWINDOWS - 1);
341 if (env->cansave == 0) {
342 raise_exception(TT_SPILL | (env->otherwin != 0 ?
343 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
344 ((env->wstate & 0x7) << 2)));
345 } else {
346 if (env->cleanwin - env->canrestore == 0) {
347 // XXX Clean windows without trap
348 raise_exception(TT_CLRWIN);
349 } else {
350 env->cansave--;
351 env->canrestore++;
352 set_cwp(cwp);
353 }
354 }
355 FORCE_RET();
356 }
357
358 void OPPROTO op_restore(void)
359 {
360 uint32_t cwp;
361 cwp = (env->cwp + 1) & (NWINDOWS - 1);
362 if (env->canrestore == 0) {
363 raise_exception(TT_FILL | (env->otherwin != 0 ?
364 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
365 ((env->wstate & 0x7) << 2)));
366 } else {
367 env->cansave++;
368 env->canrestore--;
369 set_cwp(cwp);
370 }
371 FORCE_RET();
372 }
373 #endif
374
375 void OPPROTO op_jmp_label(void)
376 {
377 GOTO_LABEL_PARAM(1);
378 }
379
380 #define F_OP(name, p) void OPPROTO op_f##name##p(void)
381
382 #if defined(CONFIG_USER_ONLY)
383 #define F_BINOP(name) \
384 F_OP(name, s) \
385 { \
386 FT0 = float32_ ## name (FT0, FT1, &env->fp_status); \
387 } \
388 F_OP(name, d) \
389 { \
390 DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
391 } \
392 F_OP(name, q) \
393 { \
394 QT0 = float128_ ## name (QT0, QT1, &env->fp_status); \
395 }
396 #else
397 #define F_BINOP(name) \
398 F_OP(name, s) \
399 { \
400 FT0 = float32_ ## name (FT0, FT1, &env->fp_status); \
401 } \
402 F_OP(name, d) \
403 { \
404 DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
405 }
406 #endif
407
408 F_BINOP(add);
409 F_BINOP(sub);
410 F_BINOP(mul);
411 F_BINOP(div);
412 #undef F_BINOP
413
414 void OPPROTO op_fsmuld(void)
415 {
416 DT0 = float64_mul(float32_to_float64(FT0, &env->fp_status),
417 float32_to_float64(FT1, &env->fp_status),
418 &env->fp_status);
419 }
420
421 #if defined(CONFIG_USER_ONLY)
422 void OPPROTO op_fdmulq(void)
423 {
424 QT0 = float128_mul(float64_to_float128(DT0, &env->fp_status),
425 float64_to_float128(DT1, &env->fp_status),
426 &env->fp_status);
427 }
428 #endif
429
430 #if defined(CONFIG_USER_ONLY)
431 #define F_HELPER(name) \
432 F_OP(name, s) \
433 { \
434 do_f##name##s(); \
435 } \
436 F_OP(name, d) \
437 { \
438 do_f##name##d(); \
439 } \
440 F_OP(name, q) \
441 { \
442 do_f##name##q(); \
443 }
444 #else
445 #define F_HELPER(name) \
446 F_OP(name, s) \
447 { \
448 do_f##name##s(); \
449 } \
450 F_OP(name, d) \
451 { \
452 do_f##name##d(); \
453 }
454 #endif
455
456 F_OP(neg, s)
457 {
458 FT0 = float32_chs(FT1);
459 }
460
461 #ifdef TARGET_SPARC64
462 F_OP(neg, d)
463 {
464 DT0 = float64_chs(DT1);
465 }
466
467 #if defined(CONFIG_USER_ONLY)
468 F_OP(neg, q)
469 {
470 QT0 = float128_chs(QT1);
471 }
472
473 #endif
474
475 #endif
476
477 /* Integer to float conversion. */
478 #ifdef USE_INT_TO_FLOAT_HELPERS
479 F_HELPER(ito);
480 #ifdef TARGET_SPARC64
481 F_HELPER(xto);
482 #endif
483 #else
484 F_OP(ito, s)
485 {
486 FT0 = int32_to_float32(*((int32_t *)&FT1), &env->fp_status);
487 }
488
489 F_OP(ito, d)
490 {
491 DT0 = int32_to_float64(*((int32_t *)&FT1), &env->fp_status);
492 }
493
494 #if defined(CONFIG_USER_ONLY)
495 F_OP(ito, q)
496 {
497 QT0 = int32_to_float128(*((int32_t *)&FT1), &env->fp_status);
498 }
499 #endif
500
501 #ifdef TARGET_SPARC64
502 F_OP(xto, s)
503 {
504 FT0 = int64_to_float32(*((int64_t *)&DT1), &env->fp_status);
505 }
506
507 F_OP(xto, d)
508 {
509 DT0 = int64_to_float64(*((int64_t *)&DT1), &env->fp_status);
510 }
511 #if defined(CONFIG_USER_ONLY)
512 F_OP(xto, q)
513 {
514 QT0 = int64_to_float128(*((int64_t *)&DT1), &env->fp_status);
515 }
516 #endif
517 #endif
518 #endif
519 #undef F_HELPER
520
521 /* floating point conversion */
522 void OPPROTO op_fdtos(void)
523 {
524 FT0 = float64_to_float32(DT1, &env->fp_status);
525 }
526
527 void OPPROTO op_fstod(void)
528 {
529 DT0 = float32_to_float64(FT1, &env->fp_status);
530 }
531
532 #if defined(CONFIG_USER_ONLY)
533 void OPPROTO op_fqtos(void)
534 {
535 FT0 = float128_to_float32(QT1, &env->fp_status);
536 }
537
538 void OPPROTO op_fstoq(void)
539 {
540 QT0 = float32_to_float128(FT1, &env->fp_status);
541 }
542
543 void OPPROTO op_fqtod(void)
544 {
545 DT0 = float128_to_float64(QT1, &env->fp_status);
546 }
547
548 void OPPROTO op_fdtoq(void)
549 {
550 QT0 = float64_to_float128(DT1, &env->fp_status);
551 }
552 #endif
553
554 /* Float to integer conversion. */
555 void OPPROTO op_fstoi(void)
556 {
557 *((int32_t *)&FT0) = float32_to_int32_round_to_zero(FT1, &env->fp_status);
558 }
559
560 void OPPROTO op_fdtoi(void)
561 {
562 *((int32_t *)&FT0) = float64_to_int32_round_to_zero(DT1, &env->fp_status);
563 }
564
565 #if defined(CONFIG_USER_ONLY)
566 void OPPROTO op_fqtoi(void)
567 {
568 *((int32_t *)&FT0) = float128_to_int32_round_to_zero(QT1, &env->fp_status);
569 }
570 #endif
571
572 #ifdef TARGET_SPARC64
573 void OPPROTO op_fstox(void)
574 {
575 *((int64_t *)&DT0) = float32_to_int64_round_to_zero(FT1, &env->fp_status);
576 }
577
578 void OPPROTO op_fdtox(void)
579 {
580 *((int64_t *)&DT0) = float64_to_int64_round_to_zero(DT1, &env->fp_status);
581 }
582
583 #if defined(CONFIG_USER_ONLY)
584 void OPPROTO op_fqtox(void)
585 {
586 *((int64_t *)&DT0) = float128_to_int64_round_to_zero(QT1, &env->fp_status);
587 }
588 #endif
589
590 void OPPROTO op_flushw(void)
591 {
592 if (env->cansave != NWINDOWS - 2) {
593 raise_exception(TT_SPILL | (env->otherwin != 0 ?
594 (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
595 ((env->wstate & 0x7) << 2)));
596 }
597 }
598
599 void OPPROTO op_saved(void)
600 {
601 env->cansave++;
602 if (env->otherwin == 0)
603 env->canrestore--;
604 else
605 env->otherwin--;
606 FORCE_RET();
607 }
608
609 void OPPROTO op_restored(void)
610 {
611 env->canrestore++;
612 if (env->cleanwin < NWINDOWS - 1)
613 env->cleanwin++;
614 if (env->otherwin == 0)
615 env->cansave--;
616 else
617 env->otherwin--;
618 FORCE_RET();
619 }
620 #endif
621
622 #ifdef TARGET_SPARC64
623 // This function uses non-native bit order
624 #define GET_FIELD(X, FROM, TO) \
625 ((X) >> (63 - (TO)) & ((1ULL << ((TO) - (FROM) + 1)) - 1))
626
627 // This function uses the order in the manuals, i.e. bit 0 is 2^0
628 #define GET_FIELD_SP(X, FROM, TO) \
629 GET_FIELD(X, 63 - (TO), 63 - (FROM))
630
631 void OPPROTO op_array8()
632 {
633 T0 = (GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
634 (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
635 (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
636 (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
637 (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
638 (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12);
639 }
640
641 void OPPROTO op_array16()
642 {
643 T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
644 (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
645 (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
646 (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
647 (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
648 (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 1;
649 }
650
651 void OPPROTO op_array32()
652 {
653 T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
654 (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
655 (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
656 (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
657 (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
658 (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 2;
659 }
660
661 void OPPROTO op_alignaddr()
662 {
663 uint64_t tmp;
664
665 tmp = T0 + T1;
666 env->gsr &= ~7ULL;
667 env->gsr |= tmp & 7ULL;
668 T0 = tmp & ~7ULL;
669 }
670
671 void OPPROTO op_faligndata()
672 {
673 uint64_t tmp;
674
675 tmp = (*((uint64_t *)&DT0)) << ((env->gsr & 7) * 8);
676 tmp |= (*((uint64_t *)&DT1)) >> (64 - (env->gsr & 7) * 8);
677 *((uint64_t *)&DT0) = tmp;
678 }
679
680 void OPPROTO op_movl_FT0_0(void)
681 {
682 *((uint32_t *)&FT0) = 0;
683 }
684
685 void OPPROTO op_movl_DT0_0(void)
686 {
687 *((uint64_t *)&DT0) = 0;
688 }
689
690 void OPPROTO op_movl_FT0_1(void)
691 {
692 *((uint32_t *)&FT0) = 0xffffffff;
693 }
694
695 void OPPROTO op_movl_DT0_1(void)
696 {
697 *((uint64_t *)&DT0) = 0xffffffffffffffffULL;
698 }
699
700 void OPPROTO op_fnot(void)
701 {
702 *(uint64_t *)&DT0 = ~*(uint64_t *)&DT1;
703 }
704
705 void OPPROTO op_fnots(void)
706 {
707 *(uint32_t *)&FT0 = ~*(uint32_t *)&FT1;
708 }
709
710 void OPPROTO op_fnor(void)
711 {
712 *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 | *(uint64_t *)&DT1);
713 }
714
715 void OPPROTO op_fnors(void)
716 {
717 *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 | *(uint32_t *)&FT1);
718 }
719
720 void OPPROTO op_for(void)
721 {
722 *(uint64_t *)&DT0 |= *(uint64_t *)&DT1;
723 }
724
725 void OPPROTO op_fors(void)
726 {
727 *(uint32_t *)&FT0 |= *(uint32_t *)&FT1;
728 }
729
730 void OPPROTO op_fxor(void)
731 {
732 *(uint64_t *)&DT0 ^= *(uint64_t *)&DT1;
733 }
734
735 void OPPROTO op_fxors(void)
736 {
737 *(uint32_t *)&FT0 ^= *(uint32_t *)&FT1;
738 }
739
740 void OPPROTO op_fand(void)
741 {
742 *(uint64_t *)&DT0 &= *(uint64_t *)&DT1;
743 }
744
745 void OPPROTO op_fands(void)
746 {
747 *(uint32_t *)&FT0 &= *(uint32_t *)&FT1;
748 }
749
750 void OPPROTO op_fornot(void)
751 {
752 *(uint64_t *)&DT0 = *(uint64_t *)&DT0 | ~*(uint64_t *)&DT1;
753 }
754
755 void OPPROTO op_fornots(void)
756 {
757 *(uint32_t *)&FT0 = *(uint32_t *)&FT0 | ~*(uint32_t *)&FT1;
758 }
759
760 void OPPROTO op_fandnot(void)
761 {
762 *(uint64_t *)&DT0 = *(uint64_t *)&DT0 & ~*(uint64_t *)&DT1;
763 }
764
765 void OPPROTO op_fandnots(void)
766 {
767 *(uint32_t *)&FT0 = *(uint32_t *)&FT0 & ~*(uint32_t *)&FT1;
768 }
769
770 void OPPROTO op_fnand(void)
771 {
772 *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 & *(uint64_t *)&DT1);
773 }
774
775 void OPPROTO op_fnands(void)
776 {
777 *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 & *(uint32_t *)&FT1);
778 }
779
780 void OPPROTO op_fxnor(void)
781 {
782 *(uint64_t *)&DT0 ^= ~*(uint64_t *)&DT1;
783 }
784
785 void OPPROTO op_fxnors(void)
786 {
787 *(uint32_t *)&FT0 ^= ~*(uint32_t *)&FT1;
788 }
789
790 #ifdef WORDS_BIGENDIAN
791 #define VIS_B64(n) b[7 - (n)]
792 #define VIS_W64(n) w[3 - (n)]
793 #define VIS_SW64(n) sw[3 - (n)]
794 #define VIS_L64(n) l[1 - (n)]
795 #define VIS_B32(n) b[3 - (n)]
796 #define VIS_W32(n) w[1 - (n)]
797 #else
798 #define VIS_B64(n) b[n]
799 #define VIS_W64(n) w[n]
800 #define VIS_SW64(n) sw[n]
801 #define VIS_L64(n) l[n]
802 #define VIS_B32(n) b[n]
803 #define VIS_W32(n) w[n]
804 #endif
805
806 typedef union {
807 uint8_t b[8];
808 uint16_t w[4];
809 int16_t sw[4];
810 uint32_t l[2];
811 float64 d;
812 } vis64;
813
814 typedef union {
815 uint8_t b[4];
816 uint16_t w[2];
817 uint32_t l;
818 float32 f;
819 } vis32;
820
821 void OPPROTO op_fpmerge(void)
822 {
823 vis64 s, d;
824
825 s.d = DT0;
826 d.d = DT1;
827
828 // Reverse calculation order to handle overlap
829 d.VIS_B64(7) = s.VIS_B64(3);
830 d.VIS_B64(6) = d.VIS_B64(3);
831 d.VIS_B64(5) = s.VIS_B64(2);
832 d.VIS_B64(4) = d.VIS_B64(2);
833 d.VIS_B64(3) = s.VIS_B64(1);
834 d.VIS_B64(2) = d.VIS_B64(1);
835 d.VIS_B64(1) = s.VIS_B64(0);
836 //d.VIS_B64(0) = d.VIS_B64(0);
837
838 DT0 = d.d;
839 }
840
841 void OPPROTO op_fmul8x16(void)
842 {
843 vis64 s, d;
844 uint32_t tmp;
845
846 s.d = DT0;
847 d.d = DT1;
848
849 #define PMUL(r) \
850 tmp = (int32_t)d.VIS_SW64(r) * (int32_t)s.VIS_B64(r); \
851 if ((tmp & 0xff) > 0x7f) \
852 tmp += 0x100; \
853 d.VIS_W64(r) = tmp >> 8;
854
855 PMUL(0);
856 PMUL(1);
857 PMUL(2);
858 PMUL(3);
859 #undef PMUL
860
861 DT0 = d.d;
862 }
863
864 void OPPROTO op_fmul8x16al(void)
865 {
866 vis64 s, d;
867 uint32_t tmp;
868
869 s.d = DT0;
870 d.d = DT1;
871
872 #define PMUL(r) \
873 tmp = (int32_t)d.VIS_SW64(1) * (int32_t)s.VIS_B64(r); \
874 if ((tmp & 0xff) > 0x7f) \
875 tmp += 0x100; \
876 d.VIS_W64(r) = tmp >> 8;
877
878 PMUL(0);
879 PMUL(1);
880 PMUL(2);
881 PMUL(3);
882 #undef PMUL
883
884 DT0 = d.d;
885 }
886
887 void OPPROTO op_fmul8x16au(void)
888 {
889 vis64 s, d;
890 uint32_t tmp;
891
892 s.d = DT0;
893 d.d = DT1;
894
895 #define PMUL(r) \
896 tmp = (int32_t)d.VIS_SW64(0) * (int32_t)s.VIS_B64(r); \
897 if ((tmp & 0xff) > 0x7f) \
898 tmp += 0x100; \
899 d.VIS_W64(r) = tmp >> 8;
900
901 PMUL(0);
902 PMUL(1);
903 PMUL(2);
904 PMUL(3);
905 #undef PMUL
906
907 DT0 = d.d;
908 }
909
910 void OPPROTO op_fmul8sux16(void)
911 {
912 vis64 s, d;
913 uint32_t tmp;
914
915 s.d = DT0;
916 d.d = DT1;
917
918 #define PMUL(r) \
919 tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
920 if ((tmp & 0xff) > 0x7f) \
921 tmp += 0x100; \
922 d.VIS_W64(r) = tmp >> 8;
923
924 PMUL(0);
925 PMUL(1);
926 PMUL(2);
927 PMUL(3);
928 #undef PMUL
929
930 DT0 = d.d;
931 }
932
933 void OPPROTO op_fmul8ulx16(void)
934 {
935 vis64 s, d;
936 uint32_t tmp;
937
938 s.d = DT0;
939 d.d = DT1;
940
941 #define PMUL(r) \
942 tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
943 if ((tmp & 0xff) > 0x7f) \
944 tmp += 0x100; \
945 d.VIS_W64(r) = tmp >> 8;
946
947 PMUL(0);
948 PMUL(1);
949 PMUL(2);
950 PMUL(3);
951 #undef PMUL
952
953 DT0 = d.d;
954 }
955
956 void OPPROTO op_fmuld8sux16(void)
957 {
958 vis64 s, d;
959 uint32_t tmp;
960
961 s.d = DT0;
962 d.d = DT1;
963
964 #define PMUL(r) \
965 tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
966 if ((tmp & 0xff) > 0x7f) \
967 tmp += 0x100; \
968 d.VIS_L64(r) = tmp;
969
970 // Reverse calculation order to handle overlap
971 PMUL(1);
972 PMUL(0);
973 #undef PMUL
974
975 DT0 = d.d;
976 }
977
978 void OPPROTO op_fmuld8ulx16(void)
979 {
980 vis64 s, d;
981 uint32_t tmp;
982
983 s.d = DT0;
984 d.d = DT1;
985
986 #define PMUL(r) \
987 tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
988 if ((tmp & 0xff) > 0x7f) \
989 tmp += 0x100; \
990 d.VIS_L64(r) = tmp;
991
992 // Reverse calculation order to handle overlap
993 PMUL(1);
994 PMUL(0);
995 #undef PMUL
996
997 DT0 = d.d;
998 }
999
1000 void OPPROTO op_fexpand(void)
1001 {
1002 vis32 s;
1003 vis64 d;
1004
1005 s.l = (uint32_t)(*(uint64_t *)&DT0 & 0xffffffff);
1006 d.d = DT1;
1007 d.VIS_L64(0) = s.VIS_W32(0) << 4;
1008 d.VIS_L64(1) = s.VIS_W32(1) << 4;
1009 d.VIS_L64(2) = s.VIS_W32(2) << 4;
1010 d.VIS_L64(3) = s.VIS_W32(3) << 4;
1011
1012 DT0 = d.d;
1013 }
1014
1015 #define VIS_OP(name, F) \
1016 void OPPROTO name##16(void) \
1017 { \
1018 vis64 s, d; \
1019 \
1020 s.d = DT0; \
1021 d.d = DT1; \
1022 \
1023 d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0)); \
1024 d.VIS_W64(1) = F(d.VIS_W64(1), s.VIS_W64(1)); \
1025 d.VIS_W64(2) = F(d.VIS_W64(2), s.VIS_W64(2)); \
1026 d.VIS_W64(3) = F(d.VIS_W64(3), s.VIS_W64(3)); \
1027 \
1028 DT0 = d.d; \
1029 } \
1030 \
1031 void OPPROTO name##16s(void) \
1032 { \
1033 vis32 s, d; \
1034 \
1035 s.f = FT0; \
1036 d.f = FT1; \
1037 \
1038 d.VIS_W32(0) = F(d.VIS_W32(0), s.VIS_W32(0)); \
1039 d.VIS_W32(1) = F(d.VIS_W32(1), s.VIS_W32(1)); \
1040 \
1041 FT0 = d.f; \
1042 } \
1043 \
1044 void OPPROTO name##32(void) \
1045 { \
1046 vis64 s, d; \
1047 \
1048 s.d = DT0; \
1049 d.d = DT1; \
1050 \
1051 d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0)); \
1052 d.VIS_L64(1) = F(d.VIS_L64(1), s.VIS_L64(1)); \
1053 \
1054 DT0 = d.d; \
1055 } \
1056 \
1057 void OPPROTO name##32s(void) \
1058 { \
1059 vis32 s, d; \
1060 \
1061 s.f = FT0; \
1062 d.f = FT1; \
1063 \
1064 d.l = F(d.l, s.l); \
1065 \
1066 FT0 = d.f; \
1067 }
1068
1069 #define FADD(a, b) ((a) + (b))
1070 #define FSUB(a, b) ((a) - (b))
1071 VIS_OP(op_fpadd, FADD)
1072 VIS_OP(op_fpsub, FSUB)
1073
1074 #define VIS_CMPOP(name, F) \
1075 void OPPROTO name##16(void) \
1076 { \
1077 vis64 s, d; \
1078 \
1079 s.d = DT0; \
1080 d.d = DT1; \
1081 \
1082 d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0))? 1: 0; \
1083 d.VIS_W64(0) |= F(d.VIS_W64(1), s.VIS_W64(1))? 2: 0; \
1084 d.VIS_W64(0) |= F(d.VIS_W64(2), s.VIS_W64(2))? 4: 0; \
1085 d.VIS_W64(0) |= F(d.VIS_W64(3), s.VIS_W64(3))? 8: 0; \
1086 \
1087 DT0 = d.d; \
1088 } \
1089 \
1090 void OPPROTO name##32(void) \
1091 { \
1092 vis64 s, d; \
1093 \
1094 s.d = DT0; \
1095 d.d = DT1; \
1096 \
1097 d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0))? 1: 0; \
1098 d.VIS_L64(0) |= F(d.VIS_L64(1), s.VIS_L64(1))? 2: 0; \
1099 \
1100 DT0 = d.d; \
1101 }
1102
1103 #define FCMPGT(a, b) ((a) > (b))
1104 #define FCMPEQ(a, b) ((a) == (b))
1105 #define FCMPLE(a, b) ((a) <= (b))
1106 #define FCMPNE(a, b) ((a) != (b))
1107
1108 VIS_CMPOP(op_fcmpgt, FCMPGT)
1109 VIS_CMPOP(op_fcmpeq, FCMPEQ)
1110 VIS_CMPOP(op_fcmple, FCMPLE)
1111 VIS_CMPOP(op_fcmpne, FCMPNE)
1112
1113 #endif
1114
1115 #define CHECK_ALIGN_OP(align) \
1116 void OPPROTO op_check_align_T0_ ## align (void) \
1117 { \
1118 if (T0 & align) \
1119 raise_exception(TT_UNALIGNED); \
1120 FORCE_RET(); \
1121 }
1122
1123 CHECK_ALIGN_OP(1)
1124 CHECK_ALIGN_OP(3)
1125 CHECK_ALIGN_OP(7)
kvm userspace components