← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-m68k/op.c

Tags: upstream-0.9.0+20070816
Import upstream version 0.9.0+20070816

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-m68k/op.c
1
1
/*
2
2
 *  m68k micro operations
3
3
 * 
4
 
 *  Copyright (c) 2006 CodeSourcery
 
4
 *  Copyright (c) 2006-2007 CodeSourcery
5
5
 *  Written by Paul Brook
6
6
 *
7
7
 * This library is free software; you can redistribute it and/or
48
48
uint32_t
49
49
get_op(int qreg)
50
50
{
51
 
    if (qreg == QREG_T0) {
 
51
    if (qreg >= TARGET_NUM_QREGS) {
 
52
        return env->qregs[qreg - TARGET_NUM_QREGS];
 
53
    } else if (qreg == QREG_T0) {
52
54
        return T0;
53
 
    } else if (qreg < TARGET_NUM_QREGS) {
 
55
    } else {
54
56
        return *(uint32_t *)(((long)env) + qreg_offsets[qreg]);
55
 
    } else {
56
 
        return env->qregs[qreg - TARGET_NUM_QREGS];
57
57
    }
58
58
}
59
59
 
60
60
void set_op(int qreg, uint32_t val)
61
61
{
62
 
    if (qreg == QREG_T0) {
 
62
    if (qreg >= TARGET_NUM_QREGS) {
 
63
        env->qregs[qreg - TARGET_NUM_QREGS] = val;
 
64
    } else if (qreg == QREG_T0) {
63
65
        T0 = val;
64
 
    } else if (qreg < TARGET_NUM_QREGS) {
 
66
    } else {
65
67
        *(uint32_t *)(((long)env) + qreg_offsets[qreg]) = val;
66
 
    } else {
67
 
        env->qregs[qreg - TARGET_NUM_QREGS] = val;
68
68
    }
69
69
}
70
70
 
86
86
    }
87
87
}
88
88
 
89
 
#define OP(name) void OPPROTO op_##name (void)
 
89
#define OP(name) void OPPROTO glue(op_,name) (void)
90
90
 
91
91
OP(mov32)
92
92
{
170
170
    FORCE_RET();
171
171
}
172
172
 
173
 
OP(addx_cc)
 
173
OP(ff1)
 
174
{
 
175
    uint32_t arg = get_op(PARAM2);
 
176
    int n;
 
177
    for (n = 32; arg; n--)
 
178
        arg >>= 1;
 
179
    set_op(PARAM1, n);
 
180
    FORCE_RET();
 
181
}
 
182
 
 
183
OP(subx_cc)
174
184
{
175
185
    uint32_t op1 = get_op(PARAM1);
176
186
    uint32_t op2 = get_op(PARAM2);
188
198
    FORCE_RET();
189
199
}
190
200
 
191
 
OP(subx_cc)
 
201
OP(addx_cc)
192
202
{
193
203
    uint32_t op1 = get_op(PARAM1);
194
204
    uint32_t op2 = get_op(PARAM2);
275
285
    FORCE_RET();
276
286
}
277
287
 
 
288
OP(sar32)
 
289
{
 
290
    int32_t op2 = get_op(PARAM2);
 
291
    uint32_t op3 = get_op(PARAM3);
 
292
    uint32_t result;
 
293
    result = op2 >> op3;
 
294
    set_op(PARAM1, result);
 
295
    FORCE_RET();
 
296
}
 
297
 
278
298
OP(sar_cc)
279
299
{
280
300
    int32_t op1 = get_op(PARAM1);
316
336
    FORCE_RET();
317
337
}
318
338
 
319
 
/* Load/store ops.  */
320
 
OP(ld8u32)
321
 
{
322
 
    uint32_t addr = get_op(PARAM2);
323
 
    set_op(PARAM1, ldub(addr));
324
 
    FORCE_RET();
325
 
}
326
 
 
327
 
OP(ld8s32)
328
 
{
329
 
    uint32_t addr = get_op(PARAM2);
330
 
    set_op(PARAM1, ldsb(addr));
331
 
    FORCE_RET();
332
 
}
333
 
 
334
 
OP(ld16u32)
335
 
{
336
 
    uint32_t addr = get_op(PARAM2);
337
 
    set_op(PARAM1, lduw(addr));
338
 
    FORCE_RET();
339
 
}
340
 
 
341
 
