← Back to branch summary

~ubuntu-branches/debian/sid/gdb/sid

« back to all changes in this revision

Viewing changes to sim/bfin/bfin-sim.c

  • Committer: Package Import Robot
  • Author(s): Hector Oron
  • Date: 2012-01-28 00:41:20 UTC
  • mfrom: (1.4.9) (5.1.6 experimental)
  • Revision ID: package-import@ubuntu.com-20120128004120-bar1h77ark622noi
Tags: 7.4really-1
* New upstream release:
  - Many Python scripting improvements
  - Better support for ambiguous linespecs
  - Masked watchpoints
  - Tracepoint support improvements
  - Support for Texas Instruments TMS320C6x (tic6x-*-*)
  - A Renesas RL78 simulator (rl78-*-elf)
  - Some minor Remote protocol extensions and GDB/MI changes
* Temporarily disable gdb-multiarch and gdb-dbg.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sim/bfin/bfin-sim.c
1
1
/* Simulator for Analog Devices Blackfin processors.
2
2
 
3
 
   Copyright (C) 2005-2011 Free Software Foundation, Inc.
 
3
   Copyright (C) 2005-2012 Free Software Foundation, Inc.
4
4
   Contributed by Analog Devices, Inc.
5
5
 
6
6
   This file is part of simulators.
713
713
  val |= sgn;
714
714
  SET_ASTATREG (an, val >> (size - 1));
715
715
  SET_ASTATREG (az, val == 0);
716
 
  /* XXX: Need to check ASTAT[v] behavior here.  */
717
 
  SET_ASTATREG (v, 0);
 
716
  if (size != 40)
 
717
    SET_ASTATREG (v, 0);
718
718
  return val;
719
719
}
720
720
 
742
742
    }
743
743
  SET_ASTATREG (an, val >> (size - 1));
744
744
  SET_ASTATREG (az, val == 0);
745
 
  SET_ASTATREG (v, 0);
 
745
  if (size != 40)
 
746
    SET_ASTATREG (v, 0);
746
747
  return val;
747
748
}
748
749
 
1380
1381
    }
1381
1382
  val1 = val;
1382
1383
 
1383
 
  if (mmod == 0 || mmod == M_IS || mmod == M_T || mmod == M_S2RND
1384
 
      || mmod == M_ISS2 || mmod == M_IH || (MM && mmod == M_FU))
 
1384
  /* In signed modes, sign extend.  */
 
1385
  if (is_macmod_signed (mmod) || MM)
1385
1386
    val1 |= -(val1 & 0x80000000);
1386
1387
 
1387
1388
  if (*psat)
1398
1399
      *v = 1;
1399
1400
      return -((bs64)1 << 39);
1400
1401
    }
1401
 
  else if ((bs64)val >= ((bs64)1 << 39) - 1)
 
1402
  else if ((bs64)val > ((bs64)1 << 39) - 1)
