gwj / at91sam9263 · Commits

Commit fb48f71b3dc1d7eff8bea99e1e4c2f352362ca9f

Authored by edgar_igl
1 parent 8137cde8

CRIS: Avoid more cpu_T usage. 

* Explicit operand passing to prep_alu_r.
* Avoid some more cpu_T[] usage.

Signed-off-by: Edgar E. Iglesias <edgar.iglesias@gmail.com>


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@5550 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 175 additions and 95 deletions
target-cris/translate.c
  View file @fb48f71
... ... @@ -1342,14 +1342,14 @@ static inline void dec_prep_move_r(DisasContext *dc, int rs, int rd,
1342 1342 s_ext decides if the operand1 should be sign-extended or zero-extended when
1343 1343 needed. */
1344 1344 static void dec_prep_alu_r(DisasContext *dc, int rs, int rd,
1345   - int size, int s_ext)
  1345 + int size, int s_ext, TCGv dst, TCGv src)
1346 1346 {
1347   - dec_prep_move_r(dc, rs, rd, size, s_ext, cpu_T[1]);
  1347 + dec_prep_move_r(dc, rs, rd, size, s_ext, src);
1348 1348  
1349 1349 if (s_ext)
1350   - t_gen_sext(cpu_T[0], cpu_R[rd], size);
  1350 + t_gen_sext(dst, cpu_R[rd], size);
1351 1351 else
1352   - t_gen_zext(cpu_T[0], cpu_R[rd], size);
  1352 + t_gen_zext(dst, cpu_R[rd], size);
1353 1353 }
1354 1354  
1355 1355 static int dec_prep_move_m(DisasContext *dc, int s_ext, int memsize,
... ... @@ -1459,6 +1459,7 @@ static unsigned int dec_addoq(DisasContext *dc)
1459 1459 cris_cc_mask(dc, 0);
1460 1460 /* Fetch register operand, */
1461 1461 tcg_gen_addi_tl(cpu_R[R_ACR], cpu_R[dc->op2], imm);
  1462 +
1462 1463 return 2;
1463 1464 }
1464 1465 static unsigned int dec_addq(DisasContext *dc)
... ... @@ -1639,102 +1640,135 @@ static unsigned int dec_scc_r(DisasContext *dc)
1639 1640 return 2;
1640 1641 }
1641 1642  
  1643 +static inline void cris_alu_alloc_temps(DisasContext *dc, int size, TCGv *t)
  1644 +{
  1645 + if (size == 4) {
  1646 + t[0] = cpu_R[dc->op2];
  1647 + t[1] = cpu_R[dc->op1];
  1648 + } else {
  1649 + t[0] = tcg_temp_new(TCG_TYPE_TL);
  1650 + t[1] = tcg_temp_new(TCG_TYPE_TL);
  1651 + }
  1652 +}
  1653 +
  1654 +static inline void cris_alu_free_temps(DisasContext *dc, int size, TCGv *t)
  1655 +{
  1656 + if (size != 4) {
  1657 + tcg_temp_free(t[0]);
  1658 + tcg_temp_free(t[1]);
  1659 + }
  1660 +}
  1661 +