OP(ld16s32)
342
 
{
343
 
    uint32_t addr = get_op(PARAM2);
344
 
    set_op(PARAM1, ldsw(addr));
345
 
    FORCE_RET();
346
 
}
347
 
 
348
 
OP(ld32)
349
 
{
350
 
    uint32_t addr = get_op(PARAM2);
351
 
    set_op(PARAM1, ldl(addr));
352
 
    FORCE_RET();
353
 
}
354
 
 
355
 
OP(st8)
356
 
{
357
 
    uint32_t addr = get_op(PARAM1);
358
 
    stb(addr, get_op(PARAM2));
359
 
    FORCE_RET();
360
 
}
361
 
 
362
 
OP(st16)
363
 
{
364
 
    uint32_t addr = get_op(PARAM1);
365
 
    stw(addr, get_op(PARAM2));
366
 
    FORCE_RET();
367
 
}
368
 
 
369
 
OP(st32)
370
 
{
371
 
    uint32_t addr = get_op(PARAM1);
372
 
    stl(addr, get_op(PARAM2));
373
 
    FORCE_RET();
374
 
}
375
 
 
376
 
OP(ldf64)
377
 
{
378
 
    uint32_t addr = get_op(PARAM2);
379
 
    set_opf64(PARAM1, ldfq(addr));
380
 
    FORCE_RET();
381
 
}
382
 
 
383
 
OP(stf64)
384
 
{
385
 
    uint32_t addr = get_op(PARAM1);
386
 
    stfq(addr, get_opf64(PARAM2));
387
 
    FORCE_RET();
388
 
}
389
 
 
390
339
OP(flush_flags)
391
340
{
392
 
    int cc_op  = PARAM1;
393
 
    if (cc_op == CC_OP_DYNAMIC)
394
 
        cc_op = env->cc_op;
395
 
    cpu_m68k_flush_flags(env, cc_op);
 
341
    cpu_m68k_flush_flags(env, env->cc_op);
396
342
    FORCE_RET();
397
343
}
398
344
 
454
400
    FORCE_RET();
455
401
}
456
402
 
 
403
/* Halt is special because it may be a semihosting call.  */
 
404
OP(halt)
 
405
{
 
406
    RAISE_EXCEPTION(EXCP_HALT_INSN);
 
407
    FORCE_RET();
 
408
}
 
409
 
 
410
OP(stop)
 
411
{
 
412
    env->halted = 1;
 
413
    RAISE_EXCEPTION(EXCP_HLT);
 
414
    FORCE_RET();
 
415
}
 
416
 
457
417
OP(raise_exception)
458
418
{
459
419
    RAISE_EXCEPTION(PARAM1);
515
475
    FORCE_RET();
516
476
}
517
477
 
 
478
OP(set_sr)
 
479
{
 
480
    env->sr = get_op(PARAM1) & 0xffff;
 
481
    m68k_switch_sp(env);
 
482
    FORCE_RET();
 
483
}
 
484
 
518
485
OP(jmp)
519
486
{
520
487
    GOTO_LABEL_PARAM(1);
521
488
}
522
489
 
523
 
/* These ops involve a function call, which probably requires a stack frame
524
 
   and breaks things on some hosts.  */
525
 
OP(jmp_z32)
526
 
{
527
 
    uint32_t arg = get_op(PARAM1);
528
 
    if (arg == 0)
529
 
        GOTO_LABEL_PARAM(2);
530
 
    FORCE_RET();
531
 
}
532
 
 
533
 
OP(jmp_nz32)
534
 
{
535
 
    uint32_t arg = get_op(PARAM1);
536
 
    if (arg != 0)
537
 
        GOTO_LABEL_PARAM(2);
538
 
    FORCE_RET();
539
 
}
540
 
 
541
 
OP(jmp_s32)
542
 
{
543
 
    int32_t arg = get_op(PARAM1);
544
 
    if (arg < 0)
545
 
        GOTO_LABEL_PARAM(2);
546
 
    FORCE_RET();
547
 
}
548
 
 
549
 
OP(jmp_ns32)
550
 