1402
1403
    {
1403
1404
      *v = 1;
1404
1405
      return ((bu64)1 << 39) - 1;
1516
1517
      case M_IS:
1517
1518
        return saturate_s32 (res, overflow);
1518
1519
      case M_IU:
 
1520
        if (MM)
 
1521
          return saturate_s32 (res, overflow);
1519
1522
        return saturate_u32 (res, overflow);
1520
1523
      case M_FU:
1521
1524
        if (MM)
1532
1535
      {
1533
1536
      case 0:
1534
1537
      case M_W32:
 
1538
      case M_IH:
1535
1539
        return saturate_s16 (rnd16 (res), overflow);
1536
 
      case M_IH:
1537
 
        return saturate_s32 (rnd16 (res), overflow) & 0xFFFF;
1538
1540
      case M_IS:
1539
1541
        return saturate_s16 (res, overflow);
1540
1542
      case M_FU:
1549
1551
      case M_T:
1550
1552
        return saturate_s16 (trunc16 (res), overflow);
1551
1553
      case M_TFU:
 
1554
        if (MM)
 
1555
          return saturate_s16 (trunc16 (res), overflow);
1552
1556
        return saturate_u16 (trunc16 (res), overflow);
1553
1557
 
1554
1558
      case M_S2RND:
1569
1573
  bu32 sat = 0, tsat, ret;
1570
1574
 
1571
1575
  /* Sign extend accumulator if necessary, otherwise unsigned.  */
1572
 
  if (mmod == 0 || mmod == M_T || mmod == M_IS || mmod == M_ISS2
1573
 
      || mmod == M_S2RND || mmod == M_IH || mmod == M_W32)
 
1576
  if (is_macmod_signed (mmod) || MM)
1574
1577
    acc = get_extended_acc (cpu, which);
1575
1578
  else
1576
1579
    acc = get_unextended_acc (cpu, which);
1577
1580
 
1578
 
  if (MM && (mmod == M_T || mmod == M_IS || mmod == M_ISS2
1579
 
      || mmod == M_S2RND || mmod == M_IH || mmod == M_W32))
1580
 
    acc |= -(acc & 0x80000000);
1581
 
 
1582
1581
  if (op != 3)
1583
1582
    {
1584
1583
      bu8 sgn0 = (acc >> 31) & 1;
 
1584
      bu8 sgn40 = (acc >> 39) & 1;
 
1585
      bu40 nosat_acc;
 
1586
 
1585
1587
      /* This can't saturate, so we don't keep track of the sat flag.  */
1586
1588
      bu64 res = decode_multfunc (cpu, h0, h1, src0, src1, mmod,
1587
1589
                                  MM, &tsat);
1601
1603
          break;
1602
1604
        }
1603
1605
 
 
1606
      nosat_acc = acc;
1604
1607
      /* Saturate.  */
1605
1608
      switch (mmod)
1606
1609
        {
1615
1618
            acc = 0x7fffffffffull, sat = 1;
1616
1619
          break;
1617
1620
        case M_TFU:
 
1621
          if (MM)
 
1622
            {
 
1623
              if ((bs64)acc < -((bs64)1 << 39))
 
1624
                acc = -((bu64)1 << 39), sat = 1;
 
1625
              if ((bs64)acc > 0x7FFFFFFFFFll)
 
1626
                acc = 0x7FFFFFFFFFull, sat = 1;
 
1627
            }
 
1628
          else
 
1629
            {
 
1630
              if ((bs64)acc < 0)
 
1631
                acc = 0, sat = 1;
 
1632
              if ((bs64)acc > 0xFFFFFFFFFFull)
 
1633
                acc = 0xFFFFFFFFFFull, sat = 1;
 
1634
            }
 
1635
          break;
 
1636
        case M_IU:
 
1637
          if (!MM && acc & 0x8000000000000000ull)
 
1638
            acc = 0x0, sat = 1;
1618
1639
          if (!MM && acc > 0xFFFFFFFFFFull)
1619
 
            acc = 0x0, sat = 1;
1620
 
          if (MM && acc > 0xFFFFFFFF)
1621
 
            acc &= 0xFFFFFFFF;
1622
 
          break;
1623
 
        case M_IU:
1624
 
          if (acc & 0x8000000000000000ull)
1625
 
            acc = 0x0, sat = 1;
1626
 
          if (acc > 0xFFFFFFFFFFull)
1627
 
            acc &= 0xFFFFFFFFFFull, sat = 1;
1628
 
          if (MM && acc > 0xFFFFFFFF)
1629
 
            acc &= 0xFFFFFFFF;
1630
 
          if (acc & 0x80000000)
1631
 
            acc |= 0xffffffff00000000ull;
1632
 
          break;
1633
 
        case M_FU:
1634
 
          if (!MM && (bs64)acc < 0)
1635
 
            acc = 0x0, sat = 1;
1636
 
          if (MM && (bs64)acc < -((bs64)1 << 39))
1637
 
            acc = -((bu64)1 << 39), sat = 1;
1638
 
          if (!MM && (bs64)acc > (bs64)0xFFFFFFFFFFll)
1639
1640
            acc = 0xFFFFFFFFFFull, sat = 1;
1640
1641
          if (MM && acc > 0xFFFFFFFFFFull)
1641
1642
            acc &= 0xFFFFFFFFFFull;
1642
 
          if (MM && acc & 0x80000000)
1643
 
            acc |= 0xffffffff00000000ull;
 
1643
          if (acc & 0x8000000000ull)
 
1644
            acc |= 0xffffff0000000000ull;
 
1645
          break;
 
1646
        case M_FU:
 
1647
          if (MM)
 
1648
            {
 
1649
              if ((bs64)acc < -((bs64)1 << 39))
 
1650
                acc = -((bu64)1 << 39), sat = 1;
 
1651
              if ((bs64)acc > 0x7FFFFFFFFFll)
 
1652
                acc = 0x7FFFFFFFFFull, sat = 1;
 
1653
              else if (acc & 0x8000000000ull)
 
1654
                acc |= 0xffffff0000000000ull;
 
1655
            }
 
1656
          else
 
1657
            {
 
1658
              if ((bs64)acc < 0)
 
1659
                acc = 0x0, sat = 1;
 
1660
              else if ((bs64)acc > (bs64)0xFFFFFFFFFFll)
 
1661
                acc = 0xFFFFFFFFFFull, sat = 1;
 
1662
            }
1644
1663
          break;
1645
1664
        case M_IH:
1646
1665
          if ((bs64)acc < -0x80000000ll)
1647
1666
            acc = -0x80000000ull, sat = 1;
1648
 
          else if ((bs64)acc >= 0x7fffffffll)
 
1667
          else if ((bs64)acc > 0x7fffffffll)
1649
1668
            acc = 0x7fffffffull, sat = 1;
1650
1669
          break;
1651
1670
        case M_W32:
1652
 
          if (sgn0 && (sgn0 != ((acc >> 31) & 1))
1653
 
              && (((acc >> 32) & 0xFF) == 0xff))
1654
 
            acc = 0x80000000;
 
1671
          /* check max negative value */
 
1672
          if (sgn40 && ((acc >> 31) != 0x1ffffffff)
 
1673
              && ((acc >> 31) != 0x0))
 
1674
            acc = 0x80000000, sat = 1;
 
1675
          if (!sat && !sgn40 && ((acc >> 31) != 0x0)
 
1676
              && ((acc >> 31) != 0x1ffffffff))
 
1677
            acc = 0x7FFFFFFF, sat = 1;
1655
1678
          acc &= 0xffffffff;
1656
1679
          if (acc & 0x80000000)
1657
1680
            acc |= 0xffffffff00000000ull;
 
1681
          if (tsat)
 
1682
            sat = 1;
1658
1683
          break;
1659
1684
        default:
1660
1685
          illegal_instruction (cpu);
1668
1693
      STORE (ASTATREG (av[which]), sat);
1669
1694
      if (sat)
1670
1695
        STORE (ASTATREG (avs[which]), sat);
 
1696
 
 
1697
      /* Figure out the overflow bit.  */
 
1698
      if (sat)
 
1699
        {
 
1700
          if (fullword)
 
1701
            *overflow = 1;
 
1702
          else
 
1703
            ret = extract_mult (cpu, nosat_acc, mmod, MM, fullword, overflow);
 
1704
        }
1671
1705
    }
1672
1706
 
1673
1707
  ret = extract_mult (cpu, acc, mmod, MM, fullword, overflow);
2035
2069
  else
2036
2070
    {
2037
2071
      TRACE_INSN (cpu, "[--SP] = %s;", reg_name);
2038
 
      /* Can't push SP.  */
2039
 
      if (INSN_LEN == 8 || (grp == 1 && reg == 6))
 
2072
      if (INSN_LEN == 8)
2040
2073
        illegal_instruction_combination (cpu);
2041
2074
 
2042
2075
      sp -= 4;
3719
3752
  int h01  = ((iw1 >> DSP32Mac_h01_bits) & DSP32Mac_h01_mask);
3720
3753
 
3721
3754
  bu32 res = DREG (dst);
3722
 
  bu32 v_i = 0, zero = 0, n_1 = 0, n_0 = 0;
 
3755
  bu32 v_0 = 0, v_1 = 0, zero = 0, n_1 = 0, n_0 = 0;
3723
3756
 
3724
3757
  static const char * const ops[] = { "=", "+=", "-=" };
3725
3758
  char _buf[128], *buf = _buf;
3744
3777
  if (w1 == 1 || op1 != 3)
3745
3778
    {
3746
3779
      bu32 res1 = decode_macfunc (cpu, 1, op1, h01, h11, src0,
3747
 
                                  src1, mmod, MM, P, &v_i, &n_1);
 
3780
                                  src1, mmod, MM, P, &v_1, &n_1);
3748
3781
 
3749
3782
      if (w1)
3750
3783
        buf += sprintf (buf, P ? "R%i" : "R%i.H", dst + P);
3776
3809
              res = REG_H_L (res1 << 16, res);
3777
3810
            }
3778
3811
        }
 
3812
      else
 
3813
        v_1 = 0;
3779
3814
 
3780
3815
      if (w0 == 1 || op0 != 3)
3781
3816
        {
3790
3825
  if (w0 == 1 || op0 != 3)
3791
3826
    {
3792
3827
      bu32 res0 = decode_macfunc (cpu, 0, op0, h00, h10, src0,
3793
 
                                  src1, mmod, 0, P, &v_i, &n_0);
 
3828
                                  src1, mmod, 0, P, &v_0, &n_0);
3794
3829
 
3795
3830
      if (w0)
3796
3831
        buf += sprintf (buf, P ? "R%i" : "R%i.L", dst);
3822
3857
              res = REG_H_L (res, res0);
3823
3858
            }
3824
3859
        }
 