1642 1662 static unsigned int dec_and_r(DisasContext *dc)
1643 1663 {
  1664 + TCGv t[2];
1644 1665 int size = memsize_zz(dc);
1645 1666  
1646 1667 DIS(fprintf (logfile, "and.%c $r%u, $r%u\n",
1647 1668 memsize_char(size), dc->op1, dc->op2));
  1669 +
1648 1670 cris_cc_mask(dc, CC_MASK_NZ);
1649   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1650 1671  
1651   - cris_alu(dc, CC_OP_AND,
1652   - cpu_R[dc->op2],
1653   - cpu_R[dc->op2], cpu_T[1], size);
  1672 + cris_alu_alloc_temps(dc, size, t);
  1673 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
  1674 + cris_alu(dc, CC_OP_AND, cpu_R[dc->op2], t[0], t[1], size);
  1675 + cris_alu_free_temps(dc, size, t);
1654 1676 return 2;
1655 1677 }
1656 1678  
1657 1679 static unsigned int dec_lz_r(DisasContext *dc)
1658 1680 {
  1681 + TCGv t0;
1659 1682 DIS(fprintf (logfile, "lz $r%u, $r%u\n",
1660 1683 dc->op1, dc->op2));
1661 1684 cris_cc_mask(dc, CC_MASK_NZ);
1662   - dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1663   - cris_alu(dc, CC_OP_LZ,
1664   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  1685 + t0 = tcg_temp_new(TCG_TYPE_TL);
  1686 + dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0, cpu_R[dc->op2], t0);
  1687 + cris_alu(dc, CC_OP_LZ, cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  1688 + tcg_temp_free(t0);
1665 1689 return 2;
1666 1690 }
1667 1691  
1668 1692 static unsigned int dec_lsl_r(DisasContext *dc)
1669 1693 {
  1694 + TCGv t[2];
1670 1695 int size = memsize_zz(dc);
1671 1696  
1672 1697 DIS(fprintf (logfile, "lsl.%c $r%u, $r%u\n",
1673 1698 memsize_char(size), dc->op1, dc->op2));
1674   - cris_cc_mask(dc, CC_MASK_NZ);
1675   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1676   - tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1677 1699  
1678   - cris_alu(dc, CC_OP_LSL,
1679   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1700 + cris_cc_mask(dc, CC_MASK_NZ);
  1701 + cris_alu_alloc_temps(dc, size, t);
  1702 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
  1703 + tcg_gen_andi_tl(t[1], t[1], 63);
  1704 + cris_alu(dc, CC_OP_LSL, cpu_R[dc->op2], t[0], t[1], size);
  1705 + cris_alu_alloc_temps(dc, size, t);
1680 1706 return 2;
1681 1707 }
1682 1708  
1683 1709 static unsigned int dec_lsr_r(DisasContext *dc)
1684 1710 {
  1711 + TCGv t[2];
1685 1712 int size = memsize_zz(dc);
1686 1713  
1687 1714 DIS(fprintf (logfile, "lsr.%c $r%u, $r%u\n",
1688 1715 memsize_char(size), dc->op1, dc->op2));
1689   - cris_cc_mask(dc, CC_MASK_NZ);
1690   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1691   - tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1692 1716  
1693   - cris_alu(dc, CC_OP_LSR,
1694   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1717 + cris_cc_mask(dc, CC_MASK_NZ);
  1718 + cris_alu_alloc_temps(dc, size, t);
  1719 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
  1720 + tcg_gen_andi_tl(t[1], t[1], 63);
  1721 + cris_alu(dc, CC_OP_LSR, cpu_R[dc->op2], t[0], t[1], size);
  1722 + cris_alu_free_temps(dc, size, t);
1695 1723 return 2;
1696 1724 }
1697 1725  
1698 1726 static unsigned int dec_asr_r(DisasContext *dc)
1699 1727 {
  1728 + TCGv t[2];
1700 1729 int size = memsize_zz(dc);
1701 1730  
1702 1731 DIS(fprintf (logfile, "asr.%c $r%u, $r%u\n",
1703 1732 memsize_char(size), dc->op1, dc->op2));
1704   - cris_cc_mask(dc, CC_MASK_NZ);
1705   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1);
1706   - tcg_gen_andi_tl(cpu_T[1], cpu_T[1], 63);
1707 1733  
1708   - cris_alu(dc, CC_OP_ASR,
1709   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1734 + cris_cc_mask(dc, CC_MASK_NZ);
  1735 + cris_alu_alloc_temps(dc, size, t);
  1736 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1, t[0], t[1]);
  1737 + tcg_gen_andi_tl(t[1], t[1], 63);
  1738 + cris_alu(dc, CC_OP_ASR, cpu_R[dc->op2], t[0], t[1], size);
  1739 + cris_alu_free_temps(dc, size, t);
1710 1740 return 2;
1711 1741 }
1712 1742  
1713 1743 static unsigned int dec_muls_r(DisasContext *dc)
1714 1744 {
  1745 + TCGv t[2];
1715 1746 int size = memsize_zz(dc);
1716 1747  
1717 1748 DIS(fprintf (logfile, "muls.%c $r%u, $r%u\n",
1718 1749 memsize_char(size), dc->op1, dc->op2));
1719 1750 cris_cc_mask(dc, CC_MASK_NZV);
1720   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1);
  1751 + cris_alu_alloc_temps(dc, size, t);
  1752 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 1, t[0], t[1]);
1721 1753  
1722   - cris_alu(dc, CC_OP_MULS,
1723   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], 4);
  1754 + cris_alu(dc, CC_OP_MULS, cpu_R[dc->op2], t[0], t[1], 4);
  1755 + cris_alu_free_temps(dc, size, t);