{
551
 
    int32_t arg = get_op(PARAM1);
552
 
    if (arg >= 0)
553
 
        GOTO_LABEL_PARAM(2);
 
490
OP(set_T0_z32)
 
491
{
 
492
    uint32_t arg = get_op(PARAM1);
 
493
    T0 = (arg == 0);
 
494
    FORCE_RET();
 
495
}
 
496
 
 
497
OP(set_T0_nz32)
 
498
{
 
499
    uint32_t arg = get_op(PARAM1);
 
500
    T0 = (arg != 0);
 
501
    FORCE_RET();
 
502
}
 
503
 
 
504
OP(set_T0_s32)
 
505
{
 
506
    int32_t arg = get_op(PARAM1);
 
507
    T0 = (arg > 0);
 
508
    FORCE_RET();
 
509
}
 
510
 
 
511
OP(set_T0_ns32)
 
512
{
 
513
    int32_t arg = get_op(PARAM1);
 
514
    T0 = (arg >= 0);
 
515
    FORCE_RET();
 
516
}
 
517
 
 
518
OP(jmp_T0)
 
519
{
 
520
    if (T0)
 
521
        GOTO_LABEL_PARAM(1);
554
522
    FORCE_RET();
555
523
}
556
524
 
679
647
    set_op(PARAM1, float64_compare_quiet(op0, op1, &CPU_FP_STATUS));
680
648
    FORCE_RET();
681
649
}
 
650
 
 
651
OP(movec)
 
652
{
 
653
    int op1 = get_op(PARAM1);
 
654
    uint32_t op2 = get_op(PARAM2);
 
655
    helper_movec(env, op1, op2);
 
656
}
 
657
 
 
658
/* Memory access.  */
 
659
 
 
660
#define MEMSUFFIX _raw
 
661
#include "op_mem.h"
 
662
 
 
663
#if !defined(CONFIG_USER_ONLY)
 
664
#define MEMSUFFIX _user
 
665
#include "op_mem.h"
 
666
#define MEMSUFFIX _kernel
 
667
#include "op_mem.h"
 
668
#endif
 
669
 
 
670
/* MAC unit.  */
 
671
/* TODO: The MAC instructions use 64-bit arithmetic fairly extensively.
 
672
   This results in fairly large ops (and sometimes other issues) on 32-bit
 
673
   hosts.  Maybe move most of them into helpers.  */
 
674
OP(macmuls)
 
675
{
 
676
    uint32_t op1 = get_op(PARAM1);
 
677
    uint32_t op2 = get_op(PARAM2);
 
678
    int64_t product;
 
679
    int64_t res;
 
680
 
 
681
    product = (uint64_t)op1 * op2;
 
682
    res = (product << 24) >> 24;
 
683
    if (res != product) {
 
684
        env->macsr |= MACSR_V;
 
685
        if (env->macsr & MACSR_OMC) {
 
686
            /* Make sure the accumulate operation overflows.  */
 
687
            if (product < 0)
 
688
                res = ~(1ll << 50);
 
689
            else
 
690
                res = 1ll << 50;
 
691
        }
 
692
    }
 
693
    env->mactmp = res;
 
694
    FORCE_RET();
 
695
}
 
696
 
 
697
OP(macmulu)
 
698
{
 
699
    uint32_t op1 = get_op(PARAM1);
 
700
    uint32_t op2 = get_op(PARAM2);
 
701
    uint64_t product;
 
702
 
 
703
    product = (uint64_t)op1 * op2;
 
704
    if (product & (0xffffffull << 40)) {
 
705
        env->macsr |= MACSR_V;
 
706
        if (env->macsr & MACSR_OMC) {
 
707
            /* Make sure the accumulate operation overflows.  */
 
708
            product = 1ll << 50;
 
709
        } else {
 
710
            product &= ((1ull << 40) - 1);
 
711
        }
 
712
    }
 
713
    env->mactmp = product;
 
714
    FORCE_RET();
 
715
}
 
716
 
 
717
OP(macmulf)
 
718
{
 
719
    int32_t op1 = get_op(PARAM1);
 
720
    int32_t op2 = get_op(PARAM2);
 
721
    uint64_t product;
 
722
    uint32_t remainder;
 
723
 
 
724
    product = (uint64_t)op1 * op2;
 
725
    if (env->macsr & MACSR_RT) {
 
726
        remainder = product & 0xffffff;
 
727
        product >>= 24;
 
728
        if (remainder > 0x800000)
 
729
            product++;
 
730
        else if (remainder == 0x800000)
 
731
            product += (product & 1);
 
732
    } else {
 
733
        product >>= 24;
 
734
    }
 
735
    env->mactmp = product;
 
736
    FORCE_RET();
 
737
}
 