3860
      else
 
3861
        v_0 = 0;
3825
3862
    }
3826
3863
 
3827
3864
  TRACE_INSN (cpu, "%s%s;", _buf, mac_optmode (mmod, _MM));
3829
3866
  if (!P && (w0 || w1))
3830
3867
    {
3831
3868
      STORE (DREG (dst), res);
3832
 
      SET_ASTATREG (v, v_i);
3833
 
      if (v_i)
3834
 
        SET_ASTATREG (vs, v_i);
 
3869
      SET_ASTATREG (v, v_0 | v_1);
 
3870
      if (v_0 || v_1)
 
3871
        SET_ASTATREG (vs, 1);
3835
3872
    }
3836
3873
  else if (P)
3837
3874
    {
3838
 
      SET_ASTATREG (v, v_i);
3839
 
      if (v_i)
3840
 
        SET_ASTATREG (vs, v_i);
 
3875
      SET_ASTATREG (v, v_0 | v_1);
 
3876
      if (v_0 || v_1)
 
3877
        SET_ASTATREG (vs, 1);
3841
3878
    }
3842
3879
 
3843
3880
  if ((w0 == 1 && op0 == 3) || (w1 == 1 && op1 == 3))
4213
4250
               ((s0 >>  8) & 0xff) + ((s0 >>  0) & 0xff) + i) >> 2) & 0xff;