1724 1756 return 2;
1725 1757 }
1726 1758  
1727 1759 static unsigned int dec_mulu_r(DisasContext *dc)
1728 1760 {
  1761 + TCGv t[2];
1729 1762 int size = memsize_zz(dc);
1730 1763  
1731 1764 DIS(fprintf (logfile, "mulu.%c $r%u, $r%u\n",
1732 1765 memsize_char(size), dc->op1, dc->op2));
1733 1766 cris_cc_mask(dc, CC_MASK_NZV);
1734   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
  1767 + cris_alu_alloc_temps(dc, size, t);
  1768 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
1735 1769  
1736   - cris_alu(dc, CC_OP_MULU,
1737   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], 4);
  1770 + cris_alu(dc, CC_OP_MULU, cpu_R[dc->op2], t[0], t[1], 4);
  1771 + cris_alu_alloc_temps(dc, size, t);
1738 1772 return 2;
1739 1773 }
1740 1774  
... ... @@ -1750,40 +1784,46 @@ static unsigned int dec_dstep_r(DisasContext *dc)
1750 1784  
1751 1785 static unsigned int dec_xor_r(DisasContext *dc)
1752 1786 {
  1787 + TCGv t[2];
1753 1788 int size = memsize_zz(dc);
1754 1789 DIS(fprintf (logfile, "xor.%c $r%u, $r%u\n",
1755 1790 memsize_char(size), dc->op1, dc->op2));
1756 1791 BUG_ON(size != 4); /* xor is dword. */
1757 1792 cris_cc_mask(dc, CC_MASK_NZ);
1758   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
  1793 + cris_alu_alloc_temps(dc, size, t);
  1794 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
1759 1795  
1760   - cris_alu(dc, CC_OP_XOR,
1761   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], 4);
  1796 + cris_alu(dc, CC_OP_XOR, cpu_R[dc->op2], t[0], t[1], 4);
  1797 + cris_alu_free_temps(dc, size, t);
1762 1798 return 2;
1763 1799 }
1764 1800  
1765 1801 static unsigned int dec_bound_r(DisasContext *dc)
1766 1802 {
  1803 + TCGv l0;
1767 1804 int size = memsize_zz(dc);
1768 1805 DIS(fprintf (logfile, "bound.%c $r%u, $r%u\n",
1769 1806 memsize_char(size), dc->op1, dc->op2));
1770 1807 cris_cc_mask(dc, CC_MASK_NZ);
1771   - dec_prep_move_r(dc, dc->op1, dc->op2, size, 0, cpu_T[1]);
  1808 + l0 = tcg_temp_local_new(TCG_TYPE_TL);
  1809 + dec_prep_move_r(dc, dc->op1, dc->op2, size, 0, l0);
1772 1810 cris_alu(dc, CC_OP_BOUND,
1773   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  1811 + cpu_R[dc->op2], cpu_R[dc->op2], l0, 4);
1774 1812 return 2;
1775 1813 }
1776 1814  
1777 1815 static unsigned int dec_cmp_r(DisasContext *dc)
1778 1816 {
  1817 + TCGv t[2];
1779 1818 int size = memsize_zz(dc);
1780 1819 DIS(fprintf (logfile, "cmp.%c $r%u, $r%u\n",
1781 1820 memsize_char(size), dc->op1, dc->op2));
1782 1821 cris_cc_mask(dc, CC_MASK_NZVC);
1783   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
  1822 + cris_alu_alloc_temps(dc, size, t);
  1823 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
1784 1824  
1785   - cris_alu(dc, CC_OP_CMP,
1786   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1825 + cris_alu(dc, CC_OP_CMP, cpu_R[dc->op2], t[0], t[1], size);
  1826 + cris_alu_free_temps(dc, size, t);
1787 1827 return 2;
1788 1828 }
1789 1829  
... ... @@ -1808,14 +1848,16 @@ static unsigned int dec_abs_r(DisasContext *dc)
1808 1848  
1809 1849 static unsigned int dec_add_r(DisasContext *dc)
1810 1850 {
  1851 + TCGv t[2];
1811 1852 int size = memsize_zz(dc);
1812 1853 DIS(fprintf (logfile, "add.%c $r%u, $r%u\n",
1813 1854 memsize_char(size), dc->op1, dc->op2));
1814 1855 cris_cc_mask(dc, CC_MASK_NZVC);
1815   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
  1856 + cris_alu_alloc_temps(dc, size, t);
  1857 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
1816 1858  
1817   - cris_alu(dc, CC_OP_ADD,
1818   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1859 + cris_alu(dc, CC_OP_ADD, cpu_R[dc->op2], t[0], t[1], size);
  1860 + cris_alu_free_temps(dc, size, t);
1819 1861 return 2;
1820 1862 }
1821 1863  
... ... @@ -1825,9 +1867,8 @@ static unsigned int dec_addc_r(DisasContext *dc)
1825 1867 dc->op1, dc->op2));
1826 1868 cris_evaluate_flags(dc);
1827 1869 cris_cc_mask(dc, CC_MASK_NZVC);
1828   - dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
1829 1870 cris_alu(dc, CC_OP_ADDC,
1830   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], 4);
  1871 + cpu_R[dc->op2], cpu_R[dc->op2], cpu_R[dc->op1], 4);