738
 
 
739
OP(macshl)
 
740
{
 
741
    env->mactmp <<= 1;
 
742
}
 
743
 
 
744
OP(macshr)
 
745
{
 
746
    env->mactmp >>= 1;
 
747
}
 
748
 
 
749
OP(macadd)
 
750
{
 
751
    int acc = PARAM1;
 
752
    env->macc[acc] += env->mactmp;
 
753
    FORCE_RET();
 
754
}
 
755
 
 
756
OP(macsub)
 
757
{
 
758
    int acc = PARAM1;
 
759
    env->macc[acc] -= env->mactmp;
 
760
    FORCE_RET();
 
761
}
 
762
 
 
763
OP(macsats)
 
764
{
 
765
    int acc = PARAM1;
 
766
    int64_t sum;
 
767
    int64_t result;
 
768
 
 
769
    sum = env->macc[acc];
 
770
    result = (sum << 16) >> 16;
 
771
    if (result != sum) {
 
772
        env->macsr |= MACSR_V;
 
773
    }
 
774
    if (env->macsr & MACSR_V) {
 
775
        env->macsr |= MACSR_PAV0 << acc;
 
776
        if (env->macsr & MACSR_OMC) {
 
777
            /* The result is saturated to 32 bits, despite overflow occuring
 
778
               at 48 bits.  Seems weird, but that's what the hardware docs
 
779
               say.  */
 
780
            result = (result >> 63) ^ 0x7fffffff;
 
781
        }
 
782
    }
 
783
    env->macc[acc] = result;
 
784
    FORCE_RET();
 
785
}
 
786
 
 
787
OP(macsatu)
 
788
{
 
789
    int acc = PARAM1;
 
790
    uint64_t sum;
 
791
 
 
792
    sum = env->macc[acc];
 
793
    if (sum & (0xffffull << 48)) {
 
794
        env->macsr |= MACSR_V;
 
795
    }
 
796
    if (env->macsr & MACSR_V) {
 
797
        env->macsr |= MACSR_PAV0 << acc;
 
798
        if (env->macsr & MACSR_OMC) {
 
799
            if (sum > (1ull << 53))
 
800
                sum = 0;
 
801
            else
 
802
                sum = (1ull << 48) - 1;
 
803
        } else {
 
804
            sum &= ((1ull << 48) - 1);
 
805
        }
 
806
    }
 
807
    FORCE_RET();
 
808
}
 
809
 
 
810
OP(macsatf)
 
811
{
 
812
    int acc = PARAM1;
 
813
    int64_t sum;
 
814
    int64_t result;
 
815
 
 
816
    sum = env->macc[acc];
 
817
    result = (sum << 16) >> 16;
 
818
    if (result != sum) {
 
819
        env->macsr |= MACSR_V;
 
820
    }
 
821
    if (env->macsr & MACSR_V) {
 
822
        env->macsr |= MACSR_PAV0 << acc;
 
823
        if (env->macsr & MACSR_OMC) {
 
824
            result = (result >> 63) ^ 0x7fffffffffffll;
 
825
        }
 
826
    }
 
827
    env->macc[acc] = result;
 
828
    FORCE_RET();
 
829
}
 
830
 
 
831
OP(mac_clear_flags)
 
832
{
 
833
    env->macsr &= ~(MACSR_V | MACSR_Z | MACSR_N | MACSR_EV);
 
834
}
 
835
 
 
836
OP(mac_set_flags)
 
837
{
 
838
    int acc = PARAM1;
 
839
    uint64_t val;
 
840
    val = env->macc[acc];
 
841
    if (val == 0)
 
842
        env->macsr |= MACSR_Z;
 
843
    else if (val & (1ull << 47));
 
844
        env->macsr |= MACSR_N;
 
845
    if (env->macsr & (MACSR_PAV0 << acc)) {
 
846
        env->macsr |= MACSR_V;
 
847
    }
 
848
    if (env->macsr & MACSR_FI) {
 
849
        val = ((int64_t)val) >> 40;
 
850
        if (val != 0 && val != -1)
 
851
            env->macsr |= MACSR_EV;
 
852
    } else if (env->macsr & MACSR_SU) {
 
853
        val = ((int64_t)val) >> 32;
 
854
        if (val != 0 && val != -1)
 
855
            env->macsr |= MACSR_EV;
 
856
    } else {
 
857
        if ((val >> 32) != 0)
 
858
            env->macsr |= MACSR_EV;
 
859
    }
 
860
    FORCE_RET();
 
861
}
 