4214
4251
      tmp1 = ((((s1 >> 24) & 0xff) + ((s1 >> 16) & 0xff) +
4215
4252
               ((s0 >> 24) & 0xff) + ((s0 >> 16) & 0xff) + i) >> 2) & 0xff;
4216
 
      SET_DREG (dst0, (tmp1 << (16 + (HL * 8))) | (tmp0 << (HL * 8)));
 
4253
      STORE (DREG (dst0), (tmp1 << (16 + (HL * 8))) | (tmp0 << (HL * 8)));
 
4254
 
 
4255
      /* Implicit DISALGNEXCPT in parallel.  */
 
4256
      DIS_ALGN_EXPT |= 1;
4217
4257
    }
4218
4258
  else if ((aop == 0 || aop == 1) && s == 0 && aopcde == 8)
4219
4259
    {
4328
4368
 
4329
4369
      tmp0 = (bs32)(bs16)(s0 >>  0) + ((s1 >> ( 0 + (8 * !HL))) & 0xff);
4330
4370
      tmp1 = (bs32)(bs16)(s0 >> 16) + ((s1 >> (16 + (8 * !HL))) & 0xff);
4331
 
      SET_DREG (dst0, (CLAMP (tmp0, 0, 255) << ( 0 + (8 * HL))) |
4332
 
                      (CLAMP (tmp1, 0, 255) << (16 + (8 * HL))));
 
4371
      STORE (DREG (dst0), (CLAMP (tmp0, 0, 255) << ( 0 + (8 * HL))) |
 
4372
                          (CLAMP (tmp1, 0, 255) << (16 + (8 * HL))));
 
4373
 
 
4374
      /* Implicit DISALGNEXCPT in parallel.  */
 
4375
      DIS_ALGN_EXPT |= 1;
4333
4376
    }