1831 1872 return 2;
1832 1873 }
1833 1874  
... ... @@ -1860,6 +1901,7 @@ static char * swapmode_name(int mode, char *modename) {
1860 1901  
1861 1902 static unsigned int dec_swap_r(DisasContext *dc)
1862 1903 {
  1904 + TCGv t0;
1863 1905 #if DISAS_CRIS
1864 1906 char modename[4];
1865 1907 #endif
... ... @@ -1867,64 +1909,72 @@ static unsigned int dec_swap_r(DisasContext *dc)
1867 1909 swapmode_name(dc->op2, modename), dc->op1));
1868 1910  
1869 1911 cris_cc_mask(dc, CC_MASK_NZ);
1870   - t_gen_mov_TN_reg(cpu_T[0], dc->op1);
  1912 + t0 = tcg_temp_new(TCG_TYPE_TL);
  1913 + t_gen_mov_TN_reg(t0, dc->op1);
1871 1914 if (dc->op2 & 8)
1872   - tcg_gen_not_tl(cpu_T[0], cpu_T[0]);
  1915 + tcg_gen_not_tl(t0, t0);
1873 1916 if (dc->op2 & 4)
1874   - t_gen_swapw(cpu_T[0], cpu_T[0]);
  1917 + t_gen_swapw(t0, t0);
1875 1918 if (dc->op2 & 2)
1876   - t_gen_swapb(cpu_T[0], cpu_T[0]);
  1919 + t_gen_swapb(t0, t0);
1877 1920 if (dc->op2 & 1)
1878   - t_gen_swapr(cpu_T[0], cpu_T[0]);
  1921 + t_gen_swapr(t0, t0);
1879 1922 cris_alu(dc, CC_OP_MOVE,
1880   - cpu_R[dc->op1], cpu_R[dc->op1], cpu_T[0], 4);
1881   -
  1923 + cpu_R[dc->op1], cpu_R[dc->op1], t0, 4);