862
 
 
863
OP(get_macf)
 
864
{
 
865
    int acc = PARAM2;
 
866
    int64_t val;
 
867
    int rem;
 
868
    uint32_t result;
 
869
 
 
870
    val = env->macc[acc];
 
871
    if (env->macsr & MACSR_SU) {
 
872
        /* 16-bit rounding.  */
 
873
        rem = val & 0xffffff;
 
874
        val = (val >> 24) & 0xffffu;
 
875
        if (rem > 0x800000)
 
876
            val++;
 
877
        else if (rem == 0x800000)
 
878
            val += (val & 1);
 
879
    } else if (env->macsr & MACSR_RT) {
 
880
        /* 32-bit rounding.  */
 
881
        rem = val & 0xff;
 
882
        val >>= 8;
 
883
        if (rem > 0x80)
 
884
            val++;
 
885
        else if (rem == 0x80)
 
886
            val += (val & 1);
 
887
    } else {
 
888
        /* No rounding.  */
 
889
        val >>= 8;
 
890
    }
 
891
    if (env->macsr & MACSR_OMC) {
 
892
        /* Saturate.  */
 
893
        if (env->macsr & MACSR_SU) {
 
894
            if (val != (uint16_t) val) {
 
895
                result = ((val >> 63) ^ 0x7fff) & 0xffff;
 
896
            } else {
 
897
                result = val & 0xffff;
 
898
            }
 
899
        } else {
 
900
            if (val != (uint32_t)val) {
 
901
                result = ((uint32_t)(val >> 63) & 0x7fffffff);
 
902
            } else {
 
903
                result = (uint32_t)val;
 
904
            }
 
905
        }
 
906
    } else {
 
907
        /* No saturation.  */
 
908
        if (env->macsr & MACSR_SU) {
 
909
            result = val & 0xffff;
 
910
        } else {
 
911
            result = (uint32_t)val;
 
912
        }
 
913
    }
 
914
    set_op(PARAM1, result);
 
915
    FORCE_RET();
 
916
}
 
917
 
 
918
OP(get_maci)
 
919
{
 
920
    int acc = PARAM2;
 
921
    set_op(PARAM1, (uint32_t)env->macc[acc]);
 
922
    FORCE_RET();
 
923
}
 
924
 
 
925
OP(get_macs)
 
926
{
 
927
    int acc = PARAM2;
 
928
    int64_t val = env->macc[acc];
 
929
    uint32_t result;
 
930
    if (val == (int32_t)val) {
 
931
        result = (int32_t)val;
 
932
    } else {
 
933
        result = (val >> 61) ^ 0x7fffffff;
 
934
    }
 
935
    set_op(PARAM1, result);
 
936
    FORCE_RET();
 
937
}
 
938
 
 
939
OP(get_macu)
 
940
{
 
941
    int acc = PARAM2;
 
942
    uint64_t val = env->macc[acc];
 
943
    uint32_t result;
 
944
    if ((val >> 32) == 0) {
 
945
        result = (uint32_t)val;
 
946
    } else {
 
947
        result = 0xffffffffu;
 
948
    }
 
949
    set_op(PARAM1, result);
 
950
    FORCE_RET();
 
951
}
 
952
 
 
953
OP(clear_mac)
 
954
{
 
955
    int acc = PARAM1;
 
956
 
 
957
    env->macc[acc] = 0;
 
958
    env->macsr &= ~(MACSR_PAV0 << acc);
 
959
    FORCE_RET();
 
960
}
 
961
 
 
962
OP(move_mac)
 
963
{
 
964
    int dest = PARAM1;
 
965
    int src = PARAM2;
 
966
    uint32_t mask;
 
967
    env->macc[dest] = env->macc[src];
 
968
    mask = MACSR_PAV0 << dest;
 
969
    if (env->macsr & (MACSR_PAV0 << src))
 
970
        env->macsr |= mask;
 
971
    else
 
972
        env->macsr &= ~mask;
 
973
    FORCE_RET();
 
974
}
 
975
 
 
976
OP(get_mac_extf)
 
