Revision 3cc62370 target-ppc/op.c

b/target-ppc/op.c
697 697
PPC_OP(divw)
698 698
{
699 699
    if ((Ts0 == INT32_MIN && Ts1 == -1) || Ts1 == 0) {
700
        Ts0 = (-1) * (T0 >> 31);
700
        T0 = (int32_t)((-1) * (T0 >> 31));
701 701
    } else {
702
        Ts0 /= Ts1;
702
        T0 = (Ts0 / Ts1);
703 703
    }
704 704
    RETURN();
705 705
}
......
712 712
        T0 = (-1) * (T0 >> 31);
713 713
    } else {
714 714
        xer_ov = 0;
715
        Ts0 /= Ts1;
715
        T0 = (Ts0 / Ts1);
716 716
    }
717 717
    RETURN();
718 718
}
......
744 744
/* multiply high word */
745 745
PPC_OP(mulhw)
746 746
{
747
    Ts0 = ((int64_t)Ts0 * (int64_t)Ts1) >> 32;
747
    T0 = ((int64_t)Ts0 * (int64_t)Ts1) >> 32;
748 748
    RETURN();
749 749
}
750 750

  
......
758 758
/* multiply low immediate */
759 759
PPC_OP(mulli)
760 760
{
761
    Ts0 *= SPARAM(1);
761
    T0 = (Ts0 * SPARAM(1));
762 762
    RETURN();
763 763
}
764 764

  
......
779 779
    } else {
780 780
        xer_ov = 0;
781 781
    }
782
    Ts0 = res;
782
    T0 = (int32_t)res;
783 783
    RETURN();
784 784
}
785 785

  
......
787 787
PPC_OP(neg)
788 788
{
789 789
    if (T0 != 0x80000000) {
790
        Ts0 = -Ts0;
790
        T0 = -Ts0;
791 791
    }
792 792
    RETURN();
793 793
}
......
799 799
        xer_so = 1;
800 800
    } else {
801 801
        xer_ov = 0;
802
        Ts0 = -Ts0;
802
        T0 = -Ts0;
803 803
    }
804 804
    RETURN();
805 805
}
......
1047 1047
/* extend sign byte */
1048 1048
PPC_OP(extsb)
1049 1049
{
1050
    Ts0 = (int8_t)(Ts0);
1050
    T0 = (int32_t)((int8_t)(Ts0));
1051 1051
    RETURN();
1052 1052
}
1053 1053

  
1054 1054
/* extend sign half word */
1055 1055
PPC_OP(extsh)
1056 1056
{
1057
    Ts0 = (int16_t)(Ts0);
1057
    T0 = (int32_t)((int16_t)(Ts0));
1058 1058
    RETURN();
1059 1059
}
1060 1060

  
......
1175 1175
/* shift right algebraic word immediate */
1176 1176
PPC_OP(srawi)
1177 1177
{
1178
    Ts1 = Ts0;
1179
    Ts0 = Ts0 >> PARAM(1);
1178
    T1 = T0;
1179
    T0 = (Ts0 >> PARAM(1));
1180 1180
    if (Ts1 < 0 && (Ts1 & PARAM(2)) != 0) {
1181 1181
        xer_ca = 1;
1182 1182
    } else {
......
1207 1207
/* fadds - fadds. */
1208 1208
PPC_OP(fadds)
1209 1209
{
1210
    FTS0 += FTS1;
1210
    FT0 = FTS0 + FTS1;
1211 1211
    RETURN();
1212 1212
}
1213 1213

  
......
1221 1221
/* fsubs - fsubs. */
1222 1222
PPC_OP(fsubs)
1223 1223
{
1224
    FTS0 -= FTS1;
1224
    FT0 = FTS0 - FTS1;
1225 1225
    RETURN();
1226 1226
}
1227 1227

  
......
1235 1235
/* fmuls - fmuls. */
1236 1236
PPC_OP(fmuls)
1237 1237
{
1238
    FTS0 *= FTS1;
1238
    FT0 = FTS0 * FTS1;
1239 1239
    RETURN();
1240 1240
}
1241 1241

  
......
1249 1249
/* fdivs - fdivs. */
1250 1250
PPC_OP(fdivs)
1251 1251
{
1252
    FTS0 /= FTS1;
1252
    FT0 = FTS0 / FTS1;
1253 1253
    RETURN();
1254 1254
}
1255 1255

  
......
1299 1299
/* fmadds - fmadds. */
1300 1300
PPC_OP(fmadds)
1301 1301
{
1302
    FTS0 = (FTS0 * FTS1) + FTS2;
1302
    FT0 = (FTS0 * FTS1) + FTS2;
1303 1303
    RETURN();
1304 1304
}
1305 1305

  
......
1313 1313
/* fmsubs - fmsubs. */
1314 1314
PPC_OP(fmsubs)
1315 1315
{
1316
    FTS0 = (FTS0 * FTS1) - FTS2;
1316
    FT0 = (FTS0 * FTS1) - FTS2;
1317 1317
    RETURN();
1318 1318
}
1319 1319

  
......
1349 1349
/* frsp - frsp. */
1350 1350
PPC_OP(frsp)
1351 1351
{
1352
    FTS0 = FT0;
1352
    FT0 = (float)FT0;
1353 1353
    RETURN();
1354 1354
}
1355 1355

  

Also available in: Unified diff