?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added code16 tests
[qemu/ar7.git] / op-i386.c
blob70b1d7449004d1bf6895fdef213753232d6f9c61
1 /*
2 * i386 micro operations
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program 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
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20 #include "exec-i386.h"
21
22 /* NOTE: data are not static to force relocation generation by GCC */
23
24 uint8_t parity_table[256] = {
25 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
26 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
27 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
28 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
29 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
30 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
31 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
32 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
33 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
34 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
35 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
36 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
37 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
38 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
39 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
40 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
41 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
42 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
43 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
44 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
45 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
46 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
47 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
48 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
49 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
50 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
51 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
52 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
53 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
54 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
55 CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
56 0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
57 };
58
59 /* modulo 17 table */
60 const uint8_t rclw_table[32] = {
61 0, 1, 2, 3, 4, 5, 6, 7,
62 8, 9,10,11,12,13,14,15,
63 16, 0, 1, 2, 3, 4, 5, 6,
64 7, 8, 9,10,11,12,13,14,
65 };
66
67 /* modulo 9 table */
68 const uint8_t rclb_table[32] = {
69 0, 1, 2, 3, 4, 5, 6, 7,
70 8, 0, 1, 2, 3, 4, 5, 6,
71 7, 8, 0, 1, 2, 3, 4, 5,
72 6, 7, 8, 0, 1, 2, 3, 4,
73 };
74
75 #ifdef USE_X86LDOUBLE
76 /* an array of Intel 80-bit FP constants, to be loaded via integer ops */
77 typedef unsigned short f15ld[5];
78 const f15ld f15rk[] =
79 {
80 /*0*/ {0x0000,0x0000,0x0000,0x0000,0x0000},
81 /*1*/ {0x0000,0x0000,0x0000,0x8000,0x3fff},
82 /*pi*/ {0xc235,0x2168,0xdaa2,0xc90f,0x4000},
83 /*lg2*/ {0xf799,0xfbcf,0x9a84,0x9a20,0x3ffd},
84 /*ln2*/ {0x79ac,0xd1cf,0x17f7,0xb172,0x3ffe},
85 /*l2e*/ {0xf0bc,0x5c17,0x3b29,0xb8aa,0x3fff},
86 /*l2t*/ {0x8afe,0xcd1b,0x784b,0xd49a,0x4000}
87 };
88 #else
89 /* the same, 64-bit version */
90 typedef unsigned short f15ld[4];
91 const f15ld f15rk[] =
92 {
93 #ifndef WORDS_BIGENDIAN
94 /*0*/ {0x0000,0x0000,0x0000,0x0000},
95 /*1*/ {0x0000,0x0000,0x0000,0x3ff0},
96 /*pi*/ {0x2d18,0x5444,0x21fb,0x4009},
97 /*lg2*/ {0x79ff,0x509f,0x4413,0x3fd3},
98 /*ln2*/ {0x39ef,0xfefa,0x2e42,0x3fe6},
99 /*l2e*/ {0x82fe,0x652b,0x1547,0x3ff7},
100 /*l2t*/ {0xa371,0x0979,0x934f,0x400a}
101 #else
102 /*0*/ {0x0000,0x0000,0x0000,0x0000},
103 /*1*/ {0x3ff0,0x0000,0x0000,0x0000},
104 /*pi*/ {0x4009,0x21fb,0x5444,0x2d18},
105 /*lg2*/ {0x3fd3,0x4413,0x509f,0x79ff},
106 /*ln2*/ {0x3fe6,0x2e42,0xfefa,0x39ef},
107 /*l2e*/ {0x3ff7,0x1547,0x652b,0x82fe},
108 /*l2t*/ {0x400a,0x934f,0x0979,0xa371}
109 #endif
110 };
111 #endif
112
113 /* n must be a constant to be efficient */
114 static inline int lshift(int x, int n)
115 {
116 if (n >= 0)
117 return x << n;
118 else
119 return x >> (-n);
120 }
121
122 /* exception support */
123 /* NOTE: not static to force relocation generation by GCC */
124 void raise_exception(int exception_index)
125 {
126 /* NOTE: the register at this point must be saved by hand because
127 longjmp restore them */
128 #ifdef reg_EAX
129 env->regs[R_EAX] = EAX;
130 #endif
131 #ifdef reg_ECX
132 env->regs[R_ECX] = ECX;
133 #endif
134 #ifdef reg_EDX
135 env->regs[R_EDX] = EDX;
136 #endif
137 #ifdef reg_EBX
138 env->regs[R_EBX] = EBX;
139 #endif
140 #ifdef reg_ESP
141 env->regs[R_ESP] = ESP;
142 #endif
143 #ifdef reg_EBP
144 env->regs[R_EBP] = EBP;
145 #endif
146 #ifdef reg_ESI
147 env->regs[R_ESI] = ESI;
148 #endif
149 #ifdef reg_EDI
150 env->regs[R_EDI] = EDI;
151 #endif
152 env->exception_index = exception_index;
153 longjmp(env->jmp_env, 1);
154 }
155
156 /* we define the various pieces of code used by the JIT */
157
158 #define REG EAX
159 #define REGNAME _EAX
160 #include "opreg_template.h"
161 #undef REG
162 #undef REGNAME
163
164 #define REG ECX
165 #define REGNAME _ECX
166 #include "opreg_template.h"
167 #undef REG
168 #undef REGNAME
169
170 #define REG EDX
171 #define REGNAME _EDX
172 #include "opreg_template.h"
173 #undef REG
174 #undef REGNAME
175
176 #define REG EBX
177 #define REGNAME _EBX
178 #include "opreg_template.h"
179 #undef REG
180 #undef REGNAME
181
182 #define REG ESP
183 #define REGNAME _ESP
184 #include "opreg_template.h"
185 #undef REG
186 #undef REGNAME
187
188 #define REG EBP
189 #define REGNAME _EBP
190 #include "opreg_template.h"
191 #undef REG
192 #undef REGNAME
193
194 #define REG ESI
195 #define REGNAME _ESI
196 #include "opreg_template.h"
197 #undef REG
198 #undef REGNAME
199
200 #define REG EDI
201 #define REGNAME _EDI
202 #include "opreg_template.h"
203 #undef REG
204 #undef REGNAME
205
206 /* operations with flags */
207
208 void OPPROTO op_addl_T0_T1_cc(void)
209 {
210 CC_SRC = T0;
211 T0 += T1;
212 CC_DST = T0;
213 }
214
215 void OPPROTO op_orl_T0_T1_cc(void)
216 {
217 T0 |= T1;
218 CC_DST = T0;
219 }
220
221 void OPPROTO op_andl_T0_T1_cc(void)
222 {
223 T0 &= T1;
224 CC_DST = T0;
225 }
226
227 void OPPROTO op_subl_T0_T1_cc(void)
228 {
229 CC_SRC = T0;
230 T0 -= T1;
231 CC_DST = T0;
232 }
233
234 void OPPROTO op_xorl_T0_T1_cc(void)
235 {
236 T0 ^= T1;
237 CC_DST = T0;
238 }
239
240 void OPPROTO op_cmpl_T0_T1_cc(void)
241 {
242 CC_SRC = T0;
243 CC_DST = T0 - T1;
244 }
245
246 void OPPROTO op_negl_T0_cc(void)
247 {
248 CC_SRC = 0;
249 T0 = -T0;
250 CC_DST = T0;
251 }
252
253 void OPPROTO op_incl_T0_cc(void)
254 {
255 CC_SRC = cc_table[CC_OP].compute_c();
256 T0++;
257 CC_DST = T0;
258 }
259
260 void OPPROTO op_decl_T0_cc(void)
261 {
262 CC_SRC = cc_table[CC_OP].compute_c();
263 T0--;
264 CC_DST = T0;
265 }
266
267 void OPPROTO op_testl_T0_T1_cc(void)
268 {
269 CC_DST = T0 & T1;
270 }
271
272 /* operations without flags */
273
274 void OPPROTO op_addl_T0_T1(void)
275 {
276 T0 += T1;
277 }
278
279 void OPPROTO op_orl_T0_T1(void)
280 {
281 T0 |= T1;
282 }
283
284 void OPPROTO op_andl_T0_T1(void)
285 {
286 T0 &= T1;
287 }
288
289 void OPPROTO op_subl_T0_T1(void)
290 {
291 T0 -= T1;
292 }
293
294 void OPPROTO op_xorl_T0_T1(void)
295 {
296 T0 ^= T1;
297 }
298
299 void OPPROTO op_negl_T0(void)
300 {
301 T0 = -T0;
302 }
303
304 void OPPROTO op_incl_T0(void)
305 {
306 T0++;
307 }
308
309 void OPPROTO op_decl_T0(void)
310 {
311 T0--;
312 }
313
314 void OPPROTO op_notl_T0(void)
315 {
316 T0 = ~T0;
317 }
318
319 void OPPROTO op_bswapl_T0(void)
320 {
321 T0 = bswap32(T0);
322 }
323
324 /* multiply/divide */
325 void OPPROTO op_mulb_AL_T0(void)
326 {
327 unsigned int res;
328 res = (uint8_t)EAX * (uint8_t)T0;
329 EAX = (EAX & 0xffff0000) | res;
330 CC_SRC = (res & 0xff00);
331 }
332
333 void OPPROTO op_imulb_AL_T0(void)
334 {
335 int res;
336 res = (int8_t)EAX * (int8_t)T0;
337 EAX = (EAX & 0xffff0000) | (res & 0xffff);
338 CC_SRC = (res != (int8_t)res);
339 }
340
341 void OPPROTO op_mulw_AX_T0(void)
342 {
343 unsigned int res;
344 res = (uint16_t)EAX * (uint16_t)T0;
345 EAX = (EAX & 0xffff0000) | (res & 0xffff);
346 EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
347 CC_SRC = res >> 16;
348 }
349
350 void OPPROTO op_imulw_AX_T0(void)
351 {
352 int res;
353 res = (int16_t)EAX * (int16_t)T0;
354 EAX = (EAX & 0xffff0000) | (res & 0xffff);
355 EDX = (EDX & 0xffff0000) | ((res >> 16) & 0xffff);
356 CC_SRC = (res != (int16_t)res);
357 }
358
359 void OPPROTO op_mull_EAX_T0(void)
360 {
361 uint64_t res;
362 res = (uint64_t)((uint32_t)EAX) * (uint64_t)((uint32_t)T0);
363 EAX = res;
364 EDX = res >> 32;
365 CC_SRC = res >> 32;
366 }
367
368 void OPPROTO op_imull_EAX_T0(void)
369 {
370 int64_t res;
371 res = (int64_t)((int32_t)EAX) * (int64_t)((int32_t)T0);
372 EAX = res;
373 EDX = res >> 32;
374 CC_SRC = (res != (int32_t)res);
375 }
376
377 void OPPROTO op_imulw_T0_T1(void)
378 {
379 int res;
380 res = (int16_t)T0 * (int16_t)T1;
381 T0 = res;
382 CC_SRC = (res != (int16_t)res);
383 }
384
385 void OPPROTO op_imull_T0_T1(void)
386 {
387 int64_t res;
388 res = (int64_t)((int32_t)T0) * (int64_t)((int32_t)T1);
389 T0 = res;
390 CC_SRC = (res != (int32_t)res);
391 }
392
393 /* division, flags are undefined */
394 /* XXX: add exceptions for overflow & div by zero */
395 void OPPROTO op_divb_AL_T0(void)
396 {
397 unsigned int num, den, q, r;
398
399 num = (EAX & 0xffff);
400 den = (T0 & 0xff);
401 q = (num / den) & 0xff;
402 r = (num % den) & 0xff;
403 EAX = (EAX & 0xffff0000) | (r << 8) | q;
404 }
405
406 void OPPROTO op_idivb_AL_T0(void)
407 {
408 int num, den, q, r;
409
410 num = (int16_t)EAX;
411 den = (int8_t)T0;
412 q = (num / den) & 0xff;
413 r = (num % den) & 0xff;
414 EAX = (EAX & 0xffff0000) | (r << 8) | q;
415 }
416
417 void OPPROTO op_divw_AX_T0(void)
418 {
419 unsigned int num, den, q, r;
420
421 num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
422 den = (T0 & 0xffff);
423 q = (num / den) & 0xffff;
424 r = (num % den) & 0xffff;
425 EAX = (EAX & 0xffff0000) | q;
426 EDX = (EDX & 0xffff0000) | r;
427 }
428
429 void OPPROTO op_idivw_AX_T0(void)
430 {
431 int num, den, q, r;
432
433 num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
434 den = (int16_t)T0;
435 q = (num / den) & 0xffff;
436 r = (num % den) & 0xffff;
437 EAX = (EAX & 0xffff0000) | q;
438 EDX = (EDX & 0xffff0000) | r;
439 }
440
441 void OPPROTO op_divl_EAX_T0(void)
442 {
443 unsigned int den, q, r;
444 uint64_t num;
445
446 num = EAX | ((uint64_t)EDX << 32);
447 den = T0;
448 q = (num / den);
449 r = (num % den);
450 EAX = q;
451 EDX = r;
452 }
453
454 void OPPROTO op_idivl_EAX_T0(void)
455 {
456 int den, q, r;
457 int64_t num;
458
459 num = EAX | ((uint64_t)EDX << 32);
460 den = T0;
461 q = (num / den);
462 r = (num % den);
463 EAX = q;
464 EDX = r;
465 }
466
467 /* constant load */
468
469 void OPPROTO op_movl_T0_im(void)
470 {
471 T0 = PARAM1;
472 }
473
474 void OPPROTO op_movl_T1_im(void)
475 {
476 T1 = PARAM1;
477 }
478
479 void OPPROTO op_movl_A0_im(void)
480 {
481 A0 = PARAM1;
482 }
483
484 void OPPROTO op_addl_A0_im(void)
485 {
486 A0 += PARAM1;
487 }
488
489 void OPPROTO op_andl_A0_ffff(void)
490 {
491 A0 = A0 & 0xffff;
492 }
493
494 /* memory access */
495
496 void OPPROTO op_ldub_T0_A0(void)
497 {
498 T0 = ldub((uint8_t *)A0);
499 }
500
501 void OPPROTO op_ldsb_T0_A0(void)
502 {
503 T0 = ldsb((int8_t *)A0);
504 }
505
506 void OPPROTO op_lduw_T0_A0(void)
507 {
508 T0 = lduw((uint8_t *)A0);
509 }
510
511 void OPPROTO op_ldsw_T0_A0(void)
512 {
513 T0 = ldsw((int8_t *)A0);
514 }
515
516 void OPPROTO op_ldl_T0_A0(void)
517 {
518 T0 = ldl((uint8_t *)A0);
519 }
520
521 void OPPROTO op_ldub_T1_A0(void)
522 {
523 T1 = ldub((uint8_t *)A0);
524 }
525
526 void OPPROTO op_ldsb_T1_A0(void)
527 {
528 T1 = ldsb((int8_t *)A0);
529 }
530
531 void OPPROTO op_lduw_T1_A0(void)
532 {
533 T1 = lduw((uint8_t *)A0);
534 }
535
536 void OPPROTO op_ldsw_T1_A0(void)
537 {
538 T1 = ldsw((int8_t *)A0);
539 }
540
541 void OPPROTO op_ldl_T1_A0(void)
542 {
543 T1 = ldl((uint8_t *)A0);
544 }
545
546 void OPPROTO op_stb_T0_A0(void)
547 {
548 stb((uint8_t *)A0, T0);
549 }
550
551 void OPPROTO op_stw_T0_A0(void)
552 {
553 stw((uint8_t *)A0, T0);
554 }
555
556 void OPPROTO op_stl_T0_A0(void)
557 {
558 stl((uint8_t *)A0, T0);
559 }
560
561 /* used for bit operations */
562
563 void OPPROTO op_add_bitw_A0_T1(void)
564 {
565 A0 += ((int32_t)T1 >> 4) << 1;
566 }
567
568 void OPPROTO op_add_bitl_A0_T1(void)
569 {
570 A0 += ((int32_t)T1 >> 5) << 2;
571 }
572
573 /* indirect jump */
574
575 void OPPROTO op_jmp_T0(void)
576 {
577 PC = T0;
578 }
579
580 void OPPROTO op_jmp_im(void)
581 {
582 PC = PARAM1;
583 }
584
585 void OPPROTO op_int_im(void)
586 {
587 PC = PARAM1;
588 raise_exception(EXCP0D_GPF);
589 }
590
591 void OPPROTO op_int3(void)
592 {
593 PC = PARAM1;
594 raise_exception(EXCP03_INT3);
595 }
596
597 void OPPROTO op_into(void)
598 {
599 int eflags;
600 eflags = cc_table[CC_OP].compute_all();
601 if (eflags & CC_O) {
602 PC = PARAM1;
603 raise_exception(EXCP04_INTO);
604 } else {
605 PC = PARAM2;
606 }
607 }
608
609 /* string ops */
610
611 #define ldul ldl
612
613 #define SHIFT 0
614 #include "ops_template.h"
615 #undef SHIFT
616
617 #define SHIFT 1
618 #include "ops_template.h"
619 #undef SHIFT
620
621 #define SHIFT 2
622 #include "ops_template.h"
623 #undef SHIFT
624
625 /* sign extend */
626
627 void OPPROTO op_movsbl_T0_T0(void)
628 {
629 T0 = (int8_t)T0;
630 }
631
632 void OPPROTO op_movzbl_T0_T0(void)
633 {
634 T0 = (uint8_t)T0;
635 }
636
637 void OPPROTO op_movswl_T0_T0(void)
638 {
639 T0 = (int16_t)T0;
640 }
641
642 void OPPROTO op_movzwl_T0_T0(void)
643 {
644 T0 = (uint16_t)T0;
645 }
646
647 void OPPROTO op_movswl_EAX_AX(void)
648 {
649 EAX = (int16_t)EAX;
650 }
651
652 void OPPROTO op_movsbw_AX_AL(void)
653 {
654 EAX = (EAX & 0xffff0000) | ((int8_t)EAX & 0xffff);
655 }
656
657 void OPPROTO op_movslq_EDX_EAX(void)
658 {
659 EDX = (int32_t)EAX >> 31;
660 }
661
662 void OPPROTO op_movswl_DX_AX(void)
663 {
664 EDX = (EDX & 0xffff0000) | (((int16_t)EAX >> 15) & 0xffff);
665 }
666
667 /* push/pop */
668 /* XXX: add 16 bit operand/16 bit seg variants */
669
670 void op_pushl_T0(void)
671 {
672 uint32_t offset;
673 offset = ESP - 4;
674 stl((void *)offset, T0);
675 /* modify ESP after to handle exceptions correctly */
676 ESP = offset;
677 }
678
679 void op_pushl_T1(void)
680 {
681 uint32_t offset;
682 offset = ESP - 4;
683 stl((void *)offset, T1);
684 /* modify ESP after to handle exceptions correctly */
685 ESP = offset;
686 }
687
688 void op_popl_T0(void)
689 {
690 T0 = ldl((void *)ESP);
691 ESP += 4;
692 }
693
694 void op_addl_ESP_im(void)
695 {
696 ESP += PARAM1;
697 }
698
699 void op_pushal(void)
700 {
701 uint8_t *sp;
702 sp = (void *)(ESP - 32);
703 stl(sp, EDI);
704 stl(sp + 4, ESI);
705 stl(sp + 8, EBP);
706 stl(sp + 12, ESP);
707 stl(sp + 16, EBX);
708 stl(sp + 20, EDX);
709 stl(sp + 24, ECX);
710 stl(sp + 28, EAX);
711 ESP = (unsigned long)sp;
712 }
713
714 void op_pushaw(void)
715 {
716 uint8_t *sp;
717 sp = (void *)(ESP - 16);
718 stw(sp, EDI);
719 stw(sp + 2, ESI);
720 stw(sp + 4, EBP);
721 stw(sp + 6, ESP);
722 stw(sp + 8, EBX);
723 stw(sp + 10, EDX);
724 stw(sp + 12, ECX);
725 stw(sp + 14, EAX);
726 ESP = (unsigned long)sp;
727 }
728
729 void op_popal(void)
730 {
731 uint8_t *sp;
732 sp = (void *)ESP;
733 EDI = ldl(sp);
734 ESI = ldl(sp + 4);
735 EBP = ldl(sp + 8);
736 EBX = ldl(sp + 16);
737 EDX = ldl(sp + 20);
738 ECX = ldl(sp + 24);
739 EAX = ldl(sp + 28);
740 ESP = (unsigned long)sp + 32;
741 }
742
743 void op_popaw(void)
744 {
745 uint8_t *sp;
746 sp = (void *)ESP;
747 EDI = ldl(sp);
748 ESI = ldl(sp + 2);
749 EBP = ldl(sp + 4);
750 EBX = ldl(sp + 8);
751 EDX = ldl(sp + 10);
752 ECX = ldl(sp + 12);
753 EAX = ldl(sp + 14);
754 ESP = (unsigned long)sp + 16;
755 }
756
757 void op_enterl(void)
758 {
759 unsigned int bp, frame_temp, level;
760 uint8_t *sp;
761
762 sp = (void *)ESP;
763 bp = EBP;
764 sp -= 4;
765 stl(sp, bp);
766 frame_temp = (unsigned int)sp;
767 level = PARAM2;
768 if (level) {
769 while (level--) {
770 bp -= 4;
771 sp -= 4;
772 stl(sp, bp);
773 }
774 sp -= 4;
775 stl(sp, frame_temp);
776 }
777 EBP = frame_temp;
778 sp -= PARAM1;
779 ESP = (int)sp;
780 }
781
782 /* rdtsc */
783 #ifndef __i386__
784 uint64_t emu_time;
785 #endif
786 void op_rdtsc(void)
787 {
788 uint64_t val;
789 #ifdef __i386__
790 asm("rdtsc" : "=A" (val));
791 #else
792 /* better than nothing: the time increases */
793 val = emu_time++;
794 #endif
795 EAX = val;
796 EDX = val >> 32;
797 }
798
799 /* bcd */
800
801 /* XXX: exception */
802 void OPPROTO op_aam(void)
803 {
804 int base = PARAM1;
805 int al, ah;
806 al = EAX & 0xff;
807 ah = al / base;
808 al = al % base;
809 EAX = (EAX & ~0xffff) | al | (ah << 8);
810 CC_DST = al;
811 }
812
813 void OPPROTO op_aad(void)
814 {
815 int base = PARAM1;
816 int al, ah;
817 al = EAX & 0xff;
818 ah = (EAX >> 8) & 0xff;
819 al = ((ah * base) + al) & 0xff;
820 EAX = (EAX & ~0xffff) | al;
821 CC_DST = al;
822 }
823
824 void OPPROTO op_aaa(void)
825 {
826 int icarry;
827 int al, ah, af;
828 int eflags;
829
830 eflags = cc_table[CC_OP].compute_all();
831 af = eflags & CC_A;
832 al = EAX & 0xff;
833 ah = (EAX >> 8) & 0xff;
834
835 icarry = (al > 0xf9);
836 if (((al & 0x0f) > 9 ) || af) {
837 al = (al + 6) & 0x0f;
838 ah = (ah + 1 + icarry) & 0xff;
839 eflags |= CC_C | CC_A;
840 } else {
841 eflags &= ~(CC_C | CC_A);
842 al &= 0x0f;
843 }
844 EAX = (EAX & ~0xffff) | al | (ah << 8);
845 CC_SRC = eflags;
846 }
847
848 void OPPROTO op_aas(void)
849 {
850 int icarry;
851 int al, ah, af;
852 int eflags;
853
854 eflags = cc_table[CC_OP].compute_all();
855 af = eflags & CC_A;
856 al = EAX & 0xff;
857 ah = (EAX >> 8) & 0xff;
858
859 icarry = (al < 6);
860 if (((al & 0x0f) > 9 ) || af) {
861 al = (al - 6) & 0x0f;
862 ah = (ah - 1 - icarry) & 0xff;
863 eflags |= CC_C | CC_A;
864 } else {
865 eflags &= ~(CC_C | CC_A);
866 al &= 0x0f;
867 }
868 EAX = (EAX & ~0xffff) | al | (ah << 8);
869 CC_SRC = eflags;
870 }
871
872 void OPPROTO op_daa(void)
873 {
874 int al, af, cf;
875 int eflags;
876
877 eflags = cc_table[CC_OP].compute_all();
878 cf = eflags & CC_C;
879 af = eflags & CC_A;
880 al = EAX & 0xff;
881
882 eflags = 0;
883 if (((al & 0x0f) > 9 ) || af) {
884 al = (al + 6) & 0xff;
885 eflags |= CC_A;
886 }
887 if ((al > 0x9f) || cf) {
888 al = (al + 0x60) & 0xff;
889 eflags |= CC_C;
890 }
891 EAX = (EAX & ~0xff) | al;
892 /* well, speed is not an issue here, so we compute the flags by hand */
893 eflags |= (al == 0) << 6; /* zf */
894 eflags |= parity_table[al]; /* pf */
895 eflags |= (al & 0x80); /* sf */
896 CC_SRC = eflags;
897 }
898
899 void OPPROTO op_das(void)
900 {
901 int al, al1, af, cf;
902 int eflags;
903
904 eflags = cc_table[CC_OP].compute_all();
905 cf = eflags & CC_C;
906 af = eflags & CC_A;
907 al = EAX & 0xff;
908
909 eflags = 0;
910 al1 = al;
911 if (((al & 0x0f) > 9 ) || af) {
912 eflags |= CC_A;
913 if (al < 6 || cf)
914 eflags |= CC_C;
915 al = (al - 6) & 0xff;
916 }
917 if ((al1 > 0x99) || cf) {
918 al = (al - 0x60) & 0xff;
919 eflags |= CC_C;
920 }
921 EAX = (EAX & ~0xff) | al;
922 /* well, speed is not an issue here, so we compute the flags by hand */
923 eflags |= (al == 0) << 6; /* zf */
924 eflags |= parity_table[al]; /* pf */
925 eflags |= (al & 0x80); /* sf */
926 CC_SRC = eflags;
927 }
928
929 /* segment handling */
930
931 void load_seg(int seg_reg, int selector)
932 {
933 SegmentCache *sc;
934 SegmentDescriptorTable *dt;
935 int index;
936 uint32_t e1, e2;
937 uint8_t *ptr;
938
939 env->segs[seg_reg] = selector;
940 sc = &env->seg_cache[seg_reg];
941 if (env->vm86) {
942 sc->base = (void *)(selector << 4);
943 sc->limit = 0xffff;
944 sc->seg_32bit = 0;
945 } else {
946 if (selector & 0x4)
947 dt = &env->ldt;
948 else
949 dt = &env->gdt;
950 index = selector & ~7;
951 if ((index + 7) > dt->limit)
952 raise_exception(EXCP0D_GPF);
953 ptr = dt->base + index;
954 e1 = ldl(ptr);
955 e2 = ldl(ptr + 4);
956 sc->base = (void *)((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
957 sc->limit = (e1 & 0xffff) | (e2 & 0x000f0000);
958 if (e2 & (1 << 23))
959 sc->limit = (sc->limit << 12) | 0xfff;
960 sc->seg_32bit = (e2 >> 22) & 1;
961 #if 0
962 fprintf(logfile, "load_seg: sel=0x%04x base=0x%08lx limit=0x%08lx seg_32bit=%d\n",
963 selector, (unsigned long)sc->base, sc->limit, sc->seg_32bit);
964 #endif
965 }
966 }
967
968 void OPPROTO op_movl_seg_T0(void)
969 {
970 load_seg(PARAM1, T0 & 0xffff);
971 }
972
973 void OPPROTO op_movl_T0_seg(void)
974 {
975 T0 = env->segs[PARAM1];
976 }
977
978 void OPPROTO op_addl_A0_seg(void)
979 {
980 A0 += *(unsigned long *)((char *)env + PARAM1);
981 }
982
983 /* flags handling */
984
985 /* slow jumps cases (compute x86 flags) */
986 void OPPROTO op_jo_cc(void)
987 {
988 int eflags;
989 eflags = cc_table[CC_OP].compute_all();
990 if (eflags & CC_O)
991 PC = PARAM1;
992 else
993 PC = PARAM2;
994 FORCE_RET();
995 }
996
997 void OPPROTO op_jb_cc(void)
998 {
999 if (cc_table[CC_OP].compute_c())
1000 PC = PARAM1;
1001 else
1002 PC = PARAM2;
1003 FORCE_RET();
1004 }
1005
1006 void OPPROTO op_jz_cc(void)
1007 {
1008 int eflags;
1009 eflags = cc_table[CC_OP].compute_all();
1010 if (eflags & CC_Z)
1011 PC = PARAM1;
1012 else
1013 PC = PARAM2;
1014 FORCE_RET();
1015 }
1016
1017 void OPPROTO op_jbe_cc(void)
1018 {
1019 int eflags;
1020 eflags = cc_table[CC_OP].compute_all();
1021 if (eflags & (CC_Z | CC_C))
1022 PC = PARAM1;
1023 else
1024 PC = PARAM2;
1025 FORCE_RET();
1026 }
1027
1028 void OPPROTO op_js_cc(void)
1029 {
1030 int eflags;
1031 eflags = cc_table[CC_OP].compute_all();
1032 if (eflags & CC_S)
1033 PC = PARAM1;
1034 else
1035 PC = PARAM2;
1036 FORCE_RET();
1037 }
1038
1039 void OPPROTO op_jp_cc(void)
1040 {
1041 int eflags;
1042 eflags = cc_table[CC_OP].compute_all();
1043 if (eflags & CC_P)
1044 PC = PARAM1;
1045 else
1046 PC = PARAM2;
1047 FORCE_RET();
1048 }
1049
1050 void OPPROTO op_jl_cc(void)
1051 {
1052 int eflags;
1053 eflags = cc_table[CC_OP].compute_all();
1054 if ((eflags ^ (eflags >> 4)) & 0x80)
1055 PC = PARAM1;
1056 else
1057 PC = PARAM2;
1058 FORCE_RET();
1059 }
1060
1061 void OPPROTO op_jle_cc(void)
1062 {
1063 int eflags;
1064 eflags = cc_table[CC_OP].compute_all();
1065 if (((eflags ^ (eflags >> 4)) & 0x80) || (eflags & CC_Z))
1066 PC = PARAM1;
1067 else
1068 PC = PARAM2;
1069 FORCE_RET();
1070 }
1071
1072 /* slow set cases (compute x86 flags) */
1073 void OPPROTO op_seto_T0_cc(void)
1074 {
1075 int eflags;
1076 eflags = cc_table[CC_OP].compute_all();
1077 T0 = (eflags >> 11) & 1;
1078 }
1079
1080 void OPPROTO op_setb_T0_cc(void)
1081 {
1082 T0 = cc_table[CC_OP].compute_c();
1083 }
1084
1085 void OPPROTO op_setz_T0_cc(void)
1086 {
1087 int eflags;
1088 eflags = cc_table[CC_OP].compute_all();
1089 T0 = (eflags >> 6) & 1;
1090 }
1091
1092 void OPPROTO op_setbe_T0_cc(void)
1093 {
1094 int eflags;
1095 eflags = cc_table[CC_OP].compute_all();
1096 T0 = (eflags & (CC_Z | CC_C)) != 0;
1097 }
1098
1099 void OPPROTO op_sets_T0_cc(void)
1100 {
1101 int eflags;
1102 eflags = cc_table[CC_OP].compute_all();
1103 T0 = (eflags >> 7) & 1;
1104 }
1105
1106 void OPPROTO op_setp_T0_cc(void)
1107 {
1108 int eflags;
1109 eflags = cc_table[CC_OP].compute_all();
1110 T0 = (eflags >> 2) & 1;
1111 }
1112
1113 void OPPROTO op_setl_T0_cc(void)
1114 {
1115 int eflags;
1116 eflags = cc_table[CC_OP].compute_all();
1117 T0 = ((eflags ^ (eflags >> 4)) >> 7) & 1;
1118 }
1119
1120 void OPPROTO op_setle_T0_cc(void)
1121 {
1122 int eflags;
1123 eflags = cc_table[CC_OP].compute_all();
1124 T0 = (((eflags ^ (eflags >> 4)) & 0x80) || (eflags & CC_Z)) != 0;
1125 }
1126
1127 void OPPROTO op_xor_T0_1(void)
1128 {
1129 T0 ^= 1;
1130 }
1131
1132 void OPPROTO op_set_cc_op(void)
1133 {
1134 CC_OP = PARAM1;
1135 }
1136
1137 void OPPROTO op_movl_eflags_T0(void)
1138 {
1139 CC_SRC = T0;
1140 DF = 1 - (2 * ((T0 >> 10) & 1));
1141 }
1142
1143 /* XXX: compute only O flag */
1144 void OPPROTO op_movb_eflags_T0(void)
1145 {
1146 int of;
1147 of = cc_table[CC_OP].compute_all() & CC_O;
1148 CC_SRC = T0 | of;
1149 }
1150
1151 void OPPROTO op_movl_T0_eflags(void)
1152 {
1153 T0 = cc_table[CC_OP].compute_all();
1154 T0 |= (DF & DIRECTION_FLAG);
1155 }
1156
1157 void OPPROTO op_cld(void)
1158 {
1159 DF = 1;
1160 }
1161
1162 void OPPROTO op_std(void)
1163 {
1164 DF = -1;
1165 }
1166
1167 void OPPROTO op_clc(void)
1168 {
1169 int eflags;
1170 eflags = cc_table[CC_OP].compute_all();
1171 eflags &= ~CC_C;
1172 CC_SRC = eflags;
1173 }
1174
1175 void OPPROTO op_stc(void)
1176 {
1177 int eflags;
1178 eflags = cc_table[CC_OP].compute_all();
1179 eflags |= CC_C;
1180 CC_SRC = eflags;
1181 }
1182
1183 void OPPROTO op_cmc(void)
1184 {
1185 int eflags;
1186 eflags = cc_table[CC_OP].compute_all();
1187 eflags ^= CC_C;
1188 CC_SRC = eflags;
1189 }
1190
1191 void OPPROTO op_salc(void)
1192 {
1193 int cf;
1194 cf = cc_table[CC_OP].compute_c();
1195 EAX = (EAX & ~0xff) | ((-cf) & 0xff);
1196 }
1197
1198 static int compute_all_eflags(void)
1199 {
1200 return CC_SRC;
1201 }
1202
1203 static int compute_c_eflags(void)
1204 {
1205 return CC_SRC & CC_C;
1206 }
1207
1208 static int compute_c_mul(void)
1209 {
1210 int cf;
1211 cf = (CC_SRC != 0);
1212 return cf;
1213 }
1214
1215 static int compute_all_mul(void)
1216 {
1217 int cf, pf, af, zf, sf, of;
1218 cf = (CC_SRC != 0);
1219 pf = 0; /* undefined */
1220 af = 0; /* undefined */
1221 zf = 0; /* undefined */
1222 sf = 0; /* undefined */
1223 of = cf << 11;
1224 return cf | pf | af | zf | sf | of;
1225 }
1226
1227 CCTable cc_table[CC_OP_NB] = {
1228 [CC_OP_DYNAMIC] = { /* should never happen */ },
1229
1230 [CC_OP_EFLAGS] = { compute_all_eflags, compute_c_eflags },
1231
1232 [CC_OP_MUL] = { compute_all_mul, compute_c_mul },
1233
1234 [CC_OP_ADDB] = { compute_all_addb, compute_c_addb },
1235 [CC_OP_ADDW] = { compute_all_addw, compute_c_addw },
1236 [CC_OP_ADDL] = { compute_all_addl, compute_c_addl },
1237
1238 [CC_OP_ADCB] = { compute_all_adcb, compute_c_adcb },
1239 [CC_OP_ADCW] = { compute_all_adcw, compute_c_adcw },
1240 [CC_OP_ADCL] = { compute_all_adcl, compute_c_adcl },
1241
1242 [CC_OP_SUBB] = { compute_all_subb, compute_c_subb },
1243 [CC_OP_SUBW] = { compute_all_subw, compute_c_subw },
1244 [CC_OP_SUBL] = { compute_all_subl, compute_c_subl },
1245
1246 [CC_OP_SBBB] = { compute_all_sbbb, compute_c_sbbb },
1247 [CC_OP_SBBW] = { compute_all_sbbw, compute_c_sbbw },
1248 [CC_OP_SBBL] = { compute_all_sbbl, compute_c_sbbl },
1249
1250 [CC_OP_LOGICB] = { compute_all_logicb, compute_c_logicb },
1251 [CC_OP_LOGICW] = { compute_all_logicw, compute_c_logicw },
1252 [CC_OP_LOGICL] = { compute_all_logicl, compute_c_logicl },
1253
1254 [CC_OP_INCB] = { compute_all_incb, compute_c_incl },
1255 [CC_OP_INCW] = { compute_all_incw, compute_c_incl },
1256 [CC_OP_INCL] = { compute_all_incl, compute_c_incl },
1257
1258 [CC_OP_DECB] = { compute_all_decb, compute_c_incl },
1259 [CC_OP_DECW] = { compute_all_decw, compute_c_incl },
1260 [CC_OP_DECL] = { compute_all_decl, compute_c_incl },
1261
1262 [CC_OP_SHLB] = { compute_all_shlb, compute_c_shll },
1263 [CC_OP_SHLW] = { compute_all_shlw, compute_c_shll },
1264 [CC_OP_SHLL] = { compute_all_shll, compute_c_shll },
1265
1266 [CC_OP_SARB] = { compute_all_sarb, compute_c_shll },
1267 [CC_OP_SARW] = { compute_all_sarw, compute_c_shll },
1268 [CC_OP_SARL] = { compute_all_sarl, compute_c_shll },
1269 };
1270
1271 /* floating point support */
1272
1273 #ifdef USE_X86LDOUBLE
1274 /* use long double functions */
1275 #define lrint lrintl
1276 #define llrint llrintl
1277 #define fabs fabsl
1278 #define sin sinl
1279 #define cos cosl
1280 #define sqrt sqrtl
1281 #define pow powl
1282 #define log logl
1283 #define tan tanl
1284 #define atan2 atan2l
1285 #define floor floorl
1286 #define ceil ceill
1287 #define rint rintl
1288 #endif
1289
1290 extern int lrint(CPU86_LDouble x);
1291 extern int64_t llrint(CPU86_LDouble x);
1292 extern CPU86_LDouble fabs(CPU86_LDouble x);
1293 extern CPU86_LDouble sin(CPU86_LDouble x);
1294 extern CPU86_LDouble cos(CPU86_LDouble x);
1295 extern CPU86_LDouble sqrt(CPU86_LDouble x);
1296 extern CPU86_LDouble pow(CPU86_LDouble, CPU86_LDouble);
1297 extern CPU86_LDouble log(CPU86_LDouble x);
1298 extern CPU86_LDouble tan(CPU86_LDouble x);
1299 extern CPU86_LDouble atan2(CPU86_LDouble, CPU86_LDouble);
1300 extern CPU86_LDouble floor(CPU86_LDouble x);
1301 extern CPU86_LDouble ceil(CPU86_LDouble x);
1302 extern CPU86_LDouble rint(CPU86_LDouble x);
1303
1304 #define RC_MASK 0xc00
1305 #define RC_NEAR 0x000
1306 #define RC_DOWN 0x400
1307 #define RC_UP 0x800
1308 #define RC_CHOP 0xc00
1309
1310 #define MAXTAN 9223372036854775808.0
1311
1312 #ifdef USE_X86LDOUBLE
1313
1314 /* only for x86 */
1315 typedef union {
1316 long double d;
1317 struct {
1318 unsigned long long lower;
1319 unsigned short upper;
1320 } l;
1321 } CPU86_LDoubleU;
1322
1323 /* the following deal with x86 long double-precision numbers */
1324 #define MAXEXPD 0x7fff
1325 #define EXPBIAS 16383
1326 #define EXPD(fp) (fp.l.upper & 0x7fff)
1327 #define SIGND(fp) ((fp.l.upper) & 0x8000)
1328 #define MANTD(fp) (fp.l.lower)
1329 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) | EXPBIAS
1330
1331 #else
1332
1333 typedef union {
1334 double d;
1335 #ifndef WORDS_BIGENDIAN
1336 struct {
1337 unsigned long lower;
1338 long upper;
1339 } l;
1340 #else
1341 struct {
1342 long upper;
1343 unsigned long lower;
1344 } l;
1345 #endif
1346 long long ll;
1347 } CPU86_LDoubleU;
1348
1349 /* the following deal with IEEE double-precision numbers */
1350 #define MAXEXPD 0x7ff
1351 #define EXPBIAS 1023
1352 #define EXPD(fp) (((fp.l.upper) >> 20) & 0x7FF)
1353 #define SIGND(fp) ((fp.l.upper) & 0x80000000)
1354 #define MANTD(fp) (fp.ll & ((1LL << 52) - 1))
1355 #define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7ff << 20)) | (EXPBIAS << 20)
1356 #endif
1357
1358 /* fp load FT0 */
1359
1360 void OPPROTO op_flds_FT0_A0(void)
1361 {
1362 FT0 = ldfl((void *)A0);
1363 }
1364
1365 void OPPROTO op_fldl_FT0_A0(void)
1366 {
1367 FT0 = ldfq((void *)A0);
1368 }
1369
1370 /* helpers are needed to avoid static constant reference. XXX: find a better way */
1371 #ifdef USE_INT_TO_FLOAT_HELPERS
1372
1373 void helper_fild_FT0_A0(void)
1374 {
1375 FT0 = (CPU86_LDouble)ldsw((void *)A0);
1376 }
1377
1378 void helper_fildl_FT0_A0(void)
1379 {
1380 FT0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1381 }
1382
1383 void helper_fildll_FT0_A0(void)
1384 {
1385 FT0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1386 }
1387
1388 void OPPROTO op_fild_FT0_A0(void)
1389 {
1390 helper_fild_FT0_A0();
1391 }
1392
1393 void OPPROTO op_fildl_FT0_A0(void)
1394 {
1395 helper_fildl_FT0_A0();
1396 }
1397
1398 void OPPROTO op_fildll_FT0_A0(void)
1399 {
1400 helper_fildll_FT0_A0();
1401 }
1402
1403 #else
1404
1405 void OPPROTO op_fild_FT0_A0(void)
1406 {
1407 FT0 = (CPU86_LDouble)ldsw((void *)A0);
1408 }
1409
1410 void OPPROTO op_fildl_FT0_A0(void)
1411 {
1412 FT0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1413 }
1414
1415 void OPPROTO op_fildll_FT0_A0(void)
1416 {
1417 FT0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1418 }
1419 #endif
1420
1421 /* fp load ST0 */
1422
1423 void OPPROTO op_flds_ST0_A0(void)
1424 {
1425 ST0 = ldfl((void *)A0);
1426 }
1427
1428 void OPPROTO op_fldl_ST0_A0(void)
1429 {
1430 ST0 = ldfq((void *)A0);
1431 }
1432
1433 #ifdef USE_X86LDOUBLE
1434 void OPPROTO op_fldt_ST0_A0(void)
1435 {
1436 ST0 = *(long double *)A0;
1437 }
1438 #else
1439 void helper_fldt_ST0_A0(void)
1440 {
1441 CPU86_LDoubleU temp;
1442 int upper, e;
1443 /* mantissa */
1444 upper = lduw((uint8_t *)A0 + 8);
1445 /* XXX: handle overflow ? */
1446 e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
1447 e |= (upper >> 4) & 0x800; /* sign */
1448 temp.ll = ((ldq((void *)A0) >> 11) & ((1LL << 52) - 1)) | ((uint64_t)e << 52);
1449 ST0 = temp.d;
1450 }
1451
1452 void OPPROTO op_fldt_ST0_A0(void)
1453 {
1454 helper_fldt_ST0_A0();
1455 }
1456 #endif
1457
1458 /* helpers are needed to avoid static constant reference. XXX: find a better way */
1459 #ifdef USE_INT_TO_FLOAT_HELPERS
1460
1461 void helper_fild_ST0_A0(void)
1462 {
1463 ST0 = (CPU86_LDouble)ldsw((void *)A0);
1464 }
1465
1466 void helper_fildl_ST0_A0(void)
1467 {
1468 ST0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1469 }
1470
1471 void helper_fildll_ST0_A0(void)
1472 {
1473 ST0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1474 }
1475
1476 void OPPROTO op_fild_ST0_A0(void)
1477 {
1478 helper_fild_ST0_A0();
1479 }
1480
1481 void OPPROTO op_fildl_ST0_A0(void)
1482 {
1483 helper_fildl_ST0_A0();
1484 }
1485
1486 void OPPROTO op_fildll_ST0_A0(void)
1487 {
1488 helper_fildll_ST0_A0();
1489 }
1490
1491 #else
1492
1493 void OPPROTO op_fild_ST0_A0(void)
1494 {
1495 ST0 = (CPU86_LDouble)ldsw((void *)A0);
1496 }
1497
1498 void OPPROTO op_fildl_ST0_A0(void)
1499 {
1500 ST0 = (CPU86_LDouble)((int32_t)ldl((void *)A0));
1501 }
1502
1503 void OPPROTO op_fildll_ST0_A0(void)
1504 {
1505 ST0 = (CPU86_LDouble)((int64_t)ldq((void *)A0));
1506 }
1507
1508 #endif
1509
1510 /* fp store */
1511
1512 void OPPROTO op_fsts_ST0_A0(void)
1513 {
1514 stfl((void *)A0, (float)ST0);
1515 }
1516
1517 void OPPROTO op_fstl_ST0_A0(void)
1518 {
1519 stfq((void *)A0, (double)ST0);
1520 }
1521
1522 #ifdef USE_X86LDOUBLE
1523 void OPPROTO op_fstt_ST0_A0(void)
1524 {
1525 *(long double *)A0 = ST0;
1526 }
1527 #else
1528 void helper_fstt_ST0_A0(void)
1529 {
1530 CPU86_LDoubleU temp;
1531 int e;
1532 temp.d = ST0;
1533 /* mantissa */
1534 stq((void *)A0, (MANTD(temp) << 11) | (1LL << 63));
1535 /* exponent + sign */
1536 e = EXPD(temp) - EXPBIAS + 16383;
1537 e |= SIGND(temp) >> 16;
1538 stw((uint8_t *)A0 + 8, e);
1539 }
1540
1541 void OPPROTO op_fstt_ST0_A0(void)
1542 {
1543 helper_fstt_ST0_A0();
1544 }
1545 #endif
1546
1547 void OPPROTO op_fist_ST0_A0(void)
1548 {
1549 int val;
1550 val = lrint(ST0);
1551 stw((void *)A0, val);
1552 }
1553
1554 void OPPROTO op_fistl_ST0_A0(void)
1555 {
1556 int val;
1557 val = lrint(ST0);
1558 stl((void *)A0, val);
1559 }
1560
1561 void OPPROTO op_fistll_ST0_A0(void)
1562 {
1563 int64_t val;
1564 val = llrint(ST0);
1565 stq((void *)A0, val);
1566 }
1567
1568 /* BCD ops */
1569
1570 #define MUL10(iv) ( iv + iv + (iv << 3) )
1571
1572 void helper_fbld_ST0_A0(void)
1573 {
1574 uint8_t *seg;
1575 CPU86_LDouble fpsrcop;
1576 int m32i;
1577 unsigned int v;
1578
1579 /* in this code, seg/m32i will be used as temporary ptr/int */
1580 seg = (uint8_t *)A0 + 8;
1581 v = ldub(seg--);
1582 /* XXX: raise exception */
1583 if (v != 0)
1584 return;
1585 v = ldub(seg--);
1586 /* XXX: raise exception */
1587 if ((v & 0xf0) != 0)
1588 return;
1589 m32i = v; /* <-- d14 */
1590 v = ldub(seg--);
1591 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d13 */
1592 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d12 */
1593 v = ldub(seg--);
1594 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d11 */
1595 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d10 */
1596 v = ldub(seg--);
1597 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d9 */
1598 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d8 */
1599 fpsrcop = ((CPU86_LDouble)m32i) * 100000000.0;
1600
1601 v = ldub(seg--);
1602 m32i = (v >> 4); /* <-- d7 */
1603 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d6 */
1604 v = ldub(seg--);
1605 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d5 */
1606 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d4 */
1607 v = ldub(seg--);
1608 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d3 */
1609 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d2 */
1610 v = ldub(seg);
1611 m32i = MUL10(m32i) + (v >> 4); /* <-- val * 10 + d1 */
1612 m32i = MUL10(m32i) + (v & 0xf); /* <-- val * 10 + d0 */
1613 fpsrcop += ((CPU86_LDouble)m32i);
1614 if ( ldub(seg+9) & 0x80 )
1615 fpsrcop = -fpsrcop;
1616 ST0 = fpsrcop;
1617 }
1618
1619 void OPPROTO op_fbld_ST0_A0(void)
1620 {
1621 helper_fbld_ST0_A0();
1622 }
1623
1624 void helper_fbst_ST0_A0(void)
1625 {
1626 CPU86_LDouble fptemp;
1627 CPU86_LDouble fpsrcop;
1628 int v;
1629 uint8_t *mem_ref, *mem_end;
1630
1631 fpsrcop = rint(ST0);
1632 mem_ref = (uint8_t *)A0;
1633 mem_end = mem_ref + 8;
1634 if ( fpsrcop < 0.0 ) {
1635 stw(mem_end, 0x8000);
1636 fpsrcop = -fpsrcop;
1637 } else {
1638 stw(mem_end, 0x0000);
1639 }
1640 while (mem_ref < mem_end) {
1641 if (fpsrcop == 0.0)
1642 break;
1643 fptemp = floor(fpsrcop/10.0);
1644 v = ((int)(fpsrcop - fptemp*10.0));
1645 if (fptemp == 0.0) {
1646 stb(mem_ref++, v);
1647 break;
1648 }
1649 fpsrcop = fptemp;
1650 fptemp = floor(fpsrcop/10.0);
1651 v |= (((int)(fpsrcop - fptemp*10.0)) << 4);
1652 stb(mem_ref++, v);
1653 fpsrcop = fptemp;
1654 }
1655 while (mem_ref < mem_end) {
1656 stb(mem_ref++, 0);
1657 }
1658 }
1659
1660 void OPPROTO op_fbst_ST0_A0(void)
1661 {
1662 helper_fbst_ST0_A0();
1663 }
1664
1665 /* FPU move */
1666
1667 static inline void fpush(void)
1668 {
1669 env->fpstt = (env->fpstt - 1) & 7;
1670 env->fptags[env->fpstt] = 0; /* validate stack entry */
1671 }
1672
1673 static inline void fpop(void)
1674 {
1675 env->fptags[env->fpstt] = 1; /* invvalidate stack entry */
1676 env->fpstt = (env->fpstt + 1) & 7;
1677 }
1678
1679 void OPPROTO op_fpush(void)
1680 {
1681 fpush();
1682 }
1683
1684 void OPPROTO op_fpop(void)
1685 {
1686 fpop();
1687 }
1688
1689 void OPPROTO op_fdecstp(void)
1690 {
1691 env->fpstt = (env->fpstt - 1) & 7;
1692 env->fpus &= (~0x4700);
1693 }
1694
1695 void OPPROTO op_fincstp(void)
1696 {
1697 env->fpstt = (env->fpstt + 1) & 7;
1698 env->fpus &= (~0x4700);
1699 }
1700
1701 void OPPROTO op_fmov_ST0_FT0(void)
1702 {
1703 ST0 = FT0;
1704 }
1705
1706 void OPPROTO op_fmov_FT0_STN(void)
1707 {
1708 FT0 = ST(PARAM1);
1709 }
1710
1711 void OPPROTO op_fmov_ST0_STN(void)
1712 {
1713 ST0 = ST(PARAM1);
1714 }
1715
1716 void OPPROTO op_fmov_STN_ST0(void)
1717 {
1718 ST(PARAM1) = ST0;
1719 }
1720
1721 void OPPROTO op_fxchg_ST0_STN(void)
1722 {
1723 CPU86_LDouble tmp;
1724 tmp = ST(PARAM1);
1725 ST(PARAM1) = ST0;
1726 ST0 = tmp;
1727 }
1728
1729 /* FPU operations */
1730
1731 /* XXX: handle nans */
1732 void OPPROTO op_fcom_ST0_FT0(void)
1733 {
1734 env->fpus &= (~0x4500); /* (C3,C2,C0) <-- 000 */
1735 if (ST0 < FT0)
1736 env->fpus |= 0x100; /* (C3,C2,C0) <-- 001 */
1737 else if (ST0 == FT0)
1738 env->fpus |= 0x4000; /* (C3,C2,C0) <-- 100 */
1739 FORCE_RET();
1740 }
1741
1742 /* XXX: handle nans */
1743 void OPPROTO op_fucom_ST0_FT0(void)
1744 {
1745 env->fpus &= (~0x4500); /* (C3,C2,C0) <-- 000 */
1746 if (ST0 < FT0)
1747 env->fpus |= 0x100; /* (C3,C2,C0) <-- 001 */
1748 else if (ST0 == FT0)
1749 env->fpus |= 0x4000; /* (C3,C2,C0) <-- 100 */
1750 FORCE_RET();
1751 }
1752
1753 void OPPROTO op_fadd_ST0_FT0(void)
1754 {
1755 ST0 += FT0;
1756 }
1757
1758 void OPPROTO op_fmul_ST0_FT0(void)
1759 {
1760 ST0 *= FT0;
1761 }
1762
1763 void OPPROTO op_fsub_ST0_FT0(void)
1764 {
1765 ST0 -= FT0;
1766 }
1767
1768 void OPPROTO op_fsubr_ST0_FT0(void)
1769 {
1770 ST0 = FT0 - ST0;
1771 }
1772
1773 void OPPROTO op_fdiv_ST0_FT0(void)
1774 {
1775 ST0 /= FT0;
1776 }
1777
1778 void OPPROTO op_fdivr_ST0_FT0(void)
1779 {
1780 ST0 = FT0 / ST0;
1781 }
1782
1783 /* fp operations between STN and ST0 */
1784
1785 void OPPROTO op_fadd_STN_ST0(void)
1786 {
1787 ST(PARAM1) += ST0;
1788 }
1789
1790 void OPPROTO op_fmul_STN_ST0(void)
1791 {
1792 ST(PARAM1) *= ST0;
1793 }
1794
1795 void OPPROTO op_fsub_STN_ST0(void)
1796 {
1797 ST(PARAM1) -= ST0;
1798 }
1799
1800 void OPPROTO op_fsubr_STN_ST0(void)
1801 {
1802 CPU86_LDouble *p;
1803 p = &ST(PARAM1);
1804 *p = ST0 - *p;
1805 }
1806
1807 void OPPROTO op_fdiv_STN_ST0(void)
1808 {
1809 ST(PARAM1) /= ST0;
1810 }
1811
1812 void OPPROTO op_fdivr_STN_ST0(void)
1813 {
1814 CPU86_LDouble *p;
1815 p = &ST(PARAM1);
1816 *p = ST0 / *p;
1817 }
1818
1819 /* misc FPU operations */
1820 void OPPROTO op_fchs_ST0(void)
1821 {
1822 ST0 = -ST0;
1823 }
1824
1825 void OPPROTO op_fabs_ST0(void)
1826 {
1827 ST0 = fabs(ST0);
1828 }
1829
1830 void helper_fxam_ST0(void)
1831 {
1832 CPU86_LDoubleU temp;
1833 int expdif;
1834
1835 temp.d = ST0;
1836
1837 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
1838 if (SIGND(temp))
1839 env->fpus |= 0x200; /* C1 <-- 1 */
1840
1841 expdif = EXPD(temp);
1842 if (expdif == MAXEXPD) {
1843 if (MANTD(temp) == 0)
1844 env->fpus |= 0x500 /*Infinity*/;
1845 else
1846 env->fpus |= 0x100 /*NaN*/;
1847 } else if (expdif == 0) {
1848 if (MANTD(temp) == 0)
1849 env->fpus |= 0x4000 /*Zero*/;
1850 else
1851 env->fpus |= 0x4400 /*Denormal*/;
1852 } else {
1853 env->fpus |= 0x400;
1854 }
1855 }
1856
1857 void OPPROTO op_fxam_ST0(void)
1858 {
1859 helper_fxam_ST0();
1860 }
1861
1862 void OPPROTO op_fld1_ST0(void)
1863 {
1864 ST0 = *(CPU86_LDouble *)&f15rk[1];
1865 }
1866
1867 void OPPROTO op_fldl2t_ST0(void)
1868 {
1869 ST0 = *(CPU86_LDouble *)&f15rk[6];
1870 }
1871
1872 void OPPROTO op_fldl2e_ST0(void)
1873 {
1874 ST0 = *(CPU86_LDouble *)&f15rk[5];
1875 }
1876
1877 void OPPROTO op_fldpi_ST0(void)
1878 {
1879 ST0 = *(CPU86_LDouble *)&f15rk[2];
1880 }
1881
1882 void OPPROTO op_fldlg2_ST0(void)
1883 {
1884 ST0 = *(CPU86_LDouble *)&f15rk[3];
1885 }
1886
1887 void OPPROTO op_fldln2_ST0(void)
1888 {
1889 ST0 = *(CPU86_LDouble *)&f15rk[4];
1890 }
1891
1892 void OPPROTO op_fldz_ST0(void)
1893 {
1894 ST0 = *(CPU86_LDouble *)&f15rk[0];
1895 }
1896
1897 void OPPROTO op_fldz_FT0(void)
1898 {
1899 ST0 = *(CPU86_LDouble *)&f15rk[0];
1900 }
1901
1902 void helper_f2xm1(void)
1903 {
1904 ST0 = pow(2.0,ST0) - 1.0;
1905 }
1906
1907 void helper_fyl2x(void)
1908 {
1909 CPU86_LDouble fptemp;
1910
1911 fptemp = ST0;
1912 if (fptemp>0.0){
1913 fptemp = log(fptemp)/log(2.0); /* log2(ST) */
1914 ST1 *= fptemp;
1915 fpop();
1916 } else {
1917 env->fpus &= (~0x4700);
1918 env->fpus |= 0x400;
1919 }
1920 }
1921
1922 void helper_fptan(void)
1923 {
1924 CPU86_LDouble fptemp;
1925
1926 fptemp = ST0;
1927 if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
1928 env->fpus |= 0x400;
1929 } else {
1930 ST0 = tan(fptemp);
1931 fpush();
1932 ST0 = 1.0;
1933 env->fpus &= (~0x400); /* C2 <-- 0 */
1934 /* the above code is for |arg| < 2**52 only */
1935 }
1936 }
1937
1938 void helper_fpatan(void)
1939 {
1940 CPU86_LDouble fptemp, fpsrcop;
1941
1942 fpsrcop = ST1;
1943 fptemp = ST0;
1944 ST1 = atan2(fpsrcop,fptemp);
1945 fpop();
1946 }
1947
1948 void helper_fxtract(void)
1949 {
1950 CPU86_LDoubleU temp;
1951 unsigned int expdif;
1952
1953 temp.d = ST0;
1954 expdif = EXPD(temp) - EXPBIAS;
1955 /*DP exponent bias*/
1956 ST0 = expdif;
1957 fpush();
1958 BIASEXPONENT(temp);
1959 ST0 = temp.d;
1960 }
1961
1962 void helper_fprem1(void)
1963 {
1964 CPU86_LDouble dblq, fpsrcop, fptemp;
1965 CPU86_LDoubleU fpsrcop1, fptemp1;
1966 int expdif;
1967 int q;
1968
1969 fpsrcop = ST0;
1970 fptemp = ST1;
1971 fpsrcop1.d = fpsrcop;
1972 fptemp1.d = fptemp;
1973 expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
1974 if (expdif < 53) {
1975 dblq = fpsrcop / fptemp;
1976 dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
1977 ST0 = fpsrcop - fptemp*dblq;
1978 q = (int)dblq; /* cutting off top bits is assumed here */
1979 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
1980 /* (C0,C1,C3) <-- (q2,q1,q0) */
1981 env->fpus |= (q&0x4) << 6; /* (C0) <-- q2 */
1982 env->fpus |= (q&0x2) << 8; /* (C1) <-- q1 */
1983 env->fpus |= (q&0x1) << 14; /* (C3) <-- q0 */
1984 } else {
1985 env->fpus |= 0x400; /* C2 <-- 1 */
1986 fptemp = pow(2.0, expdif-50);
1987 fpsrcop = (ST0 / ST1) / fptemp;
1988 /* fpsrcop = integer obtained by rounding to the nearest */
1989 fpsrcop = (fpsrcop-floor(fpsrcop) < ceil(fpsrcop)-fpsrcop)?
1990 floor(fpsrcop): ceil(fpsrcop);
1991 ST0 -= (ST1 * fpsrcop * fptemp);
1992 }
1993 }
1994
1995 void helper_fprem(void)
1996 {
1997 CPU86_LDouble dblq, fpsrcop, fptemp;
1998 CPU86_LDoubleU fpsrcop1, fptemp1;
1999 int expdif;
2000 int q;
2001
2002 fpsrcop = ST0;
2003 fptemp = ST1;
2004 fpsrcop1.d = fpsrcop;
2005 fptemp1.d = fptemp;
2006 expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
2007 if ( expdif < 53 ) {
2008 dblq = fpsrcop / fptemp;
2009 dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
2010 ST0 = fpsrcop - fptemp*dblq;
2011 q = (int)dblq; /* cutting off top bits is assumed here */
2012 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
2013 /* (C0,C1,C3) <-- (q2,q1,q0) */
2014 env->fpus |= (q&0x4) << 6; /* (C0) <-- q2 */
2015 env->fpus |= (q&0x2) << 8; /* (C1) <-- q1 */
2016 env->fpus |= (q&0x1) << 14; /* (C3) <-- q0 */
2017 } else {
2018 env->fpus |= 0x400; /* C2 <-- 1 */
2019 fptemp = pow(2.0, expdif-50);
2020 fpsrcop = (ST0 / ST1) / fptemp;
2021 /* fpsrcop = integer obtained by chopping */
2022 fpsrcop = (fpsrcop < 0.0)?
2023 -(floor(fabs(fpsrcop))): floor(fpsrcop);
2024 ST0 -= (ST1 * fpsrcop * fptemp);
2025 }
2026 }
2027
2028 void helper_fyl2xp1(void)
2029 {
2030 CPU86_LDouble fptemp;
2031
2032 fptemp = ST0;
2033 if ((fptemp+1.0)>0.0) {
2034 fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
2035 ST1 *= fptemp;
2036 fpop();
2037 } else {
2038 env->fpus &= (~0x4700);
2039 env->fpus |= 0x400;
2040 }
2041 }
2042
2043 void helper_fsqrt(void)
2044 {
2045 CPU86_LDouble fptemp;
2046
2047 fptemp = ST0;
2048 if (fptemp<0.0) {
2049 env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
2050 env->fpus |= 0x400;
2051 }
2052 ST0 = sqrt(fptemp);
2053 }
2054
2055 void helper_fsincos(void)
2056 {
2057 CPU86_LDouble fptemp;
2058
2059 fptemp = ST0;
2060 if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
2061 env->fpus |= 0x400;
2062 } else {
2063 ST0 = sin(fptemp);
2064 fpush();
2065 ST0 = cos(fptemp);
2066 env->fpus &= (~0x400); /* C2 <-- 0 */
2067 /* the above code is for |arg| < 2**63 only */
2068 }
2069 }
2070
2071 void helper_frndint(void)
2072 {
2073 ST0 = rint(ST0);
2074 }
2075
2076 void helper_fscale(void)
2077 {
2078 CPU86_LDouble fpsrcop, fptemp;
2079
2080 fpsrcop = 2.0;
2081 fptemp = pow(fpsrcop,ST1);
2082 ST0 *= fptemp;
2083 }
2084
2085 void helper_fsin(void)
2086 {
2087 CPU86_LDouble fptemp;
2088
2089 fptemp = ST0;
2090 if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
2091 env->fpus |= 0x400;
2092 } else {
2093 ST0 = sin(fptemp);
2094 env->fpus &= (~0x400); /* C2 <-- 0 */
2095 /* the above code is for |arg| < 2**53 only */
2096 }
2097 }
2098
2099 void helper_fcos(void)
2100 {
2101 CPU86_LDouble fptemp;
2102
2103 fptemp = ST0;
2104 if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
2105 env->fpus |= 0x400;
2106 } else {
2107 ST0 = cos(fptemp);
2108 env->fpus &= (~0x400); /* C2 <-- 0 */
2109 /* the above code is for |arg5 < 2**63 only */
2110 }
2111 }
2112
2113 /* associated heplers to reduce generated code length and to simplify
2114 relocation (FP constants are usually stored in .rodata section) */
2115
2116 void OPPROTO op_f2xm1(void)
2117 {
2118 helper_f2xm1();
2119 }
2120
2121 void OPPROTO op_fyl2x(void)
2122 {
2123 helper_fyl2x();
2124 }
2125
2126 void OPPROTO op_fptan(void)
2127 {
2128 helper_fptan();
2129 }
2130
2131 void OPPROTO op_fpatan(void)
2132 {
2133 helper_fpatan();
2134 }
2135
2136 void OPPROTO op_fxtract(void)
2137 {
2138 helper_fxtract();
2139 }
2140
2141 void OPPROTO op_fprem1(void)
2142 {
2143 helper_fprem1();
2144 }
2145
2146
2147 void OPPROTO op_fprem(void)
2148 {
2149 helper_fprem();
2150 }
2151
2152 void OPPROTO op_fyl2xp1(void)
2153 {
2154 helper_fyl2xp1();
2155 }
2156
2157 void OPPROTO op_fsqrt(void)
2158 {
2159 helper_fsqrt();
2160 }
2161
2162 void OPPROTO op_fsincos(void)
2163 {
2164 helper_fsincos();
2165 }
2166
2167 void OPPROTO op_frndint(void)
2168 {
2169 helper_frndint();
2170 }
2171
2172 void OPPROTO op_fscale(void)
2173 {
2174 helper_fscale();
2175 }
2176
2177 void OPPROTO op_fsin(void)
2178 {
2179 helper_fsin();
2180 }
2181
2182 void OPPROTO op_fcos(void)
2183 {
2184 helper_fcos();
2185 }
2186
2187 void OPPROTO op_fnstsw_A0(void)
2188 {
2189 int fpus;
2190 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2191 stw((void *)A0, fpus);
2192 }
2193
2194 void OPPROTO op_fnstsw_EAX(void)
2195 {
2196 int fpus;
2197 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
2198 EAX = (EAX & 0xffff0000) | fpus;
2199 }
2200
2201 void OPPROTO op_fnstcw_A0(void)
2202 {
2203 stw((void *)A0, env->fpuc);
2204 }
2205
2206 void OPPROTO op_fldcw_A0(void)
2207 {
2208 int rnd_type;
2209 env->fpuc = lduw((void *)A0);
2210 /* set rounding mode */
2211 switch(env->fpuc & RC_MASK) {
2212 default:
2213 case RC_NEAR:
2214 rnd_type = FE_TONEAREST;
2215 break;
2216 case RC_DOWN:
2217 rnd_type = FE_DOWNWARD;
2218 break;
2219 case RC_UP:
2220 rnd_type = FE_UPWARD;
2221 break;
2222 case RC_CHOP:
2223 rnd_type = FE_TOWARDZERO;
2224 break;
2225 }
2226 fesetround(rnd_type);
2227 }
2228
2229 void OPPROTO op_fclex(void)
2230 {
2231 env->fpus &= 0x7f00;
2232 }
2233
2234 void OPPROTO op_fninit(void)
2235 {
2236 env->fpus = 0;
2237 env->fpstt = 0;
2238 env->fpuc = 0x37f;
2239 env->fptags[0] = 1;
2240 env->fptags[1] = 1;
2241 env->fptags[2] = 1;
2242 env->fptags[3] = 1;
2243 env->fptags[4] = 1;
2244 env->fptags[5] = 1;
2245 env->fptags[6] = 1;
2246 env->fptags[7] = 1;
2247 }
AR7 emulation for QEMU