4334
4377
  else if ((aop == 0 || aop == 1) && aopcde == 16)
4335
4378
    {
4779
4822
      STORE (AXREG (0), 0);
4780
4823
      STORE (AWREG (1), (s1H << 16) | (s1L & 0xFFFF));
4781
4824
      STORE (AXREG (1), 0);
 
4825
 
 
4826
      /* Implicit DISALGNEXCPT in parallel.  */
 
4827
      DIS_ALGN_EXPT |= 1;
4782
4828
    }
4783
4829
  else if (aop == 3 && aopcde == 18)
4784
4830
    {
4808
4854
          s1 = algn (s1L, s1H, IREG (1) & 3);
4809
4855
        }
4810
4856
 
4811
 
      SET_DREG (dst0,
 
4857
      STORE (DREG (dst0),
4812
4858
                (((((s0 >>  0) & 0xff) + ((s1 >>  0) & 0xff) + !aop) >> 1) <<  0) |
4813
4859
                (((((s0 >>  8) & 0xff) + ((s1 >>  8) & 0xff) + !aop) >> 1) <<  8) |
4814
4860
                (((((s0 >> 16) & 0xff) + ((s1 >> 16) & 0xff) + !aop) >> 1) << 16) |
4815
4861
                (((((s0 >> 24) & 0xff) + ((s1 >> 24) & 0xff) + !aop) >> 1) << 24));
 
4862
 
 
4863
      /* Implicit DISALGNEXCPT in parallel.  */
 
4864
      DIS_ALGN_EXPT |= 1;
4816
4865
    }
4817
4866
  else if (aop == 0 && aopcde == 21)
4818
4867
    {
4839
4888
          s1 = algn (s1L, s1H, IREG (1) & 3);
4840
4889
        }
4841
4890
 