1882 1924 return 2;
1883 1925 }
1884 1926  
1885 1927 static unsigned int dec_or_r(DisasContext *dc)
1886 1928 {
  1929 + TCGv t[2];
1887 1930 int size = memsize_zz(dc);
1888 1931 DIS(fprintf (logfile, "or.%c $r%u, $r%u\n",
1889 1932 memsize_char(size), dc->op1, dc->op2));
1890 1933 cris_cc_mask(dc, CC_MASK_NZ);
1891   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1892   -
1893   - cris_alu(dc, CC_OP_OR,
1894   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1934 + cris_alu_alloc_temps(dc, size, t);
  1935 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
  1936 + cris_alu(dc, CC_OP_OR, cpu_R[dc->op2], t[0], t[1], size);
  1937 + cris_alu_free_temps(dc, size, t);
1895 1938 return 2;
1896 1939 }
1897 1940  
1898 1941 static unsigned int dec_addi_r(DisasContext *dc)
1899 1942 {
  1943 + TCGv t0;
1900 1944 DIS(fprintf (logfile, "addi.%c $r%u, $r%u\n",
1901 1945 memsize_char(memsize_zz(dc)), dc->op2, dc->op1));
1902 1946 cris_cc_mask(dc, 0);
1903   - tcg_gen_shl_tl(cpu_T[0], cpu_R[dc->op2], tcg_const_tl(dc->zzsize));
1904   - tcg_gen_add_tl(cpu_R[dc->op1], cpu_R[dc->op1], cpu_T[0]);
  1947 + t0 = tcg_temp_new(TCG_TYPE_TL);
  1948 + tcg_gen_shl_tl(t0, cpu_R[dc->op2], tcg_const_tl(dc->zzsize));
  1949 + tcg_gen_add_tl(cpu_R[dc->op1], cpu_R[dc->op1], t0);
1905 1950 return 2;
1906 1951 }
1907 1952  
1908 1953 static unsigned int dec_addi_acr(DisasContext *dc)
1909 1954 {
  1955 + TCGv t0;
1910 1956 DIS(fprintf (logfile, "addi.%c $r%u, $r%u, $acr\n",
1911 1957 memsize_char(memsize_zz(dc)), dc->op2, dc->op1));
1912 1958 cris_cc_mask(dc, 0);
1913   - tcg_gen_shl_tl(cpu_T[0], cpu_R[dc->op2], tcg_const_tl(dc->zzsize));
1914   - tcg_gen_add_tl(cpu_R[R_ACR], cpu_R[dc->op1], cpu_T[0]);
  1959 + t0 = tcg_temp_new(TCG_TYPE_TL);
  1960 + tcg_gen_shl_tl(t0, cpu_R[dc->op2], tcg_const_tl(dc->zzsize));
  1961 + tcg_gen_add_tl(cpu_R[R_ACR], cpu_R[dc->op1], t0);
  1962 +
1915 1963 return 2;
1916 1964 }
1917 1965  
1918 1966 static unsigned int dec_neg_r(DisasContext *dc)
1919 1967 {
  1968 + TCGv t[2];
1920 1969 int size = memsize_zz(dc);
1921 1970 DIS(fprintf (logfile, "neg.%c $r%u, $r%u\n",
1922 1971 memsize_char(size), dc->op1, dc->op2));
1923 1972 cris_cc_mask(dc, CC_MASK_NZVC);
1924   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
  1973 + cris_alu_alloc_temps(dc, size, t);
  1974 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
1925 1975  
1926   - cris_alu(dc, CC_OP_NEG,
1927   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  1976 + cris_alu(dc, CC_OP_NEG, cpu_R[dc->op2], t[0], t[1], size);
  1977 + cris_alu_free_temps(dc, size, t);
1928 1978 return 2;
1929 1979 }
1930 1980  
... ... @@ -1933,7 +1983,7 @@ static unsigned int dec_btst_r(DisasContext *dc)
1933 1983 DIS(fprintf (logfile, "btst $r%u, $r%u\n",
1934 1984 dc->op1, dc->op2));
1935 1985 cris_cc_mask(dc, CC_MASK_NZ);
1936   - dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0);
  1986 + dec_prep_alu_r(dc, dc->op1, dc->op2, 4, 0, cpu_T[0], cpu_T[1]);
1937 1987  
1938 1988 cris_alu(dc, CC_OP_BTST,
1939 1989 cpu_T[0], cpu_T[0], cpu_T[1], 4);
... ... @@ -1945,108 +1995,127 @@ static unsigned int dec_btst_r(DisasContext *dc)
1945 1995  
1946 1996 static unsigned int dec_sub_r(DisasContext *dc)
1947 1997 {
  1998 + TCGv t[2];
1948 1999 int size = memsize_zz(dc);
1949 2000 DIS(fprintf (logfile, "sub.%c $r%u, $r%u\n",
1950 2001 memsize_char(size), dc->op1, dc->op2));
1951 2002 cris_cc_mask(dc, CC_MASK_NZVC);
1952   - dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0);
1953   - cris_alu(dc, CC_OP_SUB,
1954   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], size);
  2003 + cris_alu_alloc_temps(dc, size, t);
  2004 + dec_prep_alu_r(dc, dc->op1, dc->op2, size, 0, t[0], t[1]);
  2005 + cris_alu(dc, CC_OP_SUB, cpu_R[dc->op2], t[0], t[1], size);
  2006 + cris_alu_free_temps(dc, size, t);