977
{
 
978
    uint32_t val;
 
979
    int acc = PARAM2;
 
980
    val = env->macc[acc] & 0x00ff;
 
981
    val = (env->macc[acc] >> 32) & 0xff00;
 
982
    val |= (env->macc[acc + 1] << 16) & 0x00ff0000;
 
983
    val |= (env->macc[acc + 1] >> 16) & 0xff000000;
 
984
    set_op(PARAM1, val);
 
985
    FORCE_RET();
 
986
}
 
987
 
 
988
OP(get_mac_exti)
 
989
{
 
990
    uint32_t val;
 
991
    int acc = PARAM2;
 
992
    val = (env->macc[acc] >> 32) & 0xffff;
 
993
    val |= (env->macc[acc + 1] >> 16) & 0xffff0000;
 
994
    set_op(PARAM1, val);
 
995
    FORCE_RET();
 
996
}
 
997
 
 
998
OP(set_macf)
 
999
{
 
1000
    int acc = PARAM2;
 
1001
    int32_t val = get_op(PARAM1);
 
1002
    env->macc[acc] = ((int64_t)val) << 8;
 
1003
    env->macsr &= ~(MACSR_PAV0 << acc);
 
1004
    FORCE_RET();
 
1005
}
 
1006
 
 
1007
OP(set_macs)
 
1008
{
 
1009
    int acc = PARAM2;
 
1010
    int32_t val = get_op(PARAM1);
 
1011
    env->macc[acc] = val;
 
1012
    env->macsr &= ~(MACSR_PAV0 << acc);
 
1013
    FORCE_RET();
 
1014
}
 
1015
 
 
1016
OP(set_macu)
 
1017
{
 
1018
    int acc = PARAM2;
 
1019
    uint32_t val = get_op(PARAM1);
 
1020
    env->macc[acc] = val;
 
1021
    env->macsr &= ~(MACSR_PAV0 << acc);
 
1022
    FORCE_RET();
 
1023
}
 
1024
 
 
1025
OP(set_mac_extf)
 
1026
{
 
1027
    int acc = PARAM2;
 
1028
    int32_t val = get_op(PARAM1);
 
1029
    int64_t res;
 
1030
    int32_t tmp;
 
1031
    res = env->macc[acc] & 0xffffffff00ull;
 
1032
    tmp = (int16_t)(val & 0xff00);
 
1033
    res |= ((int64_t)tmp) << 32;
 
1034
    res |= val & 0xff;
 
1035
    env->macc[acc] = res;
 
1036
    res = env->macc[acc + 1] & 0xffffffff00ull;
 
1037
    tmp = (val & 0xff000000);
 
1038
    res |= ((int64_t)tmp) << 16;
 
1039
    res |= (val >> 16) & 0xff;
 
1040
    env->macc[acc + 1] = res;
 
1041
}
 
1042
 
 
1043
OP(set_mac_exts)
 
1044
{
 
1045
    int acc = PARAM2;
 
1046
    int32_t val = get_op(PARAM1);
 
1047
    int64_t res;
 
1048
    int32_t tmp;
 
1049
    res = (uint32_t)env->macc[acc];
 
1050
    tmp = (int16_t)val;
 
1051
    res |= ((int64_t)tmp) << 32;
 
1052
    env->macc[acc] = res;
 
1053
    res = (uint32_t)env->macc[acc + 1];
 
1054
    tmp = val & 0xffff0000;
 
1055
    res |= (int64_t)tmp << 16;
 
1056
    env->macc[acc + 1] = res;
 
1057
}
 
1058
 
 
1059
OP(set_mac_extu)
 
1060
{
 
1061
    int acc = PARAM2;
 
1062
    int32_t val = get_op(PARAM1);
 
1063
    uint64_t res;
 
1064
    res = (uint32_t)env->macc[acc];
 
1065
    res |= ((uint64_t)(val & 0xffff)) << 32;
 
1066
    env->macc[acc] = res;
 
1067
    res = (uint32_t)env->macc[acc + 1];
 
1068
    res |= (uint64_t)(val & 0xffff0000) << 16;
 
1069
    env->macc[acc + 1] = res;
 
1070
}
 
1071
 
 
1072
OP(set_macsr)
 
1073
{
 
1074
    m68k_set_macsr(env, get_op(PARAM1));
 
1075
}