4842
 
      SET_DREG (dst0,
 
4891
      STORE (DREG (dst0),
4843
4892
                ((((s0 >>  0) & 0xff) + ((s1 >>  0) & 0xff)) <<  0) |
4844
4893
                ((((s0 >>  8) & 0xff) + ((s1 >>  8) & 0xff)) << 16));
4845
 
      SET_DREG (dst1,
 
4894
      STORE (DREG (dst1),
4846
4895
                ((((s0 >> 16) & 0xff) + ((s1 >> 16) & 0xff)) <<  0) |
4847
4896
                ((((s0 >> 24) & 0xff) + ((s1 >> 24) & 0xff)) << 16));
 
4897
 
 
4898
      /* Implicit DISALGNEXCPT in parallel.  */
 
4899
      DIS_ALGN_EXPT |= 1;
4848
4900
    }
4849
4901
  else if (aop == 1 && aopcde == 21)
4850
4902
    {
4871
4923
          s1 = algn (s1L, s1H, IREG (1) & 3);
4872
4924
        }
4873
4925
 
4874
 
      SET_DREG (dst0,
 
4926
      STORE (DREG (dst0),
4875
4927
                (((((s0 >>  0) & 0xff) - ((s1 >>  0) & 0xff)) <<  0) & 0xffff) |
4876
4928
                (((((s0 >>  8) & 0xff) - ((s1 >>  8) & 0xff)) << 16)));
4877
 
      SET_DREG (dst1,
 
4929
      STORE (DREG (dst1),
4878
4930
                (((((s0 >> 16) & 0xff) - ((s1 >> 16) & 0xff)) <<  0) & 0xffff) |
4879
4931
                (((((s0 >> 24) & 0xff) - ((s1 >> 24) & 0xff)) << 16)));
 
4932
 
 
4933
      /* Implicit DISALGNEXCPT in parallel.  */
 
4934
      DIS_ALGN_EXPT |= 1;
4880
4935
    }
4881
4936
  else if (aop == 1 && aopcde == 7)
4882
4937
    {
4968
5023
  else if (aop == 0 && aopcde == 24)
4969
5024
    {
4970
5025
      TRACE_INSN (cpu, "R%i = BYTEPACK (R%i, R%i);", dst0, src0, src1);
4971
 
      SET_DREG (dst0,
 
5026
      STORE (DREG (dst0),
4972
5027
        (((DREG (src0) >>  0) & 0xff) <<  0) |
4973
5028
        (((DREG (src0) >> 16) & 0xff) <<  8) |
4974
5029
        (((DREG (src1) >>  0) & 0xff) << 16) |
4975
5030
        (((DREG (src1) >> 16) & 0xff) << 24));
 
5031
 
 
5032
      /* Implicit DISALGNEXCPT in parallel.  */
 
5033
      DIS_ALGN_EXPT |= 1;
4976
5034
    }
4977
5035
  else if (aop == 1 && aopcde == 24)
4978
5036
    {
4996
5054
      byteb = (comb_src >> (8 + 8 * order));
4997
5055
      bytec = (comb_src >> (16 + 8 * order));
4998
5056
      byted = (comb_src >> (24 + 8 * order));
4999
 
      SET_DREG (dst0, bytea | ((bu32)byteb << 16));
5000
 
      SET_DREG (dst1, bytec | ((bu32)byted << 16));
 
5057
      STORE (DREG (dst0), bytea | ((bu32)byteb << 16));
 
5058
      STORE (DREG (dst1), bytec | ((bu32)byted << 16));
 
5059
 
 
5060
      /* Implicit DISALGNEXCPT in parallel.  */
 
5061
      DIS_ALGN_EXPT |= 1;
5001
5062
    }
5002
5063
  else if (aopcde == 13)
5003
5064
    {
5162
5223
 
5163
5224
      STORE (AXREG (HLs), (val >> 32) & 0xff);
5164
5225
      STORE (AWREG (HLs), (val & 0xffffffff));
 
5226
      STORE (ASTATREG (av[HLs]), val == 0);
 
5227
      if (val == 0)
 
5228
        STORE (ASTATREG (avs[HLs]), 1);
5165
5229
    }
5166
5230
  else if (sop == 1 && sopcde == 3 && (HLs == 0 || HLs == 1))
5167
5231
    {
5170
5234
 
5171
5235
      HLs = !!HLs;
5172
5236
      TRACE_INSN (cpu, "A%i = LSHIFT A%i BY R%i.L;", HLs, HLs, src0);
5173
 
      val = get_extended_acc (cpu, HLs);
 
5237
      val = get_unextended_acc (cpu, HLs);
5174
5238
 
5175
5239
      if (shft <= 0)
5176
5240
        val = lshiftrt (cpu, val, -shft, 40);
5179
5243
 
5180
5244
      STORE (AXREG (HLs), (val >> 32) & 0xff);
5181
5245
      STORE (AWREG (HLs), (val & 0xffffffff));
 
5246
      STORE (ASTATREG (av[HLs]), val == 0);
 
5247
      if (val == 0)
 
5248
        STORE (ASTATREG (avs[HLs]), 1);
5182
5249
    }
5183
5250
  else if ((sop == 0 || sop == 1) && sopcde == 1)
5184
5251
    {
5281
5348
        sv0 >>= 16;
5282
5349
      if (sop & 2)
5283
5350
        sv1 >>= 16;
5284
 
      SET_DREG (dst0, (sv1 << 16) | (sv0 & 0xFFFF));
 
5351
      STORE (DREG (dst0), (sv1 << 16) | (sv0 & 0xFFFF));
5285
5352
    }
5286
5353
  else if (sop == 0 && sopcde == 5)
5287
5354
    {
5399
5466
      acc = (acc >> 2) |
5400
5467
        (((bu64)s0 & 1) << 38) |
5401
5468
        (((bu64)s1 & 1) << 39);
5402
 
      SET_DREG (src0, s0 >> 1);
5403
 
      SET_DREG (src1, s1 >> 1);
 
5469
      STORE (DREG (src0), s0 >> 1);
 
5470
      STORE (DREG (src1), s1 >> 1);
5404
5471
 
5405
5472
      SET_AREG (0, acc);
5406
5473
    }
5419
5486
      acc = (acc << 2) |
5420
5487
        ((s0 >> 31) & 1) |
5421
5488
        ((s1 >> 30) & 2);
5422
 
      SET_DREG (src0, s0 << 1);
5423
 
      SET_DREG (src1, s1 << 1);
 
5489
      STORE (DREG (src0), s0 << 1);
 
5490
      STORE (DREG (src1), s1 << 1);
5424
5491
 
5425
5492
      SET_AREG (0, acc);
5426
5493
    }
5449
5516
        out = sL;
5450
5517
 
5451
5518
      SET_AREG (0, acc0);
5452
 
      SET_DREG (dst0, REG_H_L (DREG (dst0), out));
 
5519
      STORE (DREG (dst0), REG_H_L (DREG (dst0), out));
5453
5520
    }
5454
5521
  else if ((sop == 2 || sop == 3) && sopcde == 9)
5455
5522
    {
5486
5553
        out1 = s1L;
5487
5554
 
5488
5555
      SET_AREG (0, acc0);
5489
 
      SET_DREG (dst0, REG_H_L (out1 << 16, out0));
 
5556
      STORE (DREG (dst0), REG_H_L (out1 << 16, out0));
5490
5557
    }
5491
5558
  else if (sop == 0 && sopcde == 10)
5492
5559
    {
5493
5560
      bu32 v = DREG (src0);
5494
5561
      bu32 x = DREG (src1);
5495
5562
      bu32 mask = (1 << (v & 0x1f)) - 1;
 
5563
 
5496
5564
      TRACE_INSN (cpu, "R%i = EXTRACT (R%i, R%i.L) (Z);", dst0, src1, src0);
 
5565
 
5497
5566
      x >>= ((v >> 8) & 0x1f);
5498
 
      SET_DREG (dst0, x & mask);
5499
 
      setflags_logical (cpu, DREG (dst0));
 
5567
      x &= mask;
 
5568
      STORE (DREG (dst0), x);
 
5569
      setflags_logical (cpu, x);
5500
5570
    }
5501
5571
  else if (sop == 1 && sopcde == 10)
5502
5572
    {
5504
5574
      bu32 x = DREG (src1);
5505
5575
      bu32 sgn = (1 << (v & 0x1f)) >> 1;
5506
5576
      bu32 mask = (1 << (v & 0x1f)) - 1;
 
5577
 
5507
5578
      TRACE_INSN (cpu, "R%i = EXTRACT (R%i, R%i.L) (X);", dst0, src1, src0);
 
5579
 
5508
5580
      x >>= ((v >> 8) & 0x1f);
5509
5581
      x &= mask;
5510
5582
      if (x & sgn)
5511
5583
        x |= ~mask;
5512
 
      SET_DREG (dst0, x);
5513
 
      setflags_logical (cpu, DREG (dst0));
 
5584
      STORE (DREG (dst0), x);
 
5585
      setflags_logical (cpu, x);
5514
5586
    }
5515
5587
  else if ((sop == 2 || sop == 3) && sopcde == 10)
5516
5588
    {
5541
5613
      mask <<= shft;
5542
5614
      bg &= ~mask;
5543
5615
 
5544
 
      SET_DREG (dst0, bg | fgnd);
5545
 
      setflags_logical (cpu, DREG (dst0));
 
5616
      bg |= fgnd;
 
5617
      STORE (DREG (dst0), bg);
 
5618
      setflags_logical (cpu, bg);
5546
5619
    }
5547
5620
  else if (sop == 0 && sopcde == 11)
5548
5621
    {
5589
5662
    {
5590
5663
      int shift = (sop + 1) * 8;
5591
5664
      TRACE_INSN (cpu, "R%i = ALIGN%i (R%i, R%i);", dst0, shift, src1, src0);
5592
 
      SET_DREG (dst0, (DREG (src1) << (32 - shift)) | (DREG (src0) >> shift));
 
5665
      STORE (DREG (dst0), (DREG (src1) << (32 - shift)) | (DREG (src0) >> shift));
5593
5666
    }
5594
5667
  else
5595
5668
    illegal_instruction (cpu);
5628
5701
          TRACE_INSN (cpu, "R%i.%c = R%i.%c >>> %i;",
5629
5702
                      dst0, (HLs & 2) ? 'H' : 'L',
5630
5703
                      src1, (HLs & 1) ? 'H' : 'L', newimmag);
5631
 
          result = ashiftrt (cpu, in, newimmag, 16);
 
5704
          if (newimmag > 16)
 
5705
            result = lshift (cpu, in, 16 - (newimmag & 0xF), 16, 0);
 
5706
          else
 
5707
            result = ashiftrt (cpu, in, newimmag, 16);
5632
5708
        }
5633
5709
      else if (sop == 1 && bit8 == 0)
5634
5710
        {
5722
5798
      if (sop == 0)
5723
5799
        acc <<= shiftup;
5724
5800
      else
5725
 
        acc >>= shiftdn;
 
5801
        {
 
5802
          if (shiftdn <= 32)
 
5803
            acc >>= shiftdn;
 
5804
          else
 
5805
            acc <<= 32 - (shiftdn & 0x1f);
 
5806
        }
5726
5807
 
5727
5808
      SET_AREG (HLs, acc);
 
5809
      SET_ASTATREG (av[HLs], 0);
5728
5810
      SET_ASTATREG (an, !!(acc & 0x8000000000ull));
5729
 
      SET_ASTATREG (az, acc == 0);
 
5811
      SET_ASTATREG (az, (acc & 0xFFFFFFFFFF) == 0);
5730
5812
    }
5731
5813
  else if (sop == 1 && sopcde == 1 && bit8 == 0)
5732
5814
    {
5736
5818
      bu32 astat;
5737
5819
 
5738
5820
      TRACE_INSN (cpu, "R%i = R%i << %i (V,S);", dst0, src1, count);
5739
 
      val0 = lshift (cpu, val0, count, 16, 1);
5740
 
      astat = ASTAT;
5741
 
      val1 = lshift (cpu, val1, count, 16, 1);
 
5821
      if (count >= 0)
 
5822
        {
 
5823
          val0 = lshift (cpu, val0, count, 16, 1);
 
5824
          astat = ASTAT;
 
5825
          val1 = lshift (cpu, val1, count, 16, 1);
 
5826
        }
 
5827
      else
 
5828
        {
 
5829
          val0 = ashiftrt (cpu, val0, -count, 16);
 
5830
          astat = ASTAT;
 
5831
          val1 = ashiftrt (cpu, val1, -count, 16);
 
5832
        }
5742
5833
      SET_ASTAT (ASTAT | astat);
5743
5834
 
5744
5835
      STORE (DREG (dst0), (val0 << 16) | val1);
5783
5874
      TRACE_INSN (cpu, "R%i = R%i >>> %i %s;", dst0, src1, count,
5784
5875
                  sop == 0 ? "(V)" : "(V,S)");
5785
5876
 
5786
 
      val0 = ashiftrt (cpu, val0, count, 16);
5787
 
      astat = ASTAT;
5788
 
      val1 = ashiftrt (cpu, val1, count, 16);
 
5877
      if (count & 0x10)
 
5878
        {
 
5879
          val0 = lshift (cpu, val0, 16 - (count & 0xF), 16, 0);
 
5880
          astat = ASTAT;
 
5881
          val1 = lshift (cpu, val1, 16 - (count & 0xF), 16, 0);
 
5882
        }
 
5883
      else
 
5884
        {
 
5885
          val0 = ashiftrt (cpu, val0, count, 16);
 
5886
          astat = ASTAT;
 
5887
          val1 = ashiftrt (cpu, val1, count, 16);
 
5888
        }
 
5889
 
5789
5890
      SET_ASTAT (ASTAT | astat);
5790
5891
 
5791
5892
      STORE (DREG (dst0), REG_H_L (val1 << 16, val0));