1955 2007 return 2;
1956 2008 }
1957 2009  
1958 2010 /* Zero extension. From size to dword. */
1959 2011 static unsigned int dec_movu_r(DisasContext *dc)
1960 2012 {
  2013 + TCGv t0;
1961 2014 int size = memsize_z(dc);
1962 2015 DIS(fprintf (logfile, "movu.%c $r%u, $r%u\n",
1963 2016 memsize_char(size),
1964 2017 dc->op1, dc->op2));
1965 2018  
1966 2019 cris_cc_mask(dc, CC_MASK_NZ);
1967   - dec_prep_move_r(dc, dc->op1, dc->op2, size, 0, cpu_T[1]);
1968   - cris_alu(dc, CC_OP_MOVE,
1969   - cpu_R[dc->op2], cpu_T[0], cpu_T[1], 4);
  2020 + t0 = tcg_temp_new(TCG_TYPE_TL);
  2021 + dec_prep_move_r(dc, dc->op1, dc->op2, size, 0, t0);
  2022 + cris_alu(dc, CC_OP_MOVE, cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  2023 + tcg_temp_free(t0);
1970 2024 return 2;
1971 2025 }
1972 2026  
1973 2027 /* Sign extension. From size to dword. */
1974 2028 static unsigned int dec_movs_r(DisasContext *dc)
1975 2029 {
  2030 + TCGv t0;
1976 2031 int size = memsize_z(dc);
1977 2032 DIS(fprintf (logfile, "movs.%c $r%u, $r%u\n",
1978 2033 memsize_char(size),
1979 2034 dc->op1, dc->op2));
1980 2035  
1981 2036 cris_cc_mask(dc, CC_MASK_NZ);
  2037 + t0 = tcg_temp_new(TCG_TYPE_TL);
1982 2038 /* Size can only be qi or hi. */
1983   - t_gen_sext(cpu_T[1], cpu_R[dc->op1], size);
  2039 + t_gen_sext(t0, cpu_R[dc->op1], size);
1984 2040 cris_alu(dc, CC_OP_MOVE,
1985   - cpu_R[dc->op2], cpu_R[dc->op1], cpu_T[1], 4);
  2041 + cpu_R[dc->op2], cpu_R[dc->op1], t0, 4);
  2042 + tcg_temp_free(t0);
1986 2043 return 2;
1987 2044 }
1988 2045  
1989 2046 /* zero extension. From size to dword. */
1990 2047 static unsigned int dec_addu_r(DisasContext *dc)
1991 2048 {
  2049 + TCGv t0;
1992 2050 int size = memsize_z(dc);
1993 2051 DIS(fprintf (logfile, "addu.%c $r%u, $r%u\n",
1994 2052 memsize_char(size),
1995 2053 dc->op1, dc->op2));
1996 2054  
1997 2055 cris_cc_mask(dc, CC_MASK_NZVC);
  2056 + t0 = tcg_temp_new(TCG_TYPE_TL);
1998 2057 /* Size can only be qi or hi. */
1999   - t_gen_zext(cpu_T[1], cpu_R[dc->op1], size);
  2058 + t_gen_zext(t0, cpu_R[dc->op1], size);
2000 2059 cris_alu(dc, CC_OP_ADD,
2001   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  2060 + cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  2061 + tcg_temp_free(t0);
2002 2062 return 2;
2003 2063 }
2004 2064  
2005 2065 /* Sign extension. From size to dword. */
2006 2066 static unsigned int dec_adds_r(DisasContext *dc)
2007 2067 {
  2068 + TCGv t0;
2008 2069 int size = memsize_z(dc);
2009 2070 DIS(fprintf (logfile, "adds.%c $r%u, $r%u\n",
2010 2071 memsize_char(size),
2011 2072 dc->op1, dc->op2));
2012 2073  
2013 2074 cris_cc_mask(dc, CC_MASK_NZVC);
  2075 + t0 = tcg_temp_new(TCG_TYPE_TL);
2014 2076 /* Size can only be qi or hi. */
2015   - t_gen_sext(cpu_T[1], cpu_R[dc->op1], size);
  2077 + t_gen_sext(t0, cpu_R[dc->op1], size);
2016 2078 cris_alu(dc, CC_OP_ADD,
2017   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  2079 + cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  2080 + tcg_temp_free(t0);
2018 2081 return 2;
2019 2082 }
2020 2083  
2021 2084 /* Zero extension. From size to dword. */
2022 2085 static unsigned int dec_subu_r(DisasContext *dc)
2023 2086 {
  2087 + TCGv t0;
2024 2088 int size = memsize_z(dc);
2025 2089 DIS(fprintf (logfile, "subu.%c $r%u, $r%u\n",
2026 2090 memsize_char(size),
2027 2091 dc->op1, dc->op2));
2028 2092  
2029 2093 cris_cc_mask(dc, CC_MASK_NZVC);
  2094 + t0 = tcg_temp_new(TCG_TYPE_TL);
2030 2095 /* Size can only be qi or hi. */
2031   - t_gen_zext(cpu_T[1], cpu_R[dc->op1], size);
  2096 + t_gen_zext(t0, cpu_R[dc->op1], size);
2032 2097 cris_alu(dc, CC_OP_SUB,
2033   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  2098 + cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  2099 + tcg_temp_free(t0);
2034 2100 return 2;
2035 2101 }
2036 2102  
2037 2103 /* Sign extension. From size to dword. */
2038 2104 static unsigned int dec_subs_r(DisasContext *dc)
2039 2105 {
  2106 + TCGv t0;
2040 2107 int size = memsize_z(dc);
2041 2108 DIS(fprintf (logfile, "subs.%c $r%u, $r%u\n",
2042 2109 memsize_char(size),
2043 2110 dc->op1, dc->op2));
2044 2111  
2045 2112 cris_cc_mask(dc, CC_MASK_NZVC);
  2113 + t0 = tcg_temp_new(TCG_TYPE_TL);
2046 2114 /* Size can only be qi or hi. */
2047   - t_gen_sext(cpu_T[1], cpu_R[dc->op1], size);
  2115 + t_gen_sext(t0, cpu_R[dc->op1], size);
2048 2116 cris_alu(dc, CC_OP_SUB,
2049   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], 4);
  2117 + cpu_R[dc->op2], cpu_R[dc->op2], t0, 4);
  2118 + tcg_temp_free(t0);
2050 2119 return 2;
2051 2120 }
2052 2121  
... ... @@ -2055,6 +2124,7 @@ static unsigned int dec_setclrf(DisasContext *dc)
2055 2124 uint32_t flags;
2056 2125 int set = (~dc->opcode >> 2) & 1;
2057 2126  
  2127 +
2058 2128 flags = (EXTRACT_FIELD(dc->ir, 12, 15) << 4)
2059 2129 | EXTRACT_FIELD(dc->ir, 0, 3);
2060 2130 if (set && flags == 0) {
... ... @@ -2069,7 +2139,7 @@ static unsigned int dec_setclrf(DisasContext *dc)
2069 2139 flags));
2070 2140 }
2071 2141  
2072   - /* User space is not allowed to touch these. Silently ignore. */
  2142 + /* User space is not allowed to touch these. Silently ignore. */
