← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/emu/cpu/i386/x87ops.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emu/cpu/i386/x87ops.c
292
292
 
293
293
        if ((cpustate->x87_sw & ~cpustate->x87_cw) & 0x3f)
294
294
        {
295
 
                // TODO
296
 
                fatalerror("Unimplemented: unmasked x87 exception (CW:%.4x, SW:%.4x)", cpustate->x87_cw, cpustate->x87_sw);
 
295
                // device_set_input_line(cpustate->device, INPUT_LINE_FERR, RAISE_LINE);
 
296
                logerror("Unmasked x87 exception (CW:%.4x, SW:%.4x)\n", cpustate->x87_cw, cpustate->x87_sw);
 
297
                if (cpustate->cr[0] & 0x20) // FIXME: 486 and up only
 
298
                {
 
299
                        cpustate->ext = 1;
 
300
                        i386_trap(cpustate, FAULT_MF, 0, 0);
 
301
                }
297
302
                return 0;
298
303
        }
299
304
 
465
470
{
466
471
        floatx80 result;
467
472
 
 
473
        UINT32 ea = GetEA(cpustate, modrm, 0);
468
474
        if (X87_IS_ST_EMPTY(0))
469
475
        {
470
476
                x87_set_stack_underflow(cpustate);
472
478
        }
473
479
        else
474
480
        {
475
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
476
481
                UINT32 m32real = READ32(cpustate, ea);
477
482
 
478
483
                floatx80 a = ST(0);
500
505
{
501
506
        floatx80 result;
502
507
 
 
508
        UINT32 ea = GetEA(cpustate, modrm, 0);
503
509
        if (X87_IS_ST_EMPTY(0))
504
510
        {
505
511
                x87_set_stack_underflow(cpustate);
507
513
        }
508
514
        else
509
515
        {
510
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
511
516
                UINT64 m64real = READ64(cpustate, ea);
512
517
 
513
518
                floatx80 a = ST(0);
637
642
{
638
643
        floatx80 result;
639
644
 
 
645
        UINT32 ea = GetEA(cpustate, modrm, 0);
640
646
        if (X87_IS_ST_EMPTY(0))
641
647
        {
642
648
                x87_set_stack_underflow(cpustate);
644
650
        }
645
651
        else
646
652
        {
647
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
648
653
                INT32 m32int = READ32(cpustate, ea);
649
654
 
650
655
                floatx80 a = ST(0);
672
677
{
673
678
        floatx80 result;
674
679
 
 
680
        UINT32 ea = GetEA(cpustate, modrm, 0);
675
681
        if (X87_IS_ST_EMPTY(0))
676
682
        {
677
683
                x87_set_stack_underflow(cpustate);
679
685
        }
680
686
        else
681
687
        {
682
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
683
688
                INT16 m16int = READ16(cpustate, ea);
684
689
 
685
690
                floatx80 a = ST(0);
714
719
{
715
720
        floatx80 result;
716
721
 
 
722
        UINT32 ea = GetEA(cpustate, modrm, 0);
717
723
        if (X87_IS_ST_EMPTY(0))
718
724
        {
719
725
                x87_set_stack_underflow(cpustate);
721
727
        }
722
728
        else
723
729
        {
724
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
725
730
                UINT32 m32real = READ32(cpustate, ea);
726
731
 
727
732
                floatx80 a = ST(0);
749
754
{
750
755
        floatx80 result;
751
756
 
 
757
        UINT32 ea = GetEA(cpustate, modrm, 0);
752
758
        if (X87_IS_ST_EMPTY(0))
753
759
        {
754
760
                x87_set_stack_underflow(cpustate);
756
762
        }
757
763
        else
758
764
        {
759
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
760
765
                UINT64 m64real = READ64(cpustate, ea);
761
766
 
762
767
                floatx80 a = ST(0);
886
891
{
887
892
        floatx80 result;
888
893
 
 
894
        UINT32 ea = GetEA(cpustate, modrm, 0);
889
895
        if (X87_IS_ST_EMPTY(0))
890
896
        {
891
897
                x87_set_stack_underflow(cpustate);
893
899
        }
894
900
        else
895
901
        {
896
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
897
902
                INT32 m32int = READ32(cpustate, ea);
898
903
 
899
904
                floatx80 a = ST(0);
921
926
{
922
927
        floatx80 result;
923
928
 
 
929
        UINT32 ea = GetEA(cpustate, modrm, 0);
924
930
        if (X87_IS_ST_EMPTY(0))
925
931
        {
926
932
                x87_set_stack_underflow(cpustate);
928
934
        }
929
935
        else
930
936
        {
931
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
932
937
                INT16 m16int = READ16(cpustate, ea);
933
938
 
934
939
                floatx80 a = ST(0);
963
968
{
964
969
        floatx80 result;
965
970
 
 
971
        UINT32 ea = GetEA(cpustate, modrm, 0);
966
972
        if (X87_IS_ST_EMPTY(0))
967
973
        {
968
974
                x87_set_stack_underflow(cpustate);
970
976
        }
971
977
        else
972
978
        {
973
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
974
979
                UINT32 m32real = READ32(cpustate, ea);
975
980
 
976
981
                floatx80 a = float32_to_floatx80(m32real);
998
1003
{
999
1004
        floatx80 result;
1000
1005
 
 
1006
        UINT32 ea = GetEA(cpustate, modrm, 0);
1001
1007
        if (X87_IS_ST_EMPTY(0))
1002
1008
        {
1003
1009
                x87_set_stack_underflow(cpustate);
1005
1011
        }
1006
1012
        else
1007
1013
        {
1008
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1009
1014
                UINT64 m64real = READ64(cpustate, ea);
1010
1015
 
1011
1016
                floatx80 a = float64_to_floatx80(m64real);
1135
1140
{
1136
1141
        floatx80 result;
1137
1142
 
 
1143
        UINT32 ea = GetEA(cpustate, modrm, 0);
1138
1144
        if (X87_IS_ST_EMPTY(0))
1139
1145
        {
1140
1146
                x87_set_stack_underflow(cpustate);
1142
1148
        }
1143
1149
        else
1144
1150
        {
1145
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1146
1151
                INT32 m32int = READ32(cpustate, ea);
1147
1152
 
1148
1153
                floatx80 a = int32_to_floatx80(m32int);
1170
1175
{
1171
1176
        floatx80 result;
1172
1177
 
 
1178
        UINT32 ea = GetEA(cpustate, modrm, 0);
1173
1179
        if (X87_IS_ST_EMPTY(0))
1174
1180
        {
1175
1181
                x87_set_stack_underflow(cpustate);
1177
1183
        }
1178
1184
        else
1179
1185
        {
1180
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1181
1186
                INT16 m16int = READ16(cpustate, ea);
1182
1187
 
1183
1188
                floatx80 a = int32_to_floatx80(m16int);
1212
1217
{
1213
1218
        floatx80 result;
1214
1219
 
 
1220
        UINT32 ea = GetEA(cpustate, modrm, 0);
1215
1221
        if (X87_IS_ST_EMPTY(0))
1216
1222
        {
1217
1223
                x87_set_stack_underflow(cpustate);
1219
1225
        }
1220
1226
        else
1221
1227
        {
1222
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1223
1228
                UINT32 m32real = READ32(cpustate, ea);
1224
1229
 
1225
1230
                floatx80 a = ST(0);
1247
1252
{
1248
1253
        floatx80 result;
1249
1254
 
 
1255
        UINT32 ea = GetEA(cpustate, modrm, 0);
1250
1256
        if (X87_IS_ST_EMPTY(0))
1251
1257
        {
1252
1258
                x87_set_stack_underflow(cpustate);
1254
1260
        }
1255
1261
        else
1256
1262
        {
1257
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1258
1263
                UINT64 m64real = READ64(cpustate, ea);
1259
1264
 
1260
1265
                floatx80 a = ST(0);
1388
1393
{
1389
1394
        floatx80 result;
1390
1395
 
 
1396
        UINT32 ea = GetEA(cpustate, modrm, 0);
1391
1397
        if (X87_IS_ST_EMPTY(0))
1392
1398
        {
1393
1399
                x87_set_stack_underflow(cpustate);
1395
1401
        }
1396
1402
        else
1397
1403
        {
1398
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1399
1404
                INT32 m32int = READ32(cpustate, ea);
1400
1405
 
1401
1406
                floatx80 a = ST(0);
1423
1428
{
1424
1429
        floatx80 result;
1425
1430
 
 
1431
        UINT32 ea = GetEA(cpustate, modrm, 0);
1426
1432
        if (X87_IS_ST_EMPTY(0))
1427
1433
        {
1428
1434
                x87_set_stack_underflow(cpustate);
1430
1436
        }
1431
1437
        else
1432
1438
        {
1433
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1434
1439
                INT16 m16int = READ32(cpustate, ea);
1435
1440
 
1436
1441
                floatx80 a = ST(0);
1465
1470
{
1466
1471
        floatx80 result;
1467
1472
 
 
1473
        UINT32 ea = GetEA(cpustate, modrm, 0);
1468
1474
        if (X87_IS_ST_EMPTY(0))
1469
1475
        {
1470
1476
                x87_set_stack_underflow(cpustate);
1472
1478
        }
1473
1479
        else
1474
1480
        {
1475
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1476
1481
                UINT32 m32real = READ32(cpustate, ea);
1477
1482
 
1478
1483
                floatx80 a = float32_to_floatx80(m32real);
1500
1505
{
1501
1506
        floatx80 result;
1502
1507
 
 
1508
        UINT32 ea = GetEA(cpustate, modrm, 0);
1503
1509
        if (X87_IS_ST_EMPTY(0))
1504
1510
        {
1505
1511
                x87_set_stack_underflow(cpustate);
1507
1513
        }
1508
1514
        else
1509
1515
        {
1510
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1511
1516
                UINT64 m64real = READ64(cpustate, ea);
1512
1517
 
1513
1518
                floatx80 a = float64_to_floatx80(m64real);
1642
1647
{
1643
1648
        floatx80 result;
1644
1649
 
 
1650
        UINT32 ea = GetEA(cpustate, modrm, 0);
1645
1651
        if (X87_IS_ST_EMPTY(0))
1646
1652
        {
1647
1653
                x87_set_stack_underflow(cpustate);
1649
1655
        }
1650
1656
        else
1651
1657
        {
1652
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1653
1658
                INT32 m32int = READ32(cpustate, ea);
1654
1659
 
1655
1660
                floatx80 a = int32_to_floatx80(m32int);
1677
1682
{
1678
1683
        floatx80 result;
1679
1684
 
 
1685
        UINT32 ea = GetEA(cpustate, modrm, 0);
1680
1686
        if (X87_IS_ST_EMPTY(0))
1681
1687
        {
1682
1688
                x87_set_stack_underflow(cpustate);
1684
1690
        }
1685
1691
        else
1686
1692
        {
1687
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1688
1693
                INT16 m16int = READ32(cpustate, ea);
1689
1694
 
1690
1695
                floatx80 a = int32_to_floatx80(m16int);
1719
1724
{
1720
1725
        floatx80 result;
1721
1726
 
 
1727
        UINT32 ea = GetEA(cpustate, modrm, 0);
1722
1728
        if (X87_IS_ST_EMPTY(0))
1723
1729
        {
1724
1730
                x87_set_stack_underflow(cpustate);
1726
1732
        }
1727
1733
        else
1728
1734
        {
1729
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1730
1735
                UINT32 m32real = READ32(cpustate, ea);
1731
1736
 
1732
1737
                floatx80 a = ST(0);
1753
1758
{
1754
1759
        floatx80 result;
1755
1760
 
 
1761
        UINT32 ea = GetEA(cpustate, modrm, 0);
1756
1762
        if (X87_IS_ST_EMPTY(0))
1757
1763
        {
1758
1764
                x87_set_stack_underflow(cpustate);
1760
1766
        }
1761
1767
        else
1762
1768
        {
1763
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1764
1769
                UINT64 m64real = READ64(cpustate, ea);
1765
1770
 
1766
1771
                floatx80 a = ST(0);
1886
1891
{
1887
1892
        floatx80 result;
1888
1893
 
 
1894
        UINT32 ea = GetEA(cpustate, modrm, 0);
1889
1895
        if (X87_IS_ST_EMPTY(0))
1890
1896
        {
1891
1897
                x87_set_stack_underflow(cpustate);
1893
1899
        }
1894
1900
        else
1895
1901
        {
1896
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1897
1902
                INT32 m32int = READ32(cpustate, ea);
1898
1903
 
1899
1904
                floatx80 a = ST(0);
1920
1925
{
1921
1926
        floatx80 result;
1922
1927
 
 
1928
        UINT32 ea = GetEA(cpustate, modrm, 0);
1923
1929
        if (X87_IS_ST_EMPTY(0))
1924
1930
        {
1925
1931
                x87_set_stack_underflow(cpustate);
1927
1933
        }
1928
1934
        else
1929
1935
        {
1930
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
1931
1936
                INT16 m16int = READ16(cpustate, ea);
1932
1937
 
1933
1938
                floatx80 a = ST(0);
2332
2337
{
2333
2338
        floatx80 value;
2334
2339
 
 
2340
        UINT32 ea = GetEA(cpustate, modrm, 0);
2335
2341
        if (x87_dec_stack(cpustate))
2336
2342
        {
2337
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2338
2343
                UINT32 m32real = READ32(cpustate, ea);
2339
2344
 
2340
2345
                value = float32_to_floatx80(m32real);
2362
2367
{
2363
2368
        floatx80 value;
2364
2369
 
 
2370
        UINT32 ea = GetEA(cpustate, modrm, 0);
2365
2371
        if (x87_dec_stack(cpustate))
2366
2372
        {
2367
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2368
2373
                UINT64 m64real = READ64(cpustate, ea);
2369
2374
 
2370
2375
                value = float64_to_floatx80(m64real);
2392
2397
{
2393
2398
        floatx80 value;
2394
2399
 
 
2400
        UINT32 ea = GetEA(cpustate, modrm, 0);
2395
2401
        if (x87_dec_stack(cpustate))
2396
2402
        {
2397
2403
                cpustate->x87_sw &= ~X87_SW_C1;
2398
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2399
2404
                value = READ80(cpustate, ea);
2400
2405
        }
2401
2406
        else
2433
2438
{
2434
2439
        floatx80 value;
2435
2440
 
 
2441
        UINT32 ea = GetEA(cpustate, modrm, 0);
2436
2442
        if (!x87_dec_stack(cpustate))
2437
2443
        {
2438
2444
                value = fx80_inan;
2441
2447
        {
2442
2448
                cpustate->x87_sw &= ~X87_SW_C1;
2443
2449
 
2444
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2445
2450
                INT16 m16int = READ16(cpustate, ea);
2446
2451
                value = int32_to_floatx80(m16int);
2447
2452
        }
2456
2461
{
2457
2462
        floatx80 value;
2458
2463
 
 
2464
        UINT32 ea = GetEA(cpustate, modrm, 0);
2459
2465
        if (!x87_dec_stack(cpustate))
2460
2466
        {
2461
2467
                value = fx80_inan;
2464
2470
        {
2465
2471
                cpustate->x87_sw &= ~X87_SW_C1;
2466
2472
 
2467
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2468
2473
                INT32 m32int = READ32(cpustate, ea);
2469
2474
                value = int32_to_floatx80(m32int);
2470
2475
        }
2479
2484
{
2480
2485
        floatx80 value;
2481
2486
 
 
2487
        UINT32 ea = GetEA(cpustate, modrm, 0);
2482
2488
        if (!x87_dec_stack(cpustate))
2483
2489
        {
2484
2490
                value = fx80_inan;
2487
2493
        {
2488
2494
                cpustate->x87_sw &= ~X87_SW_C1;
2489
2495
 
2490
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2491
2496
                INT64 m64int = READ64(cpustate, ea);
2492
2497
                value = int64_to_floatx80(m64int);
2493
2498
        }
2502
2507
{
2503
2508
        floatx80 value;
2504
2509
 
 
2510
        UINT32 ea = GetEA(cpustate, modrm, 0);
2505
2511
        if (!x87_dec_stack(cpustate))
2506
2512
        {
2507
2513
                value = fx80_inan;
2510
2516
        {
2511
2517
                cpustate->x87_sw &= ~X87_SW_C1;
2512
2518
 
2513
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
2514
2519
                UINT64 m64val = 0;
2515
2520
                UINT16 sign;
2516
2521
 
2547
2552
{
2548
2553
        floatx80 value;
2549
2554
 
 
2555
        UINT32 ea = GetEA(cpustate, modrm, 1);
2550
2556
        if (X87_IS_ST_EMPTY(0))
2551
2557
        {
2552
2558
                x87_set_stack_underflow(cpustate);
2561
2567
        if (x87_check_exceptions(cpustate))
2562
2568
        {
2563
2569
                UINT32 m32real = floatx80_to_float32(value);
2564
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2565
2570
                WRITE32(cpustate, ea, m32real);
2566
2571
        }
2567
2572
 
2572
2577
{
2573
2578
        floatx80 value;
2574
2579
 
 
2580
        UINT32 ea = GetEA(cpustate, modrm, 1);
2575
2581
        if (X87_IS_ST_EMPTY(0))
2576
2582
        {
2577
2583
                x87_set_stack_underflow(cpustate);
2586
2592
        if (x87_check_exceptions(cpustate))
2587
2593
        {
2588
2594
                UINT64 m64real = floatx80_to_float64(value);
2589
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2590
2595
                WRITE64(cpustate, ea, m64real);
2591
2596
        }
2592
2597
 
2619
2624
{
2620
2625
        floatx80 value;
2621
2626
 
 
2627
        UINT32 ea = GetEA(cpustate, modrm, 1);
2622
2628
        if (X87_IS_ST_EMPTY(0))
2623
2629
        {
2624
2630
                x87_set_stack_underflow(cpustate);
2633
2639
        if (x87_check_exceptions(cpustate))
2634
2640
        {
2635
2641
                UINT32 m32real = floatx80_to_float32(value);
2636
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2637
2642
                WRITE32(cpustate, ea, m32real);
2638
2643
                x87_inc_stack(cpustate);
2639
2644
        }
2657
2662
        }
2658
2663
 
2659
2664
 
 
2665
        UINT32 ea = GetEA(cpustate, modrm, 1);
2660
2666
        if (x87_check_exceptions(cpustate))
2661
2667
        {
2662
2668
                UINT64 m64real = floatx80_to_float64(value);
2663
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2664
2669
                WRITE64(cpustate, ea, m64real);
2665
2670
                x87_inc_stack(cpustate);
2666
2671
        }
2683
2688
                value = ST(0);
2684
2689
        }
2685
2690
 
 
2691
        UINT32 ea = GetEA(cpustate, modrm, 1);
2686
2692
        if (x87_check_exceptions(cpustate))
2687
2693
        {
2688
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2689
2694
                WRITE80(cpustate, ea, value);
2690
2695
                x87_inc_stack(cpustate);
2691
2696
        }
2742
2747
                        m16int = -32768;
2743
2748
        }
2744
2749
 
 
2750
        UINT32 ea = GetEA(cpustate, modrm, 1);
2745
2751
        if (x87_check_exceptions(cpustate))
2746
2752
        {
2747
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2748
2753
                WRITE16(cpustate, ea, m16int);
2749
2754
        }
2750
2755
 
2775
2780
                        m32int = 0x80000000;
2776
2781
        }
2777
2782
 
 
2783
        UINT32 ea = GetEA(cpustate, modrm, 1);
2778
2784
        if (x87_check_exceptions(cpustate))
2779
2785
        {
2780
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2781
2786
                WRITE32(cpustate, ea, m32int);
2782
2787
        }
2783
2788
 
2808
2813
                        m16int = (UINT16)0x8000;
2809
2814
        }
2810
2815
 
 
2816
        UINT32 ea = GetEA(cpustate, modrm, 1);
2811
2817
        if (x87_check_exceptions(cpustate))
2812
2818
        {
2813
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2814
2819
                WRITE16(cpustate, ea, m16int);
2815
2820
                x87_inc_stack(cpustate);
2816
2821
        }
2842
2847
                        m32int = 0x80000000;
2843
2848
        }
2844
2849
 
 
2850
        UINT32 ea = GetEA(cpustate, modrm, 1);
2845
2851
        if (x87_check_exceptions(cpustate))
2846
2852
        {
2847
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2848
2853
                WRITE32(cpustate, ea, m32int);
2849
2854
                x87_inc_stack(cpustate);
2850
2855
        }
2876
2881
                        m64int = U64(0x8000000000000000);
2877
2882
        }
2878
2883
 
 
2884
        UINT32 ea = GetEA(cpustate, modrm, 1);
2879
2885
        if (x87_check_exceptions(cpustate))
2880
2886
        {
2881
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2882
2887
                WRITE64(cpustate, ea, m64int);
2883
2888
                x87_inc_stack(cpustate);
2884
2889
        }
2911
2916
                result.high |= ST(0).high & 0x8000;
2912
2917
        }
2913
2918
 
 
2919
        UINT32 ea = GetEA(cpustate, modrm, 1);
2914
2920
        if (x87_check_exceptions(cpustate))
2915
2921
        {
2916
 
                UINT32 ea = GetEA(cpustate, modrm, 1);
2917
2922
                WRITE80(cpustate, ea, result);
2918
2923
                x87_inc_stack(cpustate);
2919
2924
        }
3385
3390
 
3386
3391
void x87_ficom_m16int(i386_state *cpustate, UINT8 modrm)
3387
3392
{
 
3393
        UINT32 ea = GetEA(cpustate, modrm, 0);
3388
3394
        if (X87_IS_ST_EMPTY(0))
3389
3395
        {
3390
3396
                x87_set_stack_underflow(cpustate);
3394
3400
        {
3395
3401
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3396
3402
 
3397
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3398
3403
                INT16 m16int = READ16(cpustate, ea);
3399
3404
 
3400
3405
                floatx80 a = ST(0);
3422
3427
 
3423
3428
void x87_ficom_m32int(i386_state *cpustate, UINT8 modrm)
3424
3429
{
 
3430
        UINT32 ea = GetEA(cpustate, modrm, 0);
3425
3431
        if (X87_IS_ST_EMPTY(0))
3426
3432
        {
3427
3433
                x87_set_stack_underflow(cpustate);
3431
3437
        {
3432
3438
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3433
3439
 
3434
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3435
3440
                INT32 m32int = READ32(cpustate, ea);
3436
3441
 
3437
3442
                floatx80 a = ST(0);
3459
3464
 
3460
3465
void x87_ficomp_m16int(i386_state *cpustate, UINT8 modrm)
3461
3466
{
 
3467
        UINT32 ea = GetEA(cpustate, modrm, 0);
3462
3468
        if (X87_IS_ST_EMPTY(0))
3463
3469
        {
3464
3470
                x87_set_stack_underflow(cpustate);
3468
3474
        {
3469
3475
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3470
3476
 
3471
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3472
3477
                INT16 m16int = READ16(cpustate, ea);
3473
3478
 
3474
3479
                floatx80 a = ST(0);
3497
3502
 
3498
3503
void x87_ficomp_m32int(i386_state *cpustate, UINT8 modrm)
3499
3504
{
 
3505
        UINT32 ea = GetEA(cpustate, modrm, 0);
3500
3506
        if (X87_IS_ST_EMPTY(0))
3501
3507
        {
3502
3508
                x87_set_stack_underflow(cpustate);
3506
3512
        {
3507
3513
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3508
3514
 
3509
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3510
3515
                INT32 m32int = READ32(cpustate, ea);
3511
3516
 
3512
3517
                floatx80 a = ST(0);
3536
3541
 
3537
3542
void x87_fcom_m32real(i386_state *cpustate, UINT8 modrm)
3538
3543
{
 
3544
        UINT32 ea = GetEA(cpustate, modrm, 0);
3539
3545
        if (X87_IS_ST_EMPTY(0))
3540
3546
        {
3541
3547
                x87_set_stack_underflow(cpustate);
3545
3551
        {
3546
3552
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3547
3553
 
3548
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3549
3554
                UINT32 m32real = READ32(cpustate, ea);
3550
3555
 
3551
3556
                floatx80 a = ST(0);
3573
3578
 
3574
3579
void x87_fcom_m64real(i386_state *cpustate, UINT8 modrm)
3575
3580
{
 
3581
        UINT32 ea = GetEA(cpustate, modrm, 0);
3576
3582
        if (X87_IS_ST_EMPTY(0))
3577
3583
        {
3578
3584
                x87_set_stack_underflow(cpustate);
3582
3588
        {
3583
3589
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3584
3590
 
3585
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3586
3591
                UINT64 m64real = READ64(cpustate, ea);
3587
3592
 
3588
3593
                floatx80 a = ST(0);
3646
3651
 
3647
3652
void x87_fcomp_m32real(i386_state *cpustate, UINT8 modrm)
3648
3653
{
 
3654
        UINT32 ea = GetEA(cpustate, modrm, 0);
3649
3655
        if (X87_IS_ST_EMPTY(0))
3650
3656
        {
3651
3657
                x87_set_stack_underflow(cpustate);
3655
3661
        {
3656
3662
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3657
3663
 
3658
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3659
3664
                UINT32 m32real = READ32(cpustate, ea);
3660
3665
 
3661
3666
                floatx80 a = ST(0);
3684
3689
 
3685
3690
void x87_fcomp_m64real(i386_state *cpustate, UINT8 modrm)
3686
3691
{
 
3692
        UINT32 ea = GetEA(cpustate, modrm, 0);
3687
3693
        if (X87_IS_ST_EMPTY(0))
3688
3694
        {
3689
3695
                x87_set_stack_underflow(cpustate);
3693
3699
        {
3694
3700
                cpustate->x87_sw &= ~(X87_SW_C3 | X87_SW_C2 | X87_SW_C1 | X87_SW_C0);
3695
3701
 
3696
 
                UINT32 ea = GetEA(cpustate, modrm, 0);
3697
3702
                UINT64 m64real = READ64(cpustate, ea);
3698
3703
 
3699
3704
                floatx80 a = ST(0);
4566
4571
                        switch (modrm)
4567
4572
                        {
4568
4573
                                case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: ptr = x87_ffree;                break;
 
4574
                                case 0xc8: case 0xc9: case 0xca: case 0xcb: case 0xcc: case 0xcd: case 0xce: case 0xcf: ptr = x87_fxch_sti;             break;
4569
4575
                                case 0xd0: case 0xd1: case 0xd2: case 0xd3: case 0xd4: case 0xd5: case 0xd6: case 0xd7: ptr = x87_fst_sti;              break;
4570
4576
                                case 0xd8: case 0xd9: case 0xda: case 0xdb: case 0xdc: case 0xdd: case 0xde: case 0xdf: ptr = x87_fstp_sti;             break;
4571
4577
                                case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4: case 0xe5: case 0xe6: case 0xe7: ptr = x87_fucom_sti;    break;
4572
 
                                case 0xf0: case 0xf1: case 0xf2: case 0xf3: case 0xf4: case 0xf5: case 0xf6: case 0xf7: ptr = x87_fucomp_sti;   break;
 
4578
                                case 0xe8: case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed: case 0xee: case 0xef: ptr = x87_fucomp_sti;   break;
4573
4579
                        }
4574
4580
                }
4575
4581