2073 2143 if (dc->tb_flags & U_FLAG) {
2074 2144 flags &= ~(S_FLAG | I_FLAG | U_FLAG);
2075 2145 }
... ... @@ -2138,41 +2208,48 @@ static unsigned int dec_move_sr(DisasContext *dc)
2138 2208  
2139 2209 static unsigned int dec_move_rp(DisasContext *dc)
2140 2210 {
  2211 + TCGv t[2];
2141 2212 DIS(fprintf (logfile, "move $r%u, $p%u\n", dc->op1, dc->op2));
2142 2213 cris_cc_mask(dc, 0);
2143 2214  
  2215 + t[0] = tcg_temp_new(TCG_TYPE_TL);
2144 2216 if (dc->op2 == PR_CCS) {
2145 2217 cris_evaluate_flags(dc);
2146   - t_gen_mov_TN_reg(cpu_T[0], dc->op1);
  2218 + t_gen_mov_TN_reg(t[0], dc->op1);
2147 2219 if (dc->tb_flags & U_FLAG) {
  2220 + t[1] = tcg_temp_new(TCG_TYPE_TL);
2148 2221 /* User space is not allowed to touch all flags. */
2149   - tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0x39f);
2150   - tcg_gen_andi_tl(cpu_T[1], cpu_PR[PR_CCS], ~0x39f);
2151   - tcg_gen_or_tl(cpu_T[0], cpu_T[1], cpu_T[0]);
  2222 + tcg_gen_andi_tl(t[0], t[0], 0x39f);
  2223 + tcg_gen_andi_tl(t[1], cpu_PR[PR_CCS], ~0x39f);
  2224 + tcg_gen_or_tl(t[0], t[1], t[0]);
  2225 + tcg_temp_free(t[1]);
2152 2226 }
2153 2227 }
2154 2228 else
2155   - t_gen_mov_TN_reg(cpu_T[0], dc->op1);
  2229 + t_gen_mov_TN_reg(t[0], dc->op1);
2156 2230  
2157   - t_gen_mov_preg_TN(dc, dc->op2, cpu_T[0]);
  2231 + t_gen_mov_preg_TN(dc, dc->op2, t[0]);
2158 2232 if (dc->op2 == PR_CCS) {
2159 2233 cris_update_cc_op(dc, CC_OP_FLAGS, 4);
2160 2234 dc->flags_uptodate = 1;
2161 2235 }
  2236 + tcg_temp_free(t[0]);
2162 2237 return 2;
2163 2238 }
2164 2239 static unsigned int dec_move_pr(DisasContext *dc)
2165 2240 {
  2241 + TCGv t0;
2166 2242 DIS(fprintf (logfile, "move $p%u, $r%u\n", dc->op1, dc->op2));
2167 2243 cris_cc_mask(dc, 0);
2168 2244  
2169 2245 if (dc->op2 == PR_CCS)
2170 2246 cris_evaluate_flags(dc);
2171 2247  
2172   - t_gen_mov_TN_preg(cpu_T[1], dc->op2);
  2248 + t0 = tcg_temp_new(TCG_TYPE_TL);
  2249 + t_gen_mov_TN_preg(t0, dc->op2);
2173 2250 cris_alu(dc, CC_OP_MOVE,
2174   - cpu_R[dc->op1], cpu_R[dc->op1], cpu_T[1],
2175   - preg_sizes[dc->op2]);
  2251 + cpu_R[dc->op1], cpu_R[dc->op1], t0, preg_sizes[dc->op2]);
  2252 + tcg_temp_free(t0);
2176 2253 return 2;
2177 2254 }
2178 2255  
... ... @@ -2193,10 +2270,14 @@ static unsigned int dec_move_mr(DisasContext *dc)
2193 2270 cris_update_result(dc, cpu_R[dc->op2]);
2194 2271 }
2195 2272 else {
2196   - insn_len = dec_prep_move_m(dc, 0, memsize, cpu_T[1]);
  2273 + TCGv t0;
  2274 +
  2275 + t0 = tcg_temp_new(TCG_TYPE_TL);
  2276 + insn_len = dec_prep_move_m(dc, 0, memsize, t0);
2197 2277 cris_cc_mask(dc, CC_MASK_NZ);
2198 2278 cris_alu(dc, CC_OP_MOVE,
2199   - cpu_R[dc->op2], cpu_R[dc->op2], cpu_T[1], memsize);
  2279 + cpu_R[dc->op2], cpu_R[dc->op2], t0, memsize);
  2280 + tcg_temp_free(t0);
2200 2281 }
2201 2282 do_postinc(dc, memsize);
2202 2283 return insn_len;
... ... @@ -2838,13 +2919,11 @@ static unsigned int dec_rfe_etc(DisasContext *dc)
2838 2919  
2839 2920 static unsigned int dec_ftag_fidx_d_m(DisasContext *dc)
2840 2921 {
2841   - /* Ignore D-cache flushes. */
2842 2922 return 2;
2843 2923 }
2844 2924  
2845 2925 static unsigned int dec_ftag_fidx_i_m(DisasContext *dc)
2846 2926 {
2847   - /* Ignore I-cache flushes. */
2848 2927 return 2;
2849 2928 }
2850 2929  
... ... @@ -3207,7 +3286,8 @@ gen_intermediate_code_internal(CPUState *env, TranslationBlock *tb,
3207 3286 delay slots dont break. */
3208 3287 if (!(tb->pc & 1) && env->singlestep_enabled)
3209 3288 break;
3210   - } while (!dc->is_jmp && gen_opc_ptr < gen_opc_end
  3289 + } while (!dc->is_jmp && !dc->cpustate_changed
  3290 + && gen_opc_ptr < gen_opc_end
3211 3291 && (dc->pc < next_page_start)
3212 3292 && num_insns < max_insns);
3213 3293  
... ...