From 7fa80570a065353fad6d0698180e583e26a4c19e Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 31 Jul 2020 16:11:34 -0700 Subject: 6693 --- html/apps/mu.subx.html | 39378 ++++++++++++++++++++++++----------------------- 1 file changed, 19762 insertions(+), 19616 deletions(-) (limited to 'html/apps/*.subx.html') diff --git a/html/apps/mu.subx.html b/html/apps/mu.subx.html index ed09ba7c..0121734e 100644 --- a/html/apps/mu.subx.html +++ b/html/apps/mu.subx.html @@ -560,7 +560,7 @@ if ('onhashchange' in window) { 498 # . save registers 499 50/push-eax 500 # initialize global data structures - 501 c7 0/subop/copy *Next-block-index 1/imm32 + 501 c7 0/subop/copy *Next-block-index 1/imm32 502 8b/-> *Primitive-type-ids 0/r32/eax 503 89/<- *Type-id 0/r32/eax # stream-write 504 c7 0/subop/copy *_Program-functions 0/imm32 @@ -570,11 +570,11 @@ if ('onhashchange' in window) { 508 c7 0/subop/copy *_Program-signatures 0/imm32 509 c7 0/subop/copy *_Program-signatures->payload 0/imm32 510 # - 511 (parse-mu *(ebp+8) *(ebp+0x10) *(ebp+0x14)) - 512 (populate-mu-type-sizes *(ebp+0x10) *(ebp+0x14)) + 511 (parse-mu *(ebp+8) *(ebp+0x10) *(ebp+0x14)) + 512 (populate-mu-type-sizes *(ebp+0x10) *(ebp+0x14)) 513 #? (dump-typeinfos "=== typeinfos\n") - 514 (check-mu-types *(ebp+0x10) *(ebp+0x14)) - 515 (emit-subx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) + 514 (check-mu-types *(ebp+0x10) *(ebp+0x14)) + 515 (emit-subx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) 516 $convert-mu:end: 517 # . restore registers 518 58/pop-to-eax @@ -1602,7 +1602,7 @@ if ('onhashchange' in window) { 1665 5d/pop-to-ebp 1666 c3/return 1667 - 1668 test-convert-function-call-with-inout-with-incompatible-type-parameters: + 1668 test-type-parameter-matches-rest-of-type: 1669 # . prologue 1670 55/push-ebp 1671 89/<- %ebp 4/r32/esp @@ -1620,70 +1620,70 @@ if ('onhashchange' in window) { 1683 (tailor-exit-descriptor %edx 0x10) 1684 # 1685 (write _test-input-stream "fn f {\n") - 1686 (write _test-input-stream " var x: (addr int)\n") - 1687 (write _test-input-stream " var y: (addr boolean)\n") - 1688 (write _test-input-stream " g x, y\n") - 1689 (write _test-input-stream "}\n") - 1690 (write _test-input-stream "fn g a: (addr _T), b: (addr _T) {\n") - 1691 (write _test-input-stream "}\n") - 1692 # convert - 1693 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1694 # registers except esp clobbered at this point - 1695 # restore ed - 1696 89/<- %edx 4/r32/esp - 1697 (flush _test-output-buffered-file) - 1698 (flush _test-error-buffered-file) - 1699 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 1705 # check output - 1706 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty") - 1707 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message") - 1708 # don't restore from ebp - 1709 81 0/subop/add %esp 8/imm32 - 1710 # . epilogue - 1711 5d/pop-to-ebp - 1712 c3/return - 1713 - 1714 test-convert-function-call-with-too-few-inouts: - 1715 # . prologue - 1716 55/push-ebp - 1717 89/<- %ebp 4/r32/esp - 1718 # setup - 1719 (clear-stream _test-input-stream) - 1720 (clear-stream $_test-input-buffered-file->buffer) - 1721 (clear-stream _test-output-stream) - 1722 (clear-stream $_test-output-buffered-file->buffer) - 1723 (clear-stream _test-error-stream) - 1724 (clear-stream $_test-error-buffered-file->buffer) - 1725 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1686 (write _test-input-stream " var x: (addr array int)\n") + 1687 (write _test-input-stream " g x\n") + 1688 (write _test-input-stream "}\n") + 1689 (write _test-input-stream "fn g a: (addr _) {\n") + 1690 (write _test-input-stream "}\n") + 1691 # convert + 1692 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1693 # registers except esp clobbered at this point + 1694 # restore ed + 1695 89/<- %edx 4/r32/esp + 1696 (flush _test-output-buffered-file) + 1697 (flush _test-error-buffered-file) + 1698 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1704 # no errors + 1705 (check-stream-equal _test-error-stream "" "F - test-type-parameter-matches-rest-of-type: error stream should be empty") + 1706 # don't bother checking the generated code + 1707 # don't restore from ebp + 1708 81 0/subop/add %esp 8/imm32 + 1709 # . epilogue + 1710 5d/pop-to-ebp + 1711 c3/return + 1712 + 1713 test-convert-function-call-with-inout-with-incompatible-type-parameters: + 1714 # . prologue + 1715 55/push-ebp + 1716 89/<- %ebp 4/r32/esp + 1717 # setup + 1718 (clear-stream _test-input-stream) + 1719 (clear-stream $_test-input-buffered-file->buffer) + 1720 (clear-stream _test-output-stream) + 1721 (clear-stream $_test-output-buffered-file->buffer) + 1722 (clear-stream _test-error-stream) + 1723 (clear-stream $_test-error-buffered-file->buffer) + 1724 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1725 68/push 0/imm32 1726 68/push 0/imm32 - 1727 68/push 0/imm32 - 1728 89/<- %edx 4/r32/esp - 1729 (tailor-exit-descriptor %edx 0x10) - 1730 # - 1731 (write _test-input-stream "fn f {\n") - 1732 (write _test-input-stream " g\n") - 1733 (write _test-input-stream "}\n") - 1734 (write _test-input-stream "fn g a: int {\n") - 1735 (write _test-input-stream "}\n") - 1736 # convert - 1737 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1738 # registers except esp clobbered at this point - 1739 # restore ed - 1740 89/<- %edx 4/r32/esp - 1741 (flush _test-output-buffered-file) - 1742 (flush _test-error-buffered-file) - 1743 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 1749 # check output - 1750 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty") - 1751 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message") - 1752 # check that stop(1) was called - 1753 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-inouts: exit status") - 1754 # don't restore from ebp - 1755 81 0/subop/add %esp 8/imm32 + 1727 89/<- %edx 4/r32/esp + 1728 (tailor-exit-descriptor %edx 0x10) + 1729 # + 1730 (write _test-input-stream "fn f {\n") + 1731 (write _test-input-stream " var x: (addr int)\n") + 1732 (write _test-input-stream " var y: (addr boolean)\n") + 1733 (write _test-input-stream " g x, y\n") + 1734 (write _test-input-stream "}\n") + 1735 (write _test-input-stream "fn g a: (addr _T), b: (addr _T) {\n") + 1736 (write _test-input-stream "}\n") + 1737 # convert + 1738 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1739 # registers except esp clobbered at this point + 1740 # restore ed + 1741 89/<- %edx 4/r32/esp + 1742 (flush _test-output-buffered-file) + 1743 (flush _test-error-buffered-file) + 1744 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1750 # check output + 1751 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty") + 1752 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message") + 1753 # don't restore from ebp + 1754 81 0/subop/add %esp 8/imm32 + 1755 # . epilogue 1756 5d/pop-to-ebp 1757 c3/return 1758 - 1759 test-convert-function-call-with-too-many-inouts: + 1759 test-convert-function-call-with-too-few-inouts: 1760 # . prologue 1761 55/push-ebp 1762 89/<- %ebp 4/r32/esp @@ -1701,50 +1701,50 @@ if ('onhashchange' in window) { 1774 (tailor-exit-descriptor %edx 0x10) 1775 # 1776 (write _test-input-stream "fn f {\n") - 1777 (write _test-input-stream " var x: int\n") - 1778 (write _test-input-stream " g x\n") - 1779 (write _test-input-stream "}\n") - 1780 (write _test-input-stream "fn g {\n") - 1781 (write _test-input-stream "}\n") - 1782 # convert - 1783 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1784 # registers except esp clobbered at this point - 1785 # restore ed - 1786 89/<- %edx 4/r32/esp - 1787 (flush _test-output-buffered-file) - 1788 (flush _test-error-buffered-file) - 1789 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 1795 # check output - 1796 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty") - 1797 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message") - 1798 # check that stop(1) was called - 1799 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-inouts: exit status") - 1800 # don't restore from ebp - 1801 81 0/subop/add %esp 8/imm32 - 1802 5d/pop-to-ebp - 1803 c3/return - 1804 - 1805 test-convert-function-call-with-incorrect-output-type: - 1806 # . prologue - 1807 55/push-ebp - 1808 89/<- %ebp 4/r32/esp - 1809 # setup - 1810 (clear-stream _test-input-stream) - 1811 (clear-stream $_test-input-buffered-file->buffer) - 1812 (clear-stream _test-output-stream) - 1813 (clear-stream $_test-output-buffered-file->buffer) - 1814 (clear-stream _test-error-stream) - 1815 (clear-stream $_test-error-buffered-file->buffer) - 1816 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1777 (write _test-input-stream " g\n") + 1778 (write _test-input-stream "}\n") + 1779 (write _test-input-stream "fn g a: int {\n") + 1780 (write _test-input-stream "}\n") + 1781 # convert + 1782 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1783 # registers except esp clobbered at this point + 1784 # restore ed + 1785 89/<- %edx 4/r32/esp + 1786 (flush _test-output-buffered-file) + 1787 (flush _test-error-buffered-file) + 1788 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 1794 # check output + 1795 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty") + 1796 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message") + 1797 # check that stop(1) was called + 1798 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-inouts: exit status") + 1799 # don't restore from ebp + 1800 81 0/subop/add %esp 8/imm32 + 1801 5d/pop-to-ebp + 1802 c3/return + 1803 + 1804 test-convert-function-call-with-too-many-inouts: + 1805 # . prologue + 1806 55/push-ebp + 1807 89/<- %ebp 4/r32/esp + 1808 # setup + 1809 (clear-stream _test-input-stream) + 1810 (clear-stream $_test-input-buffered-file->buffer) + 1811 (clear-stream _test-output-stream) + 1812 (clear-stream $_test-output-buffered-file->buffer) + 1813 (clear-stream _test-error-stream) + 1814 (clear-stream $_test-error-buffered-file->buffer) + 1815 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1816 68/push 0/imm32 1817 68/push 0/imm32 - 1818 68/push 0/imm32 - 1819 89/<- %edx 4/r32/esp - 1820 (tailor-exit-descriptor %edx 0x10) - 1821 # - 1822 (write _test-input-stream "fn f {\n") - 1823 (write _test-input-stream " var x/eax: int <- g\n") + 1818 89/<- %edx 4/r32/esp + 1819 (tailor-exit-descriptor %edx 0x10) + 1820 # + 1821 (write _test-input-stream "fn f {\n") + 1822 (write _test-input-stream " var x: int\n") + 1823 (write _test-input-stream " g x\n") 1824 (write _test-input-stream "}\n") - 1825 (write _test-input-stream "fn g -> a/eax: foo {\n") + 1825 (write _test-input-stream "fn g {\n") 1826 (write _test-input-stream "}\n") 1827 # convert 1828 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) @@ -1755,16 +1755,16 @@ if ('onhashchange' in window) { 1833 (flush _test-error-buffered-file) 1834 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ 1840 # check output - 1841 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty") - 1842 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message") + 1841 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty") + 1842 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message") 1843 # check that stop(1) was called - 1844 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-type: exit status") + 1844 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-inouts: exit status") 1845 # don't restore from ebp 1846 81 0/subop/add %esp 8/imm32 1847 5d/pop-to-ebp 1848 c3/return 1849 - 1850 test-convert-function-call-with-too-few-outputs: + 1850 test-convert-function-call-with-incorrect-output-type: 1851 # . prologue 1852 55/push-ebp 1853 89/<- %ebp 4/r32/esp @@ -1782,9 +1782,9 @@ if ('onhashchange' in window) { 1865 (tailor-exit-descriptor %edx 0x10) 1866 # 1867 (write _test-input-stream "fn f {\n") - 1868 (write _test-input-stream " g\n") + 1868 (write _test-input-stream " var x/eax: int <- g\n") 1869 (write _test-input-stream "}\n") - 1870 (write _test-input-stream "fn g -> a/eax: int {\n") + 1870 (write _test-input-stream "fn g -> a/eax: foo {\n") 1871 (write _test-input-stream "}\n") 1872 # convert 1873 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) @@ -1795,16 +1795,16 @@ if ('onhashchange' in window) { 1878 (flush _test-error-buffered-file) 1879 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ 1885 # check output - 1886 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty") - 1887 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message") + 1886 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty") + 1887 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message") 1888 # check that stop(1) was called - 1889 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-outputs: exit status") + 1889 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-type: exit status") 1890 # don't restore from ebp 1891 81 0/subop/add %esp 8/imm32 1892 5d/pop-to-ebp 1893 c3/return 1894 - 1895 test-convert-function-call-with-too-many-outputs: + 1895 test-convert-function-call-with-too-few-outputs: 1896 # . prologue 1897 55/push-ebp 1898 89/<- %ebp 4/r32/esp @@ -1822,9 +1822,9 @@ if ('onhashchange' in window) { 1910 (tailor-exit-descriptor %edx 0x10) 1911 # 1912 (write _test-input-stream "fn f {\n") - 1913 (write _test-input-stream " var x/eax: int <- g\n") + 1913 (write _test-input-stream " g\n") 1914 (write _test-input-stream "}\n") - 1915 (write _test-input-stream "fn g {\n") + 1915 (write _test-input-stream "fn g -> a/eax: int {\n") 1916 (write _test-input-stream "}\n") 1917 # convert 1918 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) @@ -1835,16 +1835,16 @@ if ('onhashchange' in window) { 1923 (flush _test-error-buffered-file) 1924 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ 1930 # check output - 1931 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty") - 1932 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message") + 1931 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty") + 1932 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message") 1933 # check that stop(1) was called - 1934 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-outputs: exit status") + 1934 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-outputs: exit status") 1935 # don't restore from ebp 1936 81 0/subop/add %esp 8/imm32 1937 5d/pop-to-ebp 1938 c3/return 1939 - 1940 test-convert-function-call-with-incorrect-output-register: + 1940 test-convert-function-call-with-too-many-outputs: 1941 # . prologue 1942 55/push-ebp 1943 89/<- %ebp 4/r32/esp @@ -1862,9 +1862,9 @@ if ('onhashchange' in window) { 1955 (tailor-exit-descriptor %edx 0x10) 1956 # 1957 (write _test-input-stream "fn f {\n") - 1958 (write _test-input-stream " var x/ecx: int <- g\n") + 1958 (write _test-input-stream " var x/eax: int <- g\n") 1959 (write _test-input-stream "}\n") - 1960 (write _test-input-stream "fn g -> a/eax: int {\n") + 1960 (write _test-input-stream "fn g {\n") 1961 (write _test-input-stream "}\n") 1962 # convert 1963 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) @@ -1875,16 +1875,16 @@ if ('onhashchange' in window) { 1968 (flush _test-error-buffered-file) 1969 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ 1975 # check output - 1976 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty") - 1977 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message") + 1976 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty") + 1977 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message") 1978 # check that stop(1) was called - 1979 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-register: exit status") + 1979 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-outputs: exit status") 1980 # don't restore from ebp 1981 81 0/subop/add %esp 8/imm32 1982 5d/pop-to-ebp 1983 c3/return 1984 - 1985 test-convert-function-with-local-var-dereferenced: + 1985 test-convert-function-call-with-incorrect-output-register: 1986 # . prologue 1987 55/push-ebp 1988 89/<- %ebp 4/r32/esp @@ -1893,132 +1893,132 @@ if ('onhashchange' in window) { 1991 (clear-stream $_test-input-buffered-file->buffer) 1992 (clear-stream _test-output-stream) 1993 (clear-stream $_test-output-buffered-file->buffer) - 1994 # - 1995 (write _test-input-stream "fn foo {\n") - 1996 (write _test-input-stream " var x/ecx: (addr int) <- copy 0\n") - 1997 (write _test-input-stream " increment *x\n") - 1998 (write _test-input-stream "}\n") - 1999 # convert - 2000 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2001 (flush _test-output-buffered-file) - 2002 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2008 # check output - 2009 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") - 2010 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") - 2011 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-dereferenced/2") - 2012 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-dereferenced/3") - 2013 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-dereferenced/4") - 2014 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-dereferenced/5") - 2015 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-dereferenced/6") - 2016 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-local-var-dereferenced/7") - 2017 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-with-local-var-dereferenced/8") - 2018 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-dereferenced/9") - 2019 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-dereferenced/10") - 2020 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-dereferenced/11") - 2021 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-dereferenced/12") - 2022 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-dereferenced/13") - 2023 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-dereferenced/14") - 2024 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-dereferenced/15") - 2025 # . epilogue - 2026 89/<- %esp 5/r32/ebp + 1994 (clear-stream _test-error-stream) + 1995 (clear-stream $_test-error-buffered-file->buffer) + 1996 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1997 68/push 0/imm32 + 1998 68/push 0/imm32 + 1999 89/<- %edx 4/r32/esp + 2000 (tailor-exit-descriptor %edx 0x10) + 2001 # + 2002 (write _test-input-stream "fn f {\n") + 2003 (write _test-input-stream " var x/ecx: int <- g\n") + 2004 (write _test-input-stream "}\n") + 2005 (write _test-input-stream "fn g -> a/eax: int {\n") + 2006 (write _test-input-stream "}\n") + 2007 # convert + 2008 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2009 # registers except esp clobbered at this point + 2010 # restore ed + 2011 89/<- %edx 4/r32/esp + 2012 (flush _test-output-buffered-file) + 2013 (flush _test-error-buffered-file) + 2014 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2020 # check output + 2021 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty") + 2022 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message") + 2023 # check that stop(1) was called + 2024 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-register: exit status") + 2025 # don't restore from ebp + 2026 81 0/subop/add %esp 8/imm32 2027 5d/pop-to-ebp 2028 c3/return 2029 - 2030 # variables of type 'byte' are not allowed on the stack - 2031 test-convert-function-with-byte-operations: - 2032 # . prologue - 2033 55/push-ebp - 2034 89/<- %ebp 4/r32/esp - 2035 # setup - 2036 (clear-stream _test-input-stream) - 2037 (clear-stream $_test-input-buffered-file->buffer) - 2038 (clear-stream _test-output-stream) - 2039 (clear-stream $_test-output-buffered-file->buffer) - 2040 # - 2041 (write _test-input-stream "fn foo {\n") - 2042 (write _test-input-stream " var x/eax: byte <- copy 0\n") - 2043 (write _test-input-stream " var y/ecx: byte <- copy 0\n") - 2044 (write _test-input-stream " y <- copy-byte x\n") - 2045 (write _test-input-stream " var z/edx: (addr byte) <- copy 0\n") - 2046 (write _test-input-stream " y <- copy-byte *z\n") - 2047 (write _test-input-stream " copy-byte-to *z, x\n") - 2048 (write _test-input-stream "}\n") - 2049 # convert - 2050 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2051 (flush _test-output-buffered-file) - 2052 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2058 # check output - 2059 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0") - 2060 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1") - 2061 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-byte-operations/2") - 2062 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-byte-operations/3") - 2063 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-byte-operations/4") - 2064 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-byte-operations/5") - 2065 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-byte-operations/6") - 2066 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-byte-operations/7") - 2067 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-byte-operations/8") - 2068 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-byte-operations/9") - 2069 (check-next-stream-line-equal _test-output-stream " 8a/byte-> %eax 0x00000001/r32" "F - test-convert-function-with-byte-operations/10") - 2070 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-function-with-byte-operations/11") - 2071 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 0/imm32" "F - test-convert-function-with-byte-operations/12") - 2072 (check-next-stream-line-equal _test-output-stream " 8a/byte-> *edx 0x00000001/r32" "F - test-convert-function-with-byte-operations/13") - 2073 (check-next-stream-line-equal _test-output-stream " 88/byte<- *edx 0x00000000/r32" "F - test-convert-function-with-byte-operations/14") - 2074 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-function-with-byte-operations/15") - 2075 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-byte-operations/16") - 2076 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-byte-operations/17") - 2077 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-byte-operations/18") - 2078 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-byte-operations/19") - 2079 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-byte-operations/20") - 2080 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-byte-operations/21") - 2081 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-byte-operations/22") - 2082 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-byte-operations/23") - 2083 # . epilogue - 2084 89/<- %esp 5/r32/ebp - 2085 5d/pop-to-ebp - 2086 c3/return - 2087 - 2088 # variables of type 'byte' _can_ be function args. They then occupy 4 bytes. - 2089 test-copy-byte-var-from-fn-arg: - 2090 # . prologue - 2091 55/push-ebp - 2092 89/<- %ebp 4/r32/esp - 2093 # setup - 2094 (clear-stream _test-input-stream) - 2095 (clear-stream $_test-input-buffered-file->buffer) - 2096 (clear-stream _test-output-stream) - 2097 (clear-stream $_test-output-buffered-file->buffer) - 2098 # - 2099 (write _test-input-stream "fn foo x: byte, y: int {\n") - 2100 (write _test-input-stream " var a/eax: byte <- copy x\n") - 2101 (write _test-input-stream " var b/eax: int <- copy y\n") - 2102 (write _test-input-stream "}\n") - 2103 # convert - 2104 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2105 (flush _test-output-buffered-file) - 2106 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2112 # check output - 2113 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0") - 2114 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1") - 2115 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-copy-byte-from-fn-arg/2") - 2116 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-copy-byte-from-fn-arg/3") - 2117 (check-next-stream-line-equal _test-output-stream " {" "F - test-copy-byte-from-fn-arg/4") - 2118 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-copy-byte-from-fn-arg/5") - 2119 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-copy-byte-from-fn-arg/6") - 2120 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/7") - 2121 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x0000000c) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/8") - 2122 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-copy-byte-from-fn-arg/9") - 2123 (check-next-stream-line-equal _test-output-stream " }" "F - test-copy-byte-from-fn-arg/10") - 2124 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-copy-byte-from-fn-arg/11") - 2125 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-copy-byte-from-fn-arg/12") - 2126 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-copy-byte-from-fn-arg/13") - 2127 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-copy-byte-from-fn-arg/14") - 2128 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-copy-byte-from-fn-arg/15") - 2129 # . epilogue - 2130 89/<- %esp 5/r32/ebp - 2131 5d/pop-to-ebp - 2132 c3/return - 2133 - 2134 test-convert-compare-register-with-literal: + 2030 test-convert-function-with-local-var-dereferenced: + 2031 # . prologue + 2032 55/push-ebp + 2033 89/<- %ebp 4/r32/esp + 2034 # setup + 2035 (clear-stream _test-input-stream) + 2036 (clear-stream $_test-input-buffered-file->buffer) + 2037 (clear-stream _test-output-stream) + 2038 (clear-stream $_test-output-buffered-file->buffer) + 2039 # + 2040 (write _test-input-stream "fn foo {\n") + 2041 (write _test-input-stream " var x/ecx: (addr int) <- copy 0\n") + 2042 (write _test-input-stream " increment *x\n") + 2043 (write _test-input-stream "}\n") + 2044 # convert + 2045 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2046 (flush _test-output-buffered-file) + 2047 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2053 # check output + 2054 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") + 2055 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") + 2056 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-dereferenced/2") + 2057 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-dereferenced/3") + 2058 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-dereferenced/4") + 2059 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-dereferenced/5") + 2060 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-dereferenced/6") + 2061 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-local-var-dereferenced/7") + 2062 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-with-local-var-dereferenced/8") + 2063 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-dereferenced/9") + 2064 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-dereferenced/10") + 2065 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-dereferenced/11") + 2066 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-dereferenced/12") + 2067 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-dereferenced/13") + 2068 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-dereferenced/14") + 2069 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-dereferenced/15") + 2070 # . epilogue + 2071 89/<- %esp 5/r32/ebp + 2072 5d/pop-to-ebp + 2073 c3/return + 2074 + 2075 # variables of type 'byte' are not allowed on the stack + 2076 test-convert-function-with-byte-operations: + 2077 # . prologue + 2078 55/push-ebp + 2079 89/<- %ebp 4/r32/esp + 2080 # setup + 2081 (clear-stream _test-input-stream) + 2082 (clear-stream $_test-input-buffered-file->buffer) + 2083 (clear-stream _test-output-stream) + 2084 (clear-stream $_test-output-buffered-file->buffer) + 2085 # + 2086 (write _test-input-stream "fn foo {\n") + 2087 (write _test-input-stream " var x/eax: byte <- copy 0\n") + 2088 (write _test-input-stream " var y/ecx: byte <- copy 0\n") + 2089 (write _test-input-stream " y <- copy-byte x\n") + 2090 (write _test-input-stream " var z/edx: (addr byte) <- copy 0\n") + 2091 (write _test-input-stream " y <- copy-byte *z\n") + 2092 (write _test-input-stream " copy-byte-to *z, x\n") + 2093 (write _test-input-stream "}\n") + 2094 # convert + 2095 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2096 (flush _test-output-buffered-file) + 2097 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2103 # check output + 2104 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0") + 2105 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1") + 2106 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-byte-operations/2") + 2107 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-byte-operations/3") + 2108 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-byte-operations/4") + 2109 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-byte-operations/5") + 2110 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-byte-operations/6") + 2111 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-byte-operations/7") + 2112 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-byte-operations/8") + 2113 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-byte-operations/9") + 2114 (check-next-stream-line-equal _test-output-stream " 8a/byte-> %eax 0x00000001/r32" "F - test-convert-function-with-byte-operations/10") + 2115 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-function-with-byte-operations/11") + 2116 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 0/imm32" "F - test-convert-function-with-byte-operations/12") + 2117 (check-next-stream-line-equal _test-output-stream " 8a/byte-> *edx 0x00000001/r32" "F - test-convert-function-with-byte-operations/13") + 2118 (check-next-stream-line-equal _test-output-stream " 88/byte<- *edx 0x00000000/r32" "F - test-convert-function-with-byte-operations/14") + 2119 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-function-with-byte-operations/15") + 2120 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-byte-operations/16") + 2121 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-byte-operations/17") + 2122 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-byte-operations/18") + 2123 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-byte-operations/19") + 2124 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-byte-operations/20") + 2125 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-byte-operations/21") + 2126 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-byte-operations/22") + 2127 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-byte-operations/23") + 2128 # . epilogue + 2129 89/<- %esp 5/r32/ebp + 2130 5d/pop-to-ebp + 2131 c3/return + 2132 + 2133 # variables of type 'byte' _can_ be function args. They then occupy 4 bytes. + 2134 test-copy-byte-var-from-fn-arg: 2135 # . prologue 2136 55/push-ebp 2137 89/<- %ebp 4/r32/esp @@ -2028,37 +2028,37 @@ if ('onhashchange' in window) { 2141 (clear-stream _test-output-stream) 2142 (clear-stream $_test-output-buffered-file->buffer) 2143 # - 2144 (write _test-input-stream "fn foo {\n") - 2145 (write _test-input-stream " var x/ecx: int <- copy 0\n") - 2146 (write _test-input-stream " compare x, 0\n") + 2144 (write _test-input-stream "fn foo x: byte, y: int {\n") + 2145 (write _test-input-stream " var a/eax: byte <- copy x\n") + 2146 (write _test-input-stream " var b/eax: int <- copy y\n") 2147 (write _test-input-stream "}\n") 2148 # convert 2149 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 2150 (flush _test-output-buffered-file) 2151 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- 2157 # check output - 2158 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") - 2159 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") - 2160 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-compare-register-with-literal/2") - 2161 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-compare-register-with-literal/3") - 2162 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-compare-register-with-literal/4") - 2163 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-compare-register-with-literal/5") - 2164 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") - 2165 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-compare-register-with-literal/7") - 2166 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0/imm32" "F - test-convert-compare-register-with-literal/8") - 2167 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") - 2168 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-compare-register-with-literal/10") - 2169 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-compare-register-with-literal/11") - 2170 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-compare-register-with-literal/12") - 2171 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-compare-register-with-literal/13") - 2172 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-compare-register-with-literal/14") - 2173 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-compare-register-with-literal/15") + 2158 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0") + 2159 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1") + 2160 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-copy-byte-from-fn-arg/2") + 2161 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-copy-byte-from-fn-arg/3") + 2162 (check-next-stream-line-equal _test-output-stream " {" "F - test-copy-byte-from-fn-arg/4") + 2163 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-copy-byte-from-fn-arg/5") + 2164 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-copy-byte-from-fn-arg/6") + 2165 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/7") + 2166 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x0000000c) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/8") + 2167 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-copy-byte-from-fn-arg/9") + 2168 (check-next-stream-line-equal _test-output-stream " }" "F - test-copy-byte-from-fn-arg/10") + 2169 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-copy-byte-from-fn-arg/11") + 2170 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-copy-byte-from-fn-arg/12") + 2171 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-copy-byte-from-fn-arg/13") + 2172 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-copy-byte-from-fn-arg/14") + 2173 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-copy-byte-from-fn-arg/15") 2174 # . epilogue 2175 89/<- %esp 5/r32/ebp 2176 5d/pop-to-ebp 2177 c3/return 2178 - 2179 test-unknown-variable: + 2179 test-convert-compare-register-with-literal: 2180 # . prologue 2181 55/push-ebp 2182 89/<- %ebp 4/r32/esp @@ -2067,1808 +2067,1808 @@ if ('onhashchange' in window) { 2185 (clear-stream $_test-input-buffered-file->buffer) 2186 (clear-stream _test-output-stream) 2187 (clear-stream $_test-output-buffered-file->buffer) - 2188 (clear-stream _test-error-stream) - 2189 (clear-stream $_test-error-buffered-file->buffer) - 2190 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2191 68/push 0/imm32 - 2192 68/push 0/imm32 - 2193 89/<- %edx 4/r32/esp - 2194 (tailor-exit-descriptor %edx 0x10) - 2195 # - 2196 (write _test-input-stream "fn foo {\n") - 2197 (write _test-input-stream " compare x, 0\n") - 2198 (write _test-input-stream "}\n") - 2199 # convert - 2200 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2201 # registers except esp clobbered at this point - 2202 # restore ed - 2203 89/<- %edx 4/r32/esp - 2204 (flush _test-output-buffered-file) - 2205 (flush _test-error-buffered-file) - 2206 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 2212 # check output - 2213 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty") - 2214 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message") - 2215 # check that stop(1) was called - 2216 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable: exit status") - 2217 # don't restore from ebp - 2218 81 0/subop/add %esp 8/imm32 + 2188 # + 2189 (write _test-input-stream "fn foo {\n") + 2190 (write _test-input-stream " var x/ecx: int <- copy 0\n") + 2191 (write _test-input-stream " compare x, 0\n") + 2192 (write _test-input-stream "}\n") + 2193 # convert + 2194 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2195 (flush _test-output-buffered-file) + 2196 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2202 # check output + 2203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") + 2204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") + 2205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-compare-register-with-literal/2") + 2206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-compare-register-with-literal/3") + 2207 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-compare-register-with-literal/4") + 2208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-compare-register-with-literal/5") + 2209 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") + 2210 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-compare-register-with-literal/7") + 2211 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0/imm32" "F - test-convert-compare-register-with-literal/8") + 2212 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") + 2213 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-compare-register-with-literal/10") + 2214 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-compare-register-with-literal/11") + 2215 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-compare-register-with-literal/12") + 2216 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-compare-register-with-literal/13") + 2217 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-compare-register-with-literal/14") + 2218 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-compare-register-with-literal/15") 2219 # . epilogue - 2220 5d/pop-to-ebp - 2221 c3/return - 2222 - 2223 test-convert-function-with-local-var-in-block: - 2224 # . prologue - 2225 55/push-ebp - 2226 89/<- %ebp 4/r32/esp - 2227 # setup - 2228 (clear-stream _test-input-stream) - 2229 (clear-stream $_test-input-buffered-file->buffer) - 2230 (clear-stream _test-output-stream) - 2231 (clear-stream $_test-output-buffered-file->buffer) - 2232 # - 2233 (write _test-input-stream "fn foo {\n") - 2234 (write _test-input-stream " {\n") - 2235 (write _test-input-stream " var x: int\n") - 2236 (write _test-input-stream " increment x\n") - 2237 (write _test-input-stream " }\n") - 2238 (write _test-input-stream "}\n") - 2239 # convert - 2240 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2241 (flush _test-output-buffered-file) - 2242 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2248 # check output - 2249 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") - 2250 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") - 2251 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-block/2") - 2252 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-block/3") - 2253 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/4") - 2254 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-block/5") - 2255 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/6") - 2256 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-block/7") - 2257 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-block/8") - 2258 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-block/9") - 2259 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-block/10") - 2260 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/11") - 2261 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-block/12") - 2262 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/13") - 2263 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-block/14") - 2264 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-block/15") - 2265 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-block/16") - 2266 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-block/17") - 2267 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-block/18") - 2268 # . epilogue - 2269 89/<- %esp 5/r32/ebp - 2270 5d/pop-to-ebp - 2271 c3/return - 2272 - 2273 test-convert-function-with-local-var-in-named-block: - 2274 # . prologue - 2275 55/push-ebp - 2276 89/<- %ebp 4/r32/esp - 2277 # setup - 2278 (clear-stream _test-input-stream) - 2279 (clear-stream $_test-input-buffered-file->buffer) - 2280 (clear-stream _test-output-stream) - 2281 (clear-stream $_test-output-buffered-file->buffer) - 2282 # - 2283 (write _test-input-stream "fn foo {\n") - 2284 (write _test-input-stream " $bar: {\n") - 2285 (write _test-input-stream " var x: int\n") - 2286 (write _test-input-stream " increment x\n") - 2287 (write _test-input-stream " }\n") - 2288 (write _test-input-stream "}\n") - 2289 # convert - 2290 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2291 (flush _test-output-buffered-file) - 2292 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2298 # check output - 2299 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") - 2300 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") - 2301 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-named-block/2") - 2302 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-named-block/3") - 2303 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/4") - 2304 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-named-block/5") - 2305 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/6") - 2306 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-local-var-in-named-block/7") - 2307 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-named-block/8") - 2308 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-named-block/9") - 2309 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-named-block/10") - 2310 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/11") - 2311 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-local-var-in-named-block/12") - 2312 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/13") - 2313 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-named-block/14") - 2314 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-named-block/15") - 2315 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-named-block/16") - 2316 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-named-block/17") - 2317 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-named-block/18") - 2318 # . epilogue - 2319 89/<- %esp 5/r32/ebp - 2320 5d/pop-to-ebp - 2321 c3/return - 2322 - 2323 test-unknown-variable-in-named-block: - 2324 # . prologue - 2325 55/push-ebp - 2326 89/<- %ebp 4/r32/esp - 2327 # setup - 2328 (clear-stream _test-input-stream) - 2329 (clear-stream $_test-input-buffered-file->buffer) - 2330 (clear-stream _test-output-stream) - 2331 (clear-stream $_test-output-buffered-file->buffer) - 2332 (clear-stream _test-error-stream) - 2333 (clear-stream $_test-error-buffered-file->buffer) - 2334 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2335 68/push 0/imm32 - 2336 68/push 0/imm32 - 2337 89/<- %edx 4/r32/esp - 2338 (tailor-exit-descriptor %edx 0x10) - 2339 # - 2340 (write _test-input-stream "fn foo {\n") - 2341 (write _test-input-stream " $a: {\n") - 2342 (write _test-input-stream " compare x, 0\n") - 2343 (write _test-input-stream " }\n") - 2344 (write _test-input-stream "}\n") - 2345 # convert - 2346 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2347 # registers except esp clobbered at this point - 2348 # restore ed - 2349 89/<- %edx 4/r32/esp - 2350 (flush _test-output-buffered-file) - 2351 (flush _test-error-buffered-file) - 2352 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 2358 # check output - 2359 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty") - 2360 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message") - 2361 # check that stop(1) was called - 2362 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable-in-named-block: exit status") - 2363 # don't restore from ebp - 2364 81 0/subop/add %esp 8/imm32 - 2365 # . epilogue - 2366 5d/pop-to-ebp - 2367 c3/return - 2368 - 2369 test-always-shadow-outermost-reg-vars-in-function: - 2370 # . prologue - 2371 55/push-ebp - 2372 89/<- %ebp 4/r32/esp - 2373 # setup - 2374 (clear-stream _test-input-stream) - 2375 (clear-stream $_test-input-buffered-file->buffer) - 2376 (clear-stream _test-output-stream) - 2377 (clear-stream $_test-output-buffered-file->buffer) - 2378 # - 2379 (write _test-input-stream "fn foo {\n") - 2380 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2381 (write _test-input-stream "}\n") - 2382 # convert - 2383 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2384 (flush _test-output-buffered-file) - 2385 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2391 # check output - 2392 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") - 2393 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") - 2394 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/2") - 2395 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-always-shadow-outermost-reg-vars-in-function/3") - 2396 (check-next-stream-line-equal _test-output-stream " {" "F - test-always-shadow-outermost-reg-vars-in-function/4") - 2397 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-always-shadow-outermost-reg-vars-in-function/5") - 2398 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") - 2399 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-always-shadow-outermost-reg-vars-in-function/8") - 2400 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") - 2401 (check-next-stream-line-equal _test-output-stream " }" "F - test-always-shadow-outermost-reg-vars-in-function/12") - 2402 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-always-shadow-outermost-reg-vars-in-function/13") - 2403 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-always-shadow-outermost-reg-vars-in-function/14") - 2404 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-always-shadow-outermost-reg-vars-in-function/15") - 2405 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/16") - 2406 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-always-shadow-outermost-reg-vars-in-function/17") - 2407 # . epilogue - 2408 89/<- %esp 5/r32/ebp - 2409 5d/pop-to-ebp - 2410 c3/return - 2411 - 2412 _pending-test-clobber-dead-local: - 2413 # . prologue - 2414 55/push-ebp - 2415 89/<- %ebp 4/r32/esp - 2416 # setup - 2417 (clear-stream _test-input-stream) - 2418 (clear-stream $_test-input-buffered-file->buffer) - 2419 (clear-stream _test-output-stream) - 2420 (clear-stream $_test-output-buffered-file->buffer) - 2421 # - 2422 (write _test-input-stream "fn foo {\n") - 2423 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2424 (write _test-input-stream " {\n") - 2425 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2426 (write _test-input-stream " }\n") - 2427 (write _test-input-stream "}\n") - 2428 # convert - 2429 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2430 (flush _test-output-buffered-file) - 2431 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2437 # check output - 2438 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-clobber-dead-local/0") - 2439 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-clobber-dead-local/1") - 2440 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-clobber-dead-local/2") - 2441 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-clobber-dead-local/3") - 2442 (check-next-stream-line-equal _test-output-stream " {" "F - test-clobber-dead-local/4") - 2443 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-clobber-dead-local/5") - 2444 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-clobber-dead-local/6") - 2445 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-clobber-dead-local/7") - 2446 (check-next-stream-line-equal _test-output-stream " {" "F - test-clobber-dead-local/8") - 2447 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-clobber-dead-local/9") - 2448 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-clobber-dead-local/10") # no push/pop here - 2449 (check-next-stream-line-equal _test-output-stream " }" "F - test-clobber-dead-local/11") - 2450 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-clobber-dead-local/12") - 2451 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-clobber-dead-local/13") - 2452 (check-next-stream-line-equal _test-output-stream " }" "F - test-clobber-dead-local/14") - 2453 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-clobber-dead-local/15") - 2454 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-clobber-dead-local/16") - 2455 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-clobber-dead-local/17") - 2456 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-clobber-dead-local/18") - 2457 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-clobber-dead-local/19") - 2458 # . epilogue - 2459 89/<- %esp 5/r32/ebp - 2460 5d/pop-to-ebp - 2461 c3/return - 2462 - 2463 test-shadow-live-local: - 2464 # . prologue - 2465 55/push-ebp - 2466 89/<- %ebp 4/r32/esp - 2467 # setup - 2468 (clear-stream _test-input-stream) - 2469 (clear-stream $_test-input-buffered-file->buffer) - 2470 (clear-stream _test-output-stream) - 2471 (clear-stream $_test-output-buffered-file->buffer) - 2472 # - 2473 (write _test-input-stream "fn foo {\n") - 2474 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2475 (write _test-input-stream " {\n") - 2476 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2477 (write _test-input-stream " }\n") - 2478 (write _test-input-stream " x <- increment\n") - 2479 (write _test-input-stream "}\n") - 2480 # convert - 2481 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2482 (flush _test-output-buffered-file) - 2483 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2489 # check output - 2490 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-local/0") - 2491 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-local/1") - 2492 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-live-local/2") - 2493 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-live-local/3") - 2494 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-local/4") - 2495 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-live-local/5") - 2496 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-local/6") - 2497 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-live-local/7") - 2498 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-local/8") - 2499 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-live-local/9") - 2500 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-local/10") - 2501 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-live-local/11") - 2502 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-local/12") - 2503 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-local/13") - 2504 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-live-local/14") - 2505 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-live-local/15") - 2506 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-local/16") - 2507 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-local/17") - 2508 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-live-local/18") - 2509 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-live-local/19") - 2510 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-live-local/20") - 2511 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-live-local/21") - 2512 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-live-local/22") - 2513 # . epilogue - 2514 89/<- %esp 5/r32/ebp - 2515 5d/pop-to-ebp - 2516 c3/return - 2517 - 2518 test-shadow-name: - 2519 # . prologue - 2520 55/push-ebp - 2521 89/<- %ebp 4/r32/esp - 2522 # setup - 2523 (clear-stream _test-input-stream) - 2524 (clear-stream $_test-input-buffered-file->buffer) - 2525 (clear-stream _test-output-stream) - 2526 (clear-stream $_test-output-buffered-file->buffer) - 2527 # - 2528 (write _test-input-stream "fn foo {\n") - 2529 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2530 (write _test-input-stream " {\n") - 2531 (write _test-input-stream " var x/edx: int <- copy 4\n") - 2532 (write _test-input-stream " }\n") - 2533 (write _test-input-stream " x <- increment\n") - 2534 (write _test-input-stream "}\n") - 2535 # convert - 2536 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2537 (flush _test-output-buffered-file) - 2538 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2544 # check output - 2545 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0") - 2546 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1") - 2547 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name/2") - 2548 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name/3") - 2549 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/4") - 2550 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name/5") - 2551 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name/6") - 2552 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name/7") - 2553 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/8") - 2554 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name/9") - 2555 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name/10") - 2556 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name/11") - 2557 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name/12") - 2558 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/13") - 2559 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name/14") - 2560 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name/15") - 2561 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name/16") - 2562 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/17") - 2563 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name/18") - 2564 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name/19") - 2565 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name/20") - 2566 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name/21") - 2567 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name/22") - 2568 # . epilogue - 2569 89/<- %esp 5/r32/ebp - 2570 5d/pop-to-ebp - 2571 c3/return - 2572 - 2573 test-shadow-name-2: - 2574 # . prologue - 2575 55/push-ebp - 2576 89/<- %ebp 4/r32/esp - 2577 # setup - 2578 (clear-stream _test-input-stream) - 2579 (clear-stream $_test-input-buffered-file->buffer) - 2580 (clear-stream _test-output-stream) - 2581 (clear-stream $_test-output-buffered-file->buffer) - 2582 # - 2583 (write _test-input-stream "fn foo {\n") - 2584 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2585 (write _test-input-stream " {\n") - 2586 (write _test-input-stream " var x/edx: int <- copy 4\n") - 2587 (write _test-input-stream " var y/ecx: int <- copy 5\n") - 2588 (write _test-input-stream " }\n") - 2589 (write _test-input-stream " x <- increment\n") - 2590 (write _test-input-stream "}\n") - 2591 # convert - 2592 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2593 (flush _test-output-buffered-file) - 2594 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2600 # check output - 2601 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0") - 2602 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1") - 2603 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name-2/2") - 2604 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name-2/3") - 2605 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/4") - 2606 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name-2/5") - 2607 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/6") - 2608 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name-2/7") - 2609 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/8") - 2610 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name-2/9") - 2611 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name-2/10") - 2612 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name-2/11") - 2613 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/12") - 2614 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 5/imm32" "F - test-shadow-name-2/13") - 2615 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/14") - 2616 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name-2/15") - 2617 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/16") - 2618 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name-2/17") - 2619 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name-2/18") - 2620 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/19") - 2621 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/20") - 2622 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name-2/21") - 2623 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name-2/22") - 2624 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name-2/23") - 2625 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name-2/24") - 2626 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name-2/25") - 2627 # . epilogue - 2628 89/<- %esp 5/r32/ebp - 2629 5d/pop-to-ebp - 2630 c3/return - 2631 - 2632 test-do-not-spill-same-register-in-block: - 2633 # . prologue - 2634 55/push-ebp - 2635 89/<- %ebp 4/r32/esp - 2636 # setup - 2637 (clear-stream _test-input-stream) - 2638 (clear-stream $_test-input-buffered-file->buffer) - 2639 (clear-stream _test-output-stream) - 2640 (clear-stream $_test-output-buffered-file->buffer) - 2641 # - 2642 (write _test-input-stream "fn foo {\n") - 2643 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2644 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2645 (write _test-input-stream " y <- increment\n") - 2646 (write _test-input-stream "}\n") - 2647 # convert - 2648 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2649 (flush _test-output-buffered-file) - 2650 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2656 # check output - 2657 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") - 2658 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") - 2659 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-do-not-spill-same-register-in-block/2") - 2660 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-do-not-spill-same-register-in-block/3") - 2661 (check-next-stream-line-equal _test-output-stream " {" "F - test-do-not-spill-same-register-in-block/4") - 2662 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-do-not-spill-same-register-in-block/5") - 2663 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-do-not-spill-same-register-in-block/6") - 2664 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-do-not-spill-same-register-in-block/7") - 2665 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-do-not-spill-same-register-in-block/8") - 2666 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-do-not-spill-same-register-in-block/9") - 2667 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-do-not-spill-same-register-in-block/10") - 2668 (check-next-stream-line-equal _test-output-stream " }" "F - test-do-not-spill-same-register-in-block/11") - 2669 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-do-not-spill-same-register-in-block/12") - 2670 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-do-not-spill-same-register-in-block/13") - 2671 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-do-not-spill-same-register-in-block/14") - 2672 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-do-not-spill-same-register-in-block/15") - 2673 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-do-not-spill-same-register-in-block/16") - 2674 # . epilogue - 2675 89/<- %esp 5/r32/ebp - 2676 5d/pop-to-ebp - 2677 c3/return - 2678 - 2679 test-spill-different-register-in-block: - 2680 # . prologue - 2681 55/push-ebp - 2682 89/<- %ebp 4/r32/esp - 2683 # setup - 2684 (clear-stream _test-input-stream) - 2685 (clear-stream $_test-input-buffered-file->buffer) - 2686 (clear-stream _test-output-stream) - 2687 (clear-stream $_test-output-buffered-file->buffer) - 2688 # - 2689 (write _test-input-stream "fn foo {\n") - 2690 (write _test-input-stream " var x/eax: int <- copy 3\n") - 2691 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2692 (write _test-input-stream " y <- increment\n") - 2693 (write _test-input-stream "}\n") - 2694 # convert - 2695 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2696 (flush _test-output-buffered-file) - 2697 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2703 # check output - 2704 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") - 2705 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") - 2706 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-spill-different-register-in-block/2") - 2707 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-spill-different-register-in-block/3") - 2708 (check-next-stream-line-equal _test-output-stream " {" "F - test-spill-different-register-in-block/4") - 2709 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-spill-different-register-in-block/5") - 2710 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-spill-different-register-in-block/6") - 2711 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-spill-different-register-in-block/7") - 2712 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-spill-different-register-in-block/8") - 2713 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-spill-different-register-in-block/9") - 2714 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-spill-different-register-in-block/10") - 2715 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-spill-different-register-in-block/11") - 2716 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-spill-different-register-in-block/12") - 2717 (check-next-stream-line-equal _test-output-stream " }" "F - test-spill-different-register-in-block/13") - 2718 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-spill-different-register-in-block/14") - 2719 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-spill-different-register-in-block/15") - 2720 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-spill-different-register-in-block/16") - 2721 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-spill-different-register-in-block/17") - 2722 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-spill-different-register-in-block/18") - 2723 # . epilogue - 2724 89/<- %esp 5/r32/ebp - 2725 5d/pop-to-ebp - 2726 c3/return - 2727 - 2728 test-shadow-live-output: - 2729 # . prologue - 2730 55/push-ebp - 2731 89/<- %ebp 4/r32/esp - 2732 # setup - 2733 (clear-stream _test-input-stream) - 2734 (clear-stream $_test-input-buffered-file->buffer) - 2735 (clear-stream _test-output-stream) - 2736 (clear-stream $_test-output-buffered-file->buffer) - 2737 # - 2738 (write _test-input-stream "fn foo -> x/ecx: int {\n") - 2739 (write _test-input-stream " x <- copy 3\n") - 2740 (write _test-input-stream " {\n") - 2741 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2742 (write _test-input-stream " }\n") - 2743 (write _test-input-stream " x <- increment\n") - 2744 (write _test-input-stream "}\n") - 2745 # convert - 2746 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2747 (flush _test-output-buffered-file) - 2748 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2754 # check output - 2755 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-output/0") - 2756 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-output/1") - 2757 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-live-output/2") - 2758 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-live-output/3") - 2759 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-output/4") - 2760 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-live-output/5") - 2761 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-live-output/7") # no push because it's an output reg - 2762 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-output/8") - 2763 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-live-output/9") - 2764 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-output/10") - 2765 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-live-output/11") - 2766 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-output/12") - 2767 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-output/13") - 2768 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-live-output/14") - 2769 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-live-output/15") - 2770 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-output/17") - 2771 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-live-output/18") - 2772 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-live-output/19") - 2773 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-live-output/20") - 2774 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-live-output/21") - 2775 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-live-output/21") - 2776 # . epilogue - 2777 89/<- %esp 5/r32/ebp - 2778 5d/pop-to-ebp - 2779 c3/return - 2780 - 2781 test-stmt-defines-output-in-same-register-as-inout: - 2782 # . prologue - 2783 55/push-ebp - 2784 89/<- %ebp 4/r32/esp - 2785 # setup - 2786 (clear-stream _test-input-stream) - 2787 (clear-stream $_test-input-buffered-file->buffer) - 2788 (clear-stream _test-output-stream) - 2789 (clear-stream $_test-output-buffered-file->buffer) - 2790 (clear-stream _test-error-stream) - 2791 (clear-stream $_test-error-buffered-file->buffer) - 2792 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2793 68/push 0/imm32 - 2794 68/push 0/imm32 - 2795 89/<- %edx 4/r32/esp - 2796 (tailor-exit-descriptor %edx 0x10) - 2797 # - 2798 (write _test-input-stream "fn foo -> x/ecx: int {\n") - 2799 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2800 (write _test-input-stream " x <- copy y\n") # writing to a fn output is currently the only way for a statement to define a new var - 2801 (write _test-input-stream "}\n") - 2802 # convert - 2803 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2804 # registers except esp clobbered at this point - 2805 # restore ed - 2806 89/<- %edx 4/r32/esp - 2807 (flush _test-output-buffered-file) - 2808 (flush _test-error-buffered-file) - 2809 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 2815 # no error; we looked up 'y' correctly before pushing the binding for 'x' - 2816 (check-stream-equal _test-error-stream "" "F - test-stmt-defines-output-in-same-register-as-inout: error stream should be empty") - 2817 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below - 2818 # don't restore from ebp - 2819 81 0/subop/add %esp 8/imm32 - 2820 # . epilogue - 2821 5d/pop-to-ebp - 2822 c3/return - 2823 - 2824 test-local-clobbered-by-fn-output: - 2825 # . prologue - 2826 55/push-ebp - 2827 89/<- %ebp 4/r32/esp - 2828 # setup - 2829 (clear-stream _test-input-stream) - 2830 (clear-stream $_test-input-buffered-file->buffer) - 2831 (clear-stream _test-output-stream) - 2832 (clear-stream $_test-output-buffered-file->buffer) - 2833 # - 2834 (write _test-input-stream "fn foo -> x/ecx: int {\n") - 2835 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2836 (write _test-input-stream " x <- copy y\n") - 2837 (write _test-input-stream "}\n") - 2838 # convert - 2839 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2840 (flush _test-output-buffered-file) - 2841 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2847 # check output - 2848 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-local-clobbered-by-fn-output/0") - 2849 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-local-clobbered-by-fn-output/1") - 2850 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-local-clobbered-by-fn-output/2") - 2851 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-local-clobbered-by-fn-output/3") - 2852 (check-next-stream-line-equal _test-output-stream " {" "F - test-local-clobbered-by-fn-output/4") - 2853 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-local-clobbered-by-fn-output/5") - 2854 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-local-clobbered-by-fn-output/6") # no push because it's an output reg - 2855 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0x00000001/r32" "F - test-local-clobbered-by-fn-output/7") - 2856 (check-next-stream-line-equal _test-output-stream " }" "F - test-local-clobbered-by-fn-output/8") - 2857 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-local-clobbered-by-fn-output/9") - 2858 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-local-clobbered-by-fn-output/10") - 2859 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-local-clobbered-by-fn-output/11") - 2860 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-local-clobbered-by-fn-output/12") - 2861 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-local-clobbered-by-fn-output/13") - 2862 # . epilogue - 2863 89/<- %esp 5/r32/ebp - 2864 5d/pop-to-ebp - 2865 c3/return - 2866 - 2867 test-read-output: - 2868 # . prologue - 2869 55/push-ebp - 2870 89/<- %ebp 4/r32/esp - 2871 # setup - 2872 (clear-stream _test-input-stream) - 2873 (clear-stream $_test-input-buffered-file->buffer) - 2874 (clear-stream _test-output-stream) - 2875 (clear-stream $_test-output-buffered-file->buffer) - 2876 # - 2877 (write _test-input-stream "fn foo -> x/ecx: int {\n") - 2878 (write _test-input-stream " x <- copy 0x34\n") - 2879 (write _test-input-stream " compare x, 0x35\n") - 2880 (write _test-input-stream "}\n") - 2881 # convert - 2882 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2883 (flush _test-output-buffered-file) - 2884 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2890 # check output - 2891 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-read-output/0") - 2892 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-read-output/1") - 2893 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-read-output/2") - 2894 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-read-output/3") - 2895 (check-next-stream-line-equal _test-output-stream " {" "F - test-read-output/4") - 2896 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-read-output/5") - 2897 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x34/imm32" "F - test-read-output/6") - 2898 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0x35/imm32" "F - test-read-output/7") - 2899 (check-next-stream-line-equal _test-output-stream " }" "F - test-read-output/8") - 2900 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-read-output/9") - 2901 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-read-output/10") - 2902 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-read-output/11") - 2903 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-read-output/12") - 2904 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-read-output/13") - 2905 # . epilogue - 2906 89/<- %esp 5/r32/ebp - 2907 5d/pop-to-ebp - 2908 c3/return - 2909 - 2910 test-fn-output-written-in-inner-block: - 2911 # . prologue - 2912 55/push-ebp - 2913 89/<- %ebp 4/r32/esp - 2914 # setup - 2915 (clear-stream _test-input-stream) - 2916 (clear-stream $_test-input-buffered-file->buffer) - 2917 (clear-stream _test-output-stream) - 2918 (clear-stream $_test-output-buffered-file->buffer) - 2919 # - 2920 (write _test-input-stream "fn foo -> out/edi: int {\n") - 2921 (write _test-input-stream " var a/eax: int <- copy 3\n") # define outer local - 2922 (write _test-input-stream " {\n") - 2923 (write _test-input-stream " var a/ecx: int <- copy 4\n") # shadow outer local - 2924 (write _test-input-stream " out <- copy a\n") # write to fn output - 2925 (write _test-input-stream " }\n") - 2926 (write _test-input-stream " compare a, 0\n") # use outer local - 2927 (write _test-input-stream "}\n") - 2928 # convert - 2929 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2930 (flush _test-output-buffered-file) - 2931 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2937 # no error; defining 'out' didn't interfere with the reclamation of 'b' - 2938 # check output - 2939 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-fn-output-written-in-inner-block/0") - 2940 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-fn-output-written-in-inner-block/1") - 2941 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-fn-output-written-in-inner-block/2") - 2942 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-fn-output-written-in-inner-block/3") - 2943 (check-next-stream-line-equal _test-output-stream " {" "F - test-fn-output-written-in-inner-block/4") - 2944 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-fn-output-written-in-inner-block/5") - 2945 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-fn-output-written-in-inner-block/6") - 2946 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-fn-output-written-in-inner-block/7") - 2947 (check-next-stream-line-equal _test-output-stream " {" "F - test-fn-output-written-in-inner-block/8") - 2948 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-fn-output-written-in-inner-block/9") - 2949 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-fn-output-written-in-inner-block/10") - 2950 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-fn-output-written-in-inner-block/10") - 2951 (check-next-stream-line-equal _test-output-stream " 89/<- %edi 0x00000001/r32" "F - test-fn-output-written-in-inner-block/11") - 2952 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-fn-output-written-in-inner-block/12") - 2953 (check-next-stream-line-equal _test-output-stream " }" "F - test-fn-output-written-in-inner-block/13") - 2954 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-fn-output-written-in-inner-block/14") - 2955 (check-next-stream-line-equal _test-output-stream " 3d/compare-eax-with 0/imm32" "F - test-fn-output-written-in-inner-block/15") - 2956 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-fn-output-written-in-inner-block/16") - 2957 (check-next-stream-line-equal _test-output-stream " }" "F - test-fn-output-written-in-inner-block/17") - 2958 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-fn-output-written-in-inner-block/18") - 2959 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-fn-output-written-in-inner-block/19") - 2960 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-fn-output-written-in-inner-block/20") - 2961 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-fn-output-written-in-inner-block/21") - 2962 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-fn-output-written-in-inner-block/22") - 2963 # . epilogue - 2964 89/<- %esp 5/r32/ebp - 2965 5d/pop-to-ebp - 2966 c3/return - 2967 - 2968 test-convert-function-with-branches-in-block: - 2969 # . prologue - 2970 55/push-ebp - 2971 89/<- %ebp 4/r32/esp - 2972 # setup - 2973 (clear-stream _test-input-stream) - 2974 (clear-stream $_test-input-buffered-file->buffer) - 2975 (clear-stream _test-output-stream) - 2976 (clear-stream $_test-output-buffered-file->buffer) - 2977 # - 2978 (write _test-input-stream "fn foo x: int {\n") - 2979 (write _test-input-stream " {\n") - 2980 (write _test-input-stream " break-if->=\n") - 2981 (write _test-input-stream " loop-if-addr<\n") - 2982 (write _test-input-stream " increment x\n") - 2983 (write _test-input-stream " loop\n") - 2984 (write _test-input-stream " }\n") - 2985 (write _test-input-stream "}\n") - 2986 # convert - 2987 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2988 (flush _test-output-buffered-file) - 2989 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 2995 # check output - 2996 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") - 2997 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") - 2998 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") - 2999 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") - 3000 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") - 3001 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") - 3002 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") - 3003 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") - 3004 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") - 3005 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") - 3006 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") - 3007 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") - 3008 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") - 3009 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") - 3010 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") - 3011 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") - 3012 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") - 3013 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") - 3014 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") - 3015 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") - 3016 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") - 3017 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") - 3018 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") - 3019 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") - 3020 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") - 3021 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") - 3022 # . epilogue - 3023 89/<- %esp 5/r32/ebp - 3024 5d/pop-to-ebp - 3025 c3/return - 3026 - 3027 test-convert-function-with-branches-in-named-block: - 3028 # . prologue - 3029 55/push-ebp - 3030 89/<- %ebp 4/r32/esp - 3031 # setup - 3032 (clear-stream _test-input-stream) - 3033 (clear-stream $_test-input-buffered-file->buffer) - 3034 (clear-stream _test-output-stream) - 3035 (clear-stream $_test-output-buffered-file->buffer) - 3036 # - 3037 (write _test-input-stream "fn foo x: int {\n") - 3038 (write _test-input-stream " $bar: {\n") - 3039 (write _test-input-stream " break-if->= $bar\n") - 3040 (write _test-input-stream " loop-if-addr< $bar\n") - 3041 (write _test-input-stream " increment x\n") - 3042 (write _test-input-stream " loop\n") - 3043 (write _test-input-stream " }\n") - 3044 (write _test-input-stream "}\n") - 3045 # convert - 3046 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3047 (flush _test-output-buffered-file) - 3048 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3054 # check output - 3055 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") - 3056 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") - 3057 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-named-block/2") - 3058 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-named-block/3") - 3059 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/4") - 3060 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-named-block/5") - 3061 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/6") - 3062 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-branches-in-named-block/7") - 3063 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/8") - 3064 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-named-block/9") - 3065 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:break/disp32" "F - test-convert-function-with-branches-in-named-block/10") - 3066 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/11") - 3067 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/12") - 3068 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-named-block/13") - 3069 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:loop/disp32" "F - test-convert-function-with-branches-in-named-block/14") - 3070 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/15") - 3071 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-named-block/16") - 3072 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-named-block/17") - 3073 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/18") - 3074 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-branches-in-named-block/19") - 3075 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/20") - 3076 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-named-block/21") - 3077 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-named-block/22") - 3078 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-named-block/23") - 3079 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-named-block/24") - 3080 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-named-block/25") - 3081 # . epilogue - 3082 89/<- %esp 5/r32/ebp - 3083 5d/pop-to-ebp - 3084 c3/return - 3085 - 3086 test-convert-function-with-var-in-nested-block: - 3087 # . prologue - 3088 55/push-ebp - 3089 89/<- %ebp 4/r32/esp - 3090 # setup - 3091 (clear-stream _test-input-stream) - 3092 (clear-stream $_test-input-buffered-file->buffer) - 3093 (clear-stream _test-output-stream) - 3094 (clear-stream $_test-output-buffered-file->buffer) - 3095 # - 3096 (write _test-input-stream "fn foo x: int {\n") - 3097 (write _test-input-stream " {\n") - 3098 (write _test-input-stream " {\n") - 3099 (write _test-input-stream " var x: int\n") - 3100 (write _test-input-stream " increment x\n") - 3101 (write _test-input-stream " }\n") - 3102 (write _test-input-stream " }\n") - 3103 (write _test-input-stream "}\n") - 3104 # convert - 3105 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3106 (flush _test-output-buffered-file) - 3107 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3113 # check output - 3114 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") - 3115 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") - 3116 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-var-in-nested-block/2") - 3117 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-var-in-nested-block/3") - 3118 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/4") - 3119 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-var-in-nested-block/5") - 3120 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/6") - 3121 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-var-in-nested-block/7") - 3122 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/8") - 3123 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-var-in-nested-block/9") - 3124 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-var-in-nested-block/10") - 3125 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-var-in-nested-block/11") - 3126 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-var-in-nested-block/12") - 3127 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/13") - 3128 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-var-in-nested-block/14") - 3129 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/15") - 3130 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-var-in-nested-block/16") - 3131 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/17") - 3132 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-var-in-nested-block/18") - 3133 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-var-in-nested-block/19") - 3134 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-var-in-nested-block/20") - 3135 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-var-in-nested-block/21") - 3136 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-var-in-nested-block/22") - 3137 # . epilogue - 3138 89/<- %esp 5/r32/ebp - 3139 5d/pop-to-ebp - 3140 c3/return - 3141 - 3142 test-convert-function-with-multiple-vars-in-nested-blocks: - 3143 # . prologue - 3144 55/push-ebp - 3145 89/<- %ebp 4/r32/esp - 3146 # setup - 3147 (clear-stream _test-input-stream) - 3148 (clear-stream $_test-input-buffered-file->buffer) - 3149 (clear-stream _test-output-stream) - 3150 (clear-stream $_test-output-buffered-file->buffer) - 3151 # - 3152 (write _test-input-stream "fn foo x: int {\n") - 3153 (write _test-input-stream " {\n") - 3154 (write _test-input-stream " var x/eax: int <- copy 0\n") - 3155 (write _test-input-stream " {\n") - 3156 (write _test-input-stream " var y: int\n") - 3157 (write _test-input-stream " x <- add y\n") - 3158 (write _test-input-stream " }\n") - 3159 (write _test-input-stream " }\n") - 3160 (write _test-input-stream "}\n") - 3161 # convert - 3162 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3163 (flush _test-output-buffered-file) - 3164 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3170 # check output - 3171 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") - 3172 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") - 3173 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/2") - 3174 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/3") - 3175 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/4") - 3176 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/5") - 3177 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/6") - 3178 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/7") - 3179 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/8") - 3180 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/9") - 3181 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/10") - 3182 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/11") - 3183 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/12") - 3184 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/13") - 3185 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/14") - 3186 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/15") - 3187 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/16") - 3188 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/17") - 3189 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/18") - 3190 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/19") - 3191 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/20") - 3192 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/21") - 3193 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/22") - 3194 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/23") - 3195 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/24") - 3196 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-multiple-vars-in-nested-blocks/25") - 3197 # . epilogue - 3198 89/<- %esp 5/r32/ebp - 3199 5d/pop-to-ebp - 3200 c3/return - 3201 - 3202 test-convert-function-with-branches-and-local-vars: - 3203 # A conditional 'break' after a 'var' in a block is converted into a - 3204 # nested block that performs all necessary cleanup before jumping. This - 3205 # results in some ugly code duplication. - 3206 # . prologue - 3207 55/push-ebp - 3208 89/<- %ebp 4/r32/esp - 3209 # setup - 3210 (clear-stream _test-input-stream) - 3211 (clear-stream $_test-input-buffered-file->buffer) - 3212 (clear-stream _test-output-stream) - 3213 (clear-stream $_test-output-buffered-file->buffer) - 3214 # - 3215 (write _test-input-stream "fn foo {\n") - 3216 (write _test-input-stream " {\n") - 3217 (write _test-input-stream " var x: int\n") - 3218 (write _test-input-stream " break-if->=\n") - 3219 (write _test-input-stream " increment x\n") - 3220 (write _test-input-stream " }\n") - 3221 (write _test-input-stream "}\n") - 3222 # convert - 3223 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3224 (flush _test-output-buffered-file) - 3225 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3231 # check output - 3232 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") - 3233 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") - 3234 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-local-vars/2") - 3235 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-local-vars/3") - 3236 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/4") - 3237 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-local-vars/5") - 3238 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/6") - 3239 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-local-vars/7") - 3240 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-local-vars/8") - 3241 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/9") - 3242 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-local-vars/10") - 3243 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/11") - 3244 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-local-vars/12") - 3245 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/13") - 3246 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-local-vars/14") - 3247 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/15") - 3248 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/16") - 3249 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-local-vars/17") - 3250 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/18") - 3251 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-local-vars/19") - 3252 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-local-vars/20") - 3253 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-local-vars/21") - 3254 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-local-vars/22") - 3255 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-local-vars/23") - 3256 # . epilogue - 3257 89/<- %esp 5/r32/ebp - 3258 5d/pop-to-ebp - 3259 c3/return - 3260 - 3261 test-convert-function-with-conditional-loops-and-local-vars: - 3262 # A conditional 'loop' after a 'var' in a block is converted into a nested - 3263 # block that performs all necessary cleanup before jumping. This results - 3264 # in some ugly code duplication. - 3265 # . prologue - 3266 55/push-ebp - 3267 89/<- %ebp 4/r32/esp - 3268 # setup - 3269 (clear-stream _test-input-stream) - 3270 (clear-stream $_test-input-buffered-file->buffer) - 3271 (clear-stream _test-output-stream) - 3272 (clear-stream $_test-output-buffered-file->buffer) - 3273 # - 3274 (write _test-input-stream "fn foo {\n") - 3275 (write _test-input-stream " {\n") - 3276 (write _test-input-stream " var x: int\n") - 3277 (write _test-input-stream " loop-if->=\n") - 3278 (write _test-input-stream " increment x\n") - 3279 (write _test-input-stream " }\n") - 3280 (write _test-input-stream "}\n") - 3281 # convert - 3282 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3283 (flush _test-output-buffered-file) - 3284 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3290 # check output - 3291 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") - 3292 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") - 3293 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/2") - 3294 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-conditional-loops-and-local-vars/3") - 3295 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/4") - 3296 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/5") - 3297 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/6") - 3298 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/7") - 3299 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/8") - 3300 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/9") - 3301 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/10") - 3302 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/11") - 3303 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/12") - 3304 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/13") - 3305 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-conditional-loops-and-local-vars/14") - 3306 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/15") - 3307 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/16") - 3308 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/17") - 3309 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/18") - 3310 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/19") - 3311 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-conditional-loops-and-local-vars/20") - 3312 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/21") - 3313 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/22") - 3314 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-conditional-loops-and-local-vars/23") - 3315 # . epilogue - 3316 89/<- %esp 5/r32/ebp - 3317 5d/pop-to-ebp - 3318 c3/return - 3319 - 3320 test-convert-function-with-unconditional-loops-and-local-vars: - 3321 # An unconditional 'loop' after a 'var' in a block is emitted _after_ the - 3322 # regular block cleanup. Any instructions after 'loop' are dead and - 3323 # therefore skipped. - 3324 # . prologue - 3325 55/push-ebp - 3326 89/<- %ebp 4/r32/esp - 3327 # setup - 3328 (clear-stream _test-input-stream) - 3329 (clear-stream $_test-input-buffered-file->buffer) - 3330 (clear-stream _test-output-stream) - 3331 (clear-stream $_test-output-buffered-file->buffer) - 3332 # - 3333 (write _test-input-stream "fn foo {\n") - 3334 (write _test-input-stream " {\n") - 3335 (write _test-input-stream " var x: int\n") - 3336 (write _test-input-stream " loop\n") - 3337 (write _test-input-stream " increment x\n") - 3338 (write _test-input-stream " }\n") - 3339 (write _test-input-stream "}\n") - 3340 # convert - 3341 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3342 (flush _test-output-buffered-file) - 3343 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3349 # check output - 3350 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") - 3351 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") - 3352 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/2") - 3353 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-loops-and-local-vars/3") - 3354 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/4") - 3355 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/5") - 3356 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/6") - 3357 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/7") - 3358 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/8") - 3359 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/9") - 3360 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-unconditional-loops-and-local-vars/10") - 3361 # not emitted: ff 0/subop/increment *(ebp+0xfffffffc) - 3362 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/11") - 3363 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/12") - 3364 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/13") - 3365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/14") - 3366 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-loops-and-local-vars/15") - 3367 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/16") - 3368 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/17") - 3369 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-loops-and-local-vars/18") - 3370 # . epilogue - 3371 89/<- %esp 5/r32/ebp - 3372 5d/pop-to-ebp - 3373 c3/return - 3374 - 3375 test-convert-function-with-branches-and-loops-and-local-vars: - 3376 # . prologue - 3377 55/push-ebp - 3378 89/<- %ebp 4/r32/esp - 3379 # setup - 3380 (clear-stream _test-input-stream) - 3381 (clear-stream $_test-input-buffered-file->buffer) - 3382 (clear-stream _test-output-stream) - 3383 (clear-stream $_test-output-buffered-file->buffer) - 3384 # - 3385 (write _test-input-stream "fn foo {\n") - 3386 (write _test-input-stream " {\n") - 3387 (write _test-input-stream " var x: int\n") - 3388 (write _test-input-stream " break-if->=\n") - 3389 (write _test-input-stream " increment x\n") - 3390 (write _test-input-stream " loop\n") - 3391 (write _test-input-stream " }\n") - 3392 (write _test-input-stream "}\n") - 3393 # convert - 3394 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3395 (flush _test-output-buffered-file) - 3396 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3402 # check output - 3403 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") - 3404 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") - 3405 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/2") - 3406 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-loops-and-local-vars/3") - 3407 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/4") - 3408 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/5") - 3409 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/6") - 3410 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/7") - 3411 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/8") - 3412 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/9") - 3413 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/10") - 3414 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/11") - 3415 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/12") - 3416 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/13") - 3417 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-loops-and-local-vars/14") - 3418 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/15") - 3419 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/16") - 3420 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/17") - 3421 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/18") - 3422 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/19") - 3423 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/20") - 3424 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-loops-and-local-vars/21") - 3425 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/22") - 3426 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/23") - 3427 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-loops-and-local-vars/24") - 3428 # . epilogue - 3429 89/<- %esp 5/r32/ebp - 3430 5d/pop-to-ebp - 3431 c3/return - 3432 - 3433 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars: - 3434 # . prologue - 3435 55/push-ebp - 3436 89/<- %ebp 4/r32/esp - 3437 # setup - 3438 (clear-stream _test-input-stream) - 3439 (clear-stream $_test-input-buffered-file->buffer) - 3440 (clear-stream _test-output-stream) - 3441 (clear-stream $_test-output-buffered-file->buffer) - 3442 # - 3443 (write _test-input-stream "fn foo {\n") - 3444 (write _test-input-stream " a: {\n") - 3445 (write _test-input-stream " var x: int\n") - 3446 (write _test-input-stream " {\n") - 3447 (write _test-input-stream " var y: int\n") - 3448 (write _test-input-stream " break-if->= a\n") - 3449 (write _test-input-stream " increment x\n") - 3450 (write _test-input-stream " loop\n") - 3451 (write _test-input-stream " }\n") - 3452 (write _test-input-stream " }\n") - 3453 (write _test-input-stream "}\n") - 3454 # convert - 3455 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3456 (flush _test-output-buffered-file) - 3457 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3463 # check output - 3464 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") - 3465 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") - 3466 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/2") - 3467 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/3") - 3468 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/4") - 3469 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/5") - 3470 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/6") - 3471 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/7") - 3472 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/8") - 3473 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/9") - 3474 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/10") - 3475 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/11") - 3476 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/12") - 3477 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/13") - 3478 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/14") - 3479 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/15") - 3480 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/16") - 3481 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/17") - 3482 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/18") - 3483 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/19") - 3484 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/20") - 3485 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/21") - 3486 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/22") - 3487 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/23") - 3488 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/24") - 3489 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/25") - 3490 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/26") - 3491 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/27") - 3492 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/28") - 3493 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/29") - 3494 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/30") - 3495 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/31") - 3496 # . epilogue - 3497 89/<- %esp 5/r32/ebp - 3498 5d/pop-to-ebp - 3499 c3/return - 3500 - 3501 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2: - 3502 # . prologue - 3503 55/push-ebp - 3504 89/<- %ebp 4/r32/esp - 3505 # setup - 3506 (clear-stream _test-input-stream) - 3507 (clear-stream $_test-input-buffered-file->buffer) - 3508 (clear-stream _test-output-stream) - 3509 (clear-stream $_test-output-buffered-file->buffer) - 3510 # non-local conditional branch from a block without a local variable, - 3511 # unwinding a local on the stack - 3512 (write _test-input-stream "fn foo {\n") - 3513 (write _test-input-stream " a: {\n") - 3514 (write _test-input-stream " var x: int\n") - 3515 (write _test-input-stream " {\n") - 3516 (write _test-input-stream " break-if->= a\n") - 3517 (write _test-input-stream " }\n") - 3518 (write _test-input-stream " }\n") - 3519 (write _test-input-stream "}\n") - 3520 # convert - 3521 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3522 (flush _test-output-buffered-file) - 3523 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3529 # check output - 3530 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0") - 3531 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1") - 3532 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/2") - 3533 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/3") - 3534 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/4") - 3535 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/5") - 3536 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/6") - 3537 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/7") - 3538 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/8") - 3539 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/9") - 3540 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/10") - 3541 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/11") - 3542 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/12") - 3543 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/13") - 3544 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/14") - 3545 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/15") - 3546 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/16") - 3547 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/17") - 3548 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/18") - 3549 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/19") - 3550 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/20") - 3551 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/21") - 3552 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/22") - 3553 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/23") - 3554 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/24") - 3555 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/25") - 3556 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/26") - 3557 # . epilogue - 3558 89/<- %esp 5/r32/ebp - 3559 5d/pop-to-ebp - 3560 c3/return - 3561 - 3562 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3: - 3563 # . prologue - 3564 55/push-ebp - 3565 89/<- %ebp 4/r32/esp - 3566 # setup - 3567 (clear-stream _test-input-stream) - 3568 (clear-stream $_test-input-buffered-file->buffer) - 3569 (clear-stream _test-output-stream) - 3570 (clear-stream $_test-output-buffered-file->buffer) - 3571 # non-local unconditional branch from a block without a local variable, - 3572 # unwinding a local on the stack - 3573 (write _test-input-stream "fn foo {\n") - 3574 (write _test-input-stream " a: {\n") - 3575 (write _test-input-stream " var x: int\n") - 3576 (write _test-input-stream " {\n") - 3577 (write _test-input-stream " break a\n") - 3578 (write _test-input-stream " }\n") - 3579 (write _test-input-stream " }\n") - 3580 (write _test-input-stream "}\n") - 3581 # convert - 3582 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3583 (flush _test-output-buffered-file) - 3584 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3590 # check output - 3591 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0") - 3592 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1") - 3593 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/2") - 3594 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/3") - 3595 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/4") - 3596 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/5") - 3597 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/6") - 3598 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/7") - 3599 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/8") - 3600 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/9") - 3601 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/10") - 3602 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/11") - 3603 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/12") - 3604 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/14") - 3605 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/15") - 3606 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/16") - 3607 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/17") - 3608 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/18") - 3609 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/19") - 3610 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/20") - 3611 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/21") - 3612 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/22") - 3613 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/23") - 3614 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/24") - 3615 # . epilogue - 3616 89/<- %esp 5/r32/ebp - 3617 5d/pop-to-ebp - 3618 c3/return - 3619 - 3620 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4: - 3621 # . prologue - 3622 55/push-ebp - 3623 89/<- %ebp 4/r32/esp - 3624 # setup - 3625 (clear-stream _test-input-stream) - 3626 (clear-stream $_test-input-buffered-file->buffer) - 3627 (clear-stream _test-output-stream) - 3628 (clear-stream $_test-output-buffered-file->buffer) - 3629 # - 3630 (write _test-input-stream "fn foo {\n") - 3631 (write _test-input-stream " a: {\n") - 3632 (write _test-input-stream " var x/esi: int <- copy 0\n") - 3633 (write _test-input-stream " {\n") - 3634 (write _test-input-stream " break a\n") - 3635 (write _test-input-stream " }\n") - 3636 (write _test-input-stream " }\n") - 3637 (write _test-input-stream "}\n") - 3638 # convert - 3639 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3640 (flush _test-output-buffered-file) - 3641 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3647 # check output - 3648 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0") - 3649 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1") - 3650 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/2") - 3651 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/3") - 3652 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/4") - 3653 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/5") - 3654 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/6") - 3655 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/7") - 3656 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/8") - 3657 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/9") - 3658 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/10") - 3659 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/11") - 3660 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/12") - 3661 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/13") - 3662 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/14") - 3663 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/15") - 3664 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/16") - 3665 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/17") - 3666 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/18") - 3667 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/19") - 3668 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/20") - 3669 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/21") - 3670 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/22") - 3671 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/23") - 3672 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/24") - 3673 # . epilogue - 3674 89/<- %esp 5/r32/ebp - 3675 5d/pop-to-ebp - 3676 c3/return - 3677 - 3678 test-convert-function-with-nonlocal-unconditional-break-and-local-vars: - 3679 # . prologue - 3680 55/push-ebp - 3681 89/<- %ebp 4/r32/esp - 3682 # setup - 3683 (clear-stream _test-input-stream) - 3684 (clear-stream $_test-input-buffered-file->buffer) - 3685 (clear-stream _test-output-stream) - 3686 (clear-stream $_test-output-buffered-file->buffer) - 3687 # - 3688 (write _test-input-stream "fn foo {\n") - 3689 (write _test-input-stream " a: {\n") - 3690 (write _test-input-stream " var x: int\n") - 3691 (write _test-input-stream " {\n") - 3692 (write _test-input-stream " var y: int\n") - 3693 (write _test-input-stream " break a\n") - 3694 (write _test-input-stream " increment x\n") - 3695 (write _test-input-stream " }\n") - 3696 (write _test-input-stream " }\n") - 3697 (write _test-input-stream "}\n") - 3698 # convert - 3699 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3700 (flush _test-output-buffered-file) - 3701 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3707 # check output - 3708 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") - 3709 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") - 3710 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/2") - 3711 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/3") - 3712 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/4") - 3713 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/5") - 3714 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/6") - 3715 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/7") - 3716 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/8") - 3717 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/9") - 3718 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/10") - 3719 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/11") - 3720 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/12") - 3721 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/13") - 3722 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/14") - 3723 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/15") - 3724 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/16") - 3725 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/17") - 3726 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/18") - 3727 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/19") - 3728 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/20") - 3729 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/21") - 3730 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/22") - 3731 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/23") - 3732 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/24") - 3733 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/25") - 3734 # . epilogue - 3735 89/<- %esp 5/r32/ebp - 3736 5d/pop-to-ebp - 3737 c3/return - 3738 - 3739 test-convert-function-with-unconditional-break-and-local-vars: - 3740 # . prologue - 3741 55/push-ebp - 3742 89/<- %ebp 4/r32/esp - 3743 # setup - 3744 (clear-stream _test-input-stream) - 3745 (clear-stream $_test-input-buffered-file->buffer) - 3746 (clear-stream _test-output-stream) - 3747 (clear-stream $_test-output-buffered-file->buffer) - 3748 # - 3749 (write _test-input-stream "fn foo {\n") - 3750 (write _test-input-stream " {\n") - 3751 (write _test-input-stream " var x: int\n") - 3752 (write _test-input-stream " {\n") - 3753 (write _test-input-stream " var y: int\n") - 3754 (write _test-input-stream " break\n") - 3755 (write _test-input-stream " increment x\n") - 3756 (write _test-input-stream " }\n") - 3757 (write _test-input-stream " }\n") - 3758 (write _test-input-stream "}\n") - 3759 # convert - 3760 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3761 (flush _test-output-buffered-file) - 3762 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3768 # check output - 3769 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") - 3770 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") - 3771 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/2") - 3772 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-break-and-local-vars/3") - 3773 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/4") - 3774 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/5") - 3775 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/6") - 3776 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/7") - 3777 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/8") - 3778 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/9") - 3779 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/10") - 3780 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/11") - 3781 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/12") - 3782 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/13") - 3783 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/14") - 3784 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/15") - 3785 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/16") - 3786 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/17") - 3787 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/18") - 3788 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/19") - 3789 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-break-and-local-vars/20") - 3790 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/21") - 3791 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/22") - 3792 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-break-and-local-vars/23") - 3793 # . epilogue - 3794 89/<- %esp 5/r32/ebp - 3795 5d/pop-to-ebp - 3796 c3/return - 3797 - 3798 test-convert-function-with-nonlocal-unconditional-loop-and-local-vars: - 3799 # . prologue - 3800 55/push-ebp - 3801 89/<- %ebp 4/r32/esp - 3802 # setup - 3803 (clear-stream _test-input-stream) - 3804 (clear-stream $_test-input-buffered-file->buffer) - 3805 (clear-stream _test-output-stream) - 3806 (clear-stream $_test-output-buffered-file->buffer) - 3807 # - 3808 (write _test-input-stream "fn foo {\n") - 3809 (write _test-input-stream " a: {\n") - 3810 (write _test-input-stream " var x: int\n") - 3811 (write _test-input-stream " {\n") - 3812 (write _test-input-stream " var y: int\n") - 3813 (write _test-input-stream " loop a\n") - 3814 (write _test-input-stream " increment x\n") - 3815 (write _test-input-stream " }\n") - 3816 (write _test-input-stream " }\n") - 3817 (write _test-input-stream "}\n") - 3818 # convert - 3819 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3820 (flush _test-output-buffered-file) - 3821 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3827 # check output - 3828 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") - 3829 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") - 3830 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/2") - 3831 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/3") - 3832 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/4") - 3833 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/5") - 3834 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/6") - 3835 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/7") - 3836 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/8") - 3837 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/9") - 3838 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/10") - 3839 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/11") - 3840 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/12") - 3841 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/13") - 3842 (check-next-stream-line-equal _test-output-stream " e9/jump a:loop/disp32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/14") - 3843 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/15") - 3844 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/16") - 3845 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/17") - 3846 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/18") - 3847 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/19") - 3848 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/20") - 3849 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/21") - 3850 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/22") - 3851 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/23") - 3852 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/24") - 3853 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/25") - 3854 # . epilogue - 3855 89/<- %esp 5/r32/ebp - 3856 5d/pop-to-ebp - 3857 c3/return - 3858 - 3859 test-convert-function-with-local-array-var-in-mem: - 3860 # . prologue - 3861 55/push-ebp - 3862 89/<- %ebp 4/r32/esp - 3863 # setup - 3864 (clear-stream _test-input-stream) - 3865 (clear-stream $_test-input-buffered-file->buffer) - 3866 (clear-stream _test-output-stream) - 3867 (clear-stream $_test-output-buffered-file->buffer) - 3868 # - 3869 (write _test-input-stream "fn foo {\n") - 3870 (write _test-input-stream " var x: (array int 3)\n") - 3871 (write _test-input-stream "}\n") - 3872 # convert - 3873 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3874 (flush _test-output-buffered-file) - 3875 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3881 # check output - 3882 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") - 3883 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") - 3884 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-var-in-mem/2") - 3885 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-var-in-mem/3") - 3886 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-var-in-mem/4") - 3887 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-var-in-mem/5") - 3888 # define x - 3889 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-function-with-local-array-var-in-mem/7") - 3890 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-function-with-local-array-var-in-mem/8") - 3891 # reclaim x - 3892 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-function-with-local-array-var-in-mem/9") - 3893 # - 3894 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-var-in-mem/10") - 3895 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-var-in-mem/11") - 3896 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-var-in-mem/12") - 3897 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-var-in-mem/13") - 3898 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-var-in-mem/14") - 3899 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-var-in-mem/15") - 3900 # . epilogue - 3901 89/<- %esp 5/r32/ebp - 3902 5d/pop-to-ebp - 3903 c3/return - 3904 - 3905 test-array-size-in-hex: - 3906 # . prologue - 3907 55/push-ebp - 3908 89/<- %ebp 4/r32/esp - 3909 # setup - 3910 (clear-stream _test-input-stream) - 3911 (clear-stream $_test-input-buffered-file->buffer) - 3912 (clear-stream _test-output-stream) - 3913 (clear-stream $_test-output-buffered-file->buffer) - 3914 (clear-stream _test-error-stream) - 3915 (clear-stream $_test-error-buffered-file->buffer) - 3916 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 3917 68/push 0/imm32 - 3918 68/push 0/imm32 - 3919 89/<- %edx 4/r32/esp - 3920 (tailor-exit-descriptor %edx 0x10) - 3921 # - 3922 (write _test-input-stream "fn foo {\n") - 3923 (write _test-input-stream " var x: (array int 10)\n") - 3924 (write _test-input-stream "}\n") - 3925 # convert - 3926 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 3927 # registers except esp clobbered at this point - 3928 # restore ed - 3929 89/<- %edx 4/r32/esp - 3930 (flush _test-output-buffered-file) - 3931 (flush _test-error-buffered-file) - 3932 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 3938 # check output - 3939 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty") - 3940 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; either start '10' with a '0x' to be unambiguous, or convert it to decimal." "F - test-array-size-in-hex: error message") - 3941 # check that stop(1) was called - 3942 (check-ints-equal *(edx+4) 2 "F - test-array-size-in-hex: exit status") - 3943 # don't restore from ebp - 3944 81 0/subop/add %esp 8/imm32 + 2220 89/<- %esp 5/r32/ebp + 2221 5d/pop-to-ebp + 2222 c3/return + 2223 + 2224 test-unknown-variable: + 2225 # . prologue + 2226 55/push-ebp + 2227 89/<- %ebp 4/r32/esp + 2228 # setup + 2229 (clear-stream _test-input-stream) + 2230 (clear-stream $_test-input-buffered-file->buffer) + 2231 (clear-stream _test-output-stream) + 2232 (clear-stream $_test-output-buffered-file->buffer) + 2233 (clear-stream _test-error-stream) + 2234 (clear-stream $_test-error-buffered-file->buffer) + 2235 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2236 68/push 0/imm32 + 2237 68/push 0/imm32 + 2238 89/<- %edx 4/r32/esp + 2239 (tailor-exit-descriptor %edx 0x10) + 2240 # + 2241 (write _test-input-stream "fn foo {\n") + 2242 (write _test-input-stream " compare x, 0\n") + 2243 (write _test-input-stream "}\n") + 2244 # convert + 2245 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2246 # registers except esp clobbered at this point + 2247 # restore ed + 2248 89/<- %edx 4/r32/esp + 2249 (flush _test-output-buffered-file) + 2250 (flush _test-error-buffered-file) + 2251 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2257 # check output + 2258 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty") + 2259 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message") + 2260 # check that stop(1) was called + 2261 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable: exit status") + 2262 # don't restore from ebp + 2263 81 0/subop/add %esp 8/imm32 + 2264 # . epilogue + 2265 5d/pop-to-ebp + 2266 c3/return + 2267 + 2268 test-convert-function-with-local-var-in-block: + 2269 # . prologue + 2270 55/push-ebp + 2271 89/<- %ebp 4/r32/esp + 2272 # setup + 2273 (clear-stream _test-input-stream) + 2274 (clear-stream $_test-input-buffered-file->buffer) + 2275 (clear-stream _test-output-stream) + 2276 (clear-stream $_test-output-buffered-file->buffer) + 2277 # + 2278 (write _test-input-stream "fn foo {\n") + 2279 (write _test-input-stream " {\n") + 2280 (write _test-input-stream " var x: int\n") + 2281 (write _test-input-stream " increment x\n") + 2282 (write _test-input-stream " }\n") + 2283 (write _test-input-stream "}\n") + 2284 # convert + 2285 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2286 (flush _test-output-buffered-file) + 2287 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2293 # check output + 2294 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") + 2295 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") + 2296 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-block/2") + 2297 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-block/3") + 2298 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/4") + 2299 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-block/5") + 2300 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/6") + 2301 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-block/7") + 2302 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-block/8") + 2303 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-block/9") + 2304 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-block/10") + 2305 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/11") + 2306 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-block/12") + 2307 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/13") + 2308 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-block/14") + 2309 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-block/15") + 2310 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-block/16") + 2311 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-block/17") + 2312 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-block/18") + 2313 # . epilogue + 2314 89/<- %esp 5/r32/ebp + 2315 5d/pop-to-ebp + 2316 c3/return + 2317 + 2318 test-convert-function-with-local-var-in-named-block: + 2319 # . prologue + 2320 55/push-ebp + 2321 89/<- %ebp 4/r32/esp + 2322 # setup + 2323 (clear-stream _test-input-stream) + 2324 (clear-stream $_test-input-buffered-file->buffer) + 2325 (clear-stream _test-output-stream) + 2326 (clear-stream $_test-output-buffered-file->buffer) + 2327 # + 2328 (write _test-input-stream "fn foo {\n") + 2329 (write _test-input-stream " $bar: {\n") + 2330 (write _test-input-stream " var x: int\n") + 2331 (write _test-input-stream " increment x\n") + 2332 (write _test-input-stream " }\n") + 2333 (write _test-input-stream "}\n") + 2334 # convert + 2335 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2336 (flush _test-output-buffered-file) + 2337 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2343 # check output + 2344 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") + 2345 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") + 2346 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-named-block/2") + 2347 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-named-block/3") + 2348 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/4") + 2349 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-named-block/5") + 2350 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/6") + 2351 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-local-var-in-named-block/7") + 2352 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-named-block/8") + 2353 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-named-block/9") + 2354 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-named-block/10") + 2355 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/11") + 2356 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-local-var-in-named-block/12") + 2357 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/13") + 2358 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-named-block/14") + 2359 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-named-block/15") + 2360 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-named-block/16") + 2361 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-named-block/17") + 2362 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-named-block/18") + 2363 # . epilogue + 2364 89/<- %esp 5/r32/ebp + 2365 5d/pop-to-ebp + 2366 c3/return + 2367 + 2368 test-unknown-variable-in-named-block: + 2369 # . prologue + 2370 55/push-ebp + 2371 89/<- %ebp 4/r32/esp + 2372 # setup + 2373 (clear-stream _test-input-stream) + 2374 (clear-stream $_test-input-buffered-file->buffer) + 2375 (clear-stream _test-output-stream) + 2376 (clear-stream $_test-output-buffered-file->buffer) + 2377 (clear-stream _test-error-stream) + 2378 (clear-stream $_test-error-buffered-file->buffer) + 2379 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2380 68/push 0/imm32 + 2381 68/push 0/imm32 + 2382 89/<- %edx 4/r32/esp + 2383 (tailor-exit-descriptor %edx 0x10) + 2384 # + 2385 (write _test-input-stream "fn foo {\n") + 2386 (write _test-input-stream " $a: {\n") + 2387 (write _test-input-stream " compare x, 0\n") + 2388 (write _test-input-stream " }\n") + 2389 (write _test-input-stream "}\n") + 2390 # convert + 2391 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2392 # registers except esp clobbered at this point + 2393 # restore ed + 2394 89/<- %edx 4/r32/esp + 2395 (flush _test-output-buffered-file) + 2396 (flush _test-error-buffered-file) + 2397 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2403 # check output + 2404 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty") + 2405 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message") + 2406 # check that stop(1) was called + 2407 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable-in-named-block: exit status") + 2408 # don't restore from ebp + 2409 81 0/subop/add %esp 8/imm32 + 2410 # . epilogue + 2411 5d/pop-to-ebp + 2412 c3/return + 2413 + 2414 test-always-shadow-outermost-reg-vars-in-function: + 2415 # . prologue + 2416 55/push-ebp + 2417 89/<- %ebp 4/r32/esp + 2418 # setup + 2419 (clear-stream _test-input-stream) + 2420 (clear-stream $_test-input-buffered-file->buffer) + 2421 (clear-stream _test-output-stream) + 2422 (clear-stream $_test-output-buffered-file->buffer) + 2423 # + 2424 (write _test-input-stream "fn foo {\n") + 2425 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2426 (write _test-input-stream "}\n") + 2427 # convert + 2428 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2429 (flush _test-output-buffered-file) + 2430 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2436 # check output + 2437 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") + 2438 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") + 2439 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/2") + 2440 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-always-shadow-outermost-reg-vars-in-function/3") + 2441 (check-next-stream-line-equal _test-output-stream " {" "F - test-always-shadow-outermost-reg-vars-in-function/4") + 2442 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-always-shadow-outermost-reg-vars-in-function/5") + 2443 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") + 2444 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-always-shadow-outermost-reg-vars-in-function/8") + 2445 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") + 2446 (check-next-stream-line-equal _test-output-stream " }" "F - test-always-shadow-outermost-reg-vars-in-function/12") + 2447 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-always-shadow-outermost-reg-vars-in-function/13") + 2448 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-always-shadow-outermost-reg-vars-in-function/14") + 2449 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-always-shadow-outermost-reg-vars-in-function/15") + 2450 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/16") + 2451 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-always-shadow-outermost-reg-vars-in-function/17") + 2452 # . epilogue + 2453 89/<- %esp 5/r32/ebp + 2454 5d/pop-to-ebp + 2455 c3/return + 2456 + 2457 _pending-test-clobber-dead-local: + 2458 # . prologue + 2459 55/push-ebp + 2460 89/<- %ebp 4/r32/esp + 2461 # setup + 2462 (clear-stream _test-input-stream) + 2463 (clear-stream $_test-input-buffered-file->buffer) + 2464 (clear-stream _test-output-stream) + 2465 (clear-stream $_test-output-buffered-file->buffer) + 2466 # + 2467 (write _test-input-stream "fn foo {\n") + 2468 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2469 (write _test-input-stream " {\n") + 2470 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2471 (write _test-input-stream " }\n") + 2472 (write _test-input-stream "}\n") + 2473 # convert + 2474 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2475 (flush _test-output-buffered-file) + 2476 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2482 # check output + 2483 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-clobber-dead-local/0") + 2484 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-clobber-dead-local/1") + 2485 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-clobber-dead-local/2") + 2486 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-clobber-dead-local/3") + 2487 (check-next-stream-line-equal _test-output-stream " {" "F - test-clobber-dead-local/4") + 2488 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-clobber-dead-local/5") + 2489 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-clobber-dead-local/6") + 2490 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-clobber-dead-local/7") + 2491 (check-next-stream-line-equal _test-output-stream " {" "F - test-clobber-dead-local/8") + 2492 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-clobber-dead-local/9") + 2493 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-clobber-dead-local/10") # no push/pop here + 2494 (check-next-stream-line-equal _test-output-stream " }" "F - test-clobber-dead-local/11") + 2495 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-clobber-dead-local/12") + 2496 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-clobber-dead-local/13") + 2497 (check-next-stream-line-equal _test-output-stream " }" "F - test-clobber-dead-local/14") + 2498 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-clobber-dead-local/15") + 2499 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-clobber-dead-local/16") + 2500 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-clobber-dead-local/17") + 2501 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-clobber-dead-local/18") + 2502 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-clobber-dead-local/19") + 2503 # . epilogue + 2504 89/<- %esp 5/r32/ebp + 2505 5d/pop-to-ebp + 2506 c3/return + 2507 + 2508 test-shadow-live-local: + 2509 # . prologue + 2510 55/push-ebp + 2511 89/<- %ebp 4/r32/esp + 2512 # setup + 2513 (clear-stream _test-input-stream) + 2514 (clear-stream $_test-input-buffered-file->buffer) + 2515 (clear-stream _test-output-stream) + 2516 (clear-stream $_test-output-buffered-file->buffer) + 2517 # + 2518 (write _test-input-stream "fn foo {\n") + 2519 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2520 (write _test-input-stream " {\n") + 2521 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2522 (write _test-input-stream " }\n") + 2523 (write _test-input-stream " x <- increment\n") + 2524 (write _test-input-stream "}\n") + 2525 # convert + 2526 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2527 (flush _test-output-buffered-file) + 2528 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2534 # check output + 2535 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-local/0") + 2536 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-local/1") + 2537 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-live-local/2") + 2538 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-live-local/3") + 2539 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-local/4") + 2540 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-live-local/5") + 2541 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-local/6") + 2542 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-live-local/7") + 2543 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-local/8") + 2544 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-live-local/9") + 2545 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-local/10") + 2546 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-live-local/11") + 2547 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-local/12") + 2548 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-local/13") + 2549 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-live-local/14") + 2550 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-live-local/15") + 2551 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-local/16") + 2552 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-local/17") + 2553 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-live-local/18") + 2554 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-live-local/19") + 2555 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-live-local/20") + 2556 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-live-local/21") + 2557 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-live-local/22") + 2558 # . epilogue + 2559 89/<- %esp 5/r32/ebp + 2560 5d/pop-to-ebp + 2561 c3/return + 2562 + 2563 test-shadow-name: + 2564 # . prologue + 2565 55/push-ebp + 2566 89/<- %ebp 4/r32/esp + 2567 # setup + 2568 (clear-stream _test-input-stream) + 2569 (clear-stream $_test-input-buffered-file->buffer) + 2570 (clear-stream _test-output-stream) + 2571 (clear-stream $_test-output-buffered-file->buffer) + 2572 # + 2573 (write _test-input-stream "fn foo {\n") + 2574 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2575 (write _test-input-stream " {\n") + 2576 (write _test-input-stream " var x/edx: int <- copy 4\n") + 2577 (write _test-input-stream " }\n") + 2578 (write _test-input-stream " x <- increment\n") + 2579 (write _test-input-stream "}\n") + 2580 # convert + 2581 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2582 (flush _test-output-buffered-file) + 2583 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2589 # check output + 2590 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0") + 2591 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1") + 2592 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name/2") + 2593 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name/3") + 2594 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/4") + 2595 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name/5") + 2596 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name/6") + 2597 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name/7") + 2598 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/8") + 2599 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name/9") + 2600 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name/10") + 2601 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name/11") + 2602 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name/12") + 2603 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/13") + 2604 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name/14") + 2605 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name/15") + 2606 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name/16") + 2607 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/17") + 2608 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name/18") + 2609 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name/19") + 2610 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name/20") + 2611 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name/21") + 2612 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name/22") + 2613 # . epilogue + 2614 89/<- %esp 5/r32/ebp + 2615 5d/pop-to-ebp + 2616 c3/return + 2617 + 2618 test-shadow-name-2: + 2619 # . prologue + 2620 55/push-ebp + 2621 89/<- %ebp 4/r32/esp + 2622 # setup + 2623 (clear-stream _test-input-stream) + 2624 (clear-stream $_test-input-buffered-file->buffer) + 2625 (clear-stream _test-output-stream) + 2626 (clear-stream $_test-output-buffered-file->buffer) + 2627 # + 2628 (write _test-input-stream "fn foo {\n") + 2629 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2630 (write _test-input-stream " {\n") + 2631 (write _test-input-stream " var x/edx: int <- copy 4\n") + 2632 (write _test-input-stream " var y/ecx: int <- copy 5\n") + 2633 (write _test-input-stream " }\n") + 2634 (write _test-input-stream " x <- increment\n") + 2635 (write _test-input-stream "}\n") + 2636 # convert + 2637 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2638 (flush _test-output-buffered-file) + 2639 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2645 # check output + 2646 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0") + 2647 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1") + 2648 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name-2/2") + 2649 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name-2/3") + 2650 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/4") + 2651 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name-2/5") + 2652 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/6") + 2653 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name-2/7") + 2654 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/8") + 2655 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name-2/9") + 2656 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name-2/10") + 2657 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name-2/11") + 2658 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/12") + 2659 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 5/imm32" "F - test-shadow-name-2/13") + 2660 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/14") + 2661 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name-2/15") + 2662 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/16") + 2663 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name-2/17") + 2664 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name-2/18") + 2665 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/19") + 2666 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/20") + 2667 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name-2/21") + 2668 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name-2/22") + 2669 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name-2/23") + 2670 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name-2/24") + 2671 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name-2/25") + 2672 # . epilogue + 2673 89/<- %esp 5/r32/ebp + 2674 5d/pop-to-ebp + 2675 c3/return + 2676 + 2677 test-do-not-spill-same-register-in-block: + 2678 # . prologue + 2679 55/push-ebp + 2680 89/<- %ebp 4/r32/esp + 2681 # setup + 2682 (clear-stream _test-input-stream) + 2683 (clear-stream $_test-input-buffered-file->buffer) + 2684 (clear-stream _test-output-stream) + 2685 (clear-stream $_test-output-buffered-file->buffer) + 2686 # + 2687 (write _test-input-stream "fn foo {\n") + 2688 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2689 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2690 (write _test-input-stream " y <- increment\n") + 2691 (write _test-input-stream "}\n") + 2692 # convert + 2693 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2694 (flush _test-output-buffered-file) + 2695 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2701 # check output + 2702 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") + 2703 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") + 2704 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-do-not-spill-same-register-in-block/2") + 2705 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-do-not-spill-same-register-in-block/3") + 2706 (check-next-stream-line-equal _test-output-stream " {" "F - test-do-not-spill-same-register-in-block/4") + 2707 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-do-not-spill-same-register-in-block/5") + 2708 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-do-not-spill-same-register-in-block/6") + 2709 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-do-not-spill-same-register-in-block/7") + 2710 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-do-not-spill-same-register-in-block/8") + 2711 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-do-not-spill-same-register-in-block/9") + 2712 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-do-not-spill-same-register-in-block/10") + 2713 (check-next-stream-line-equal _test-output-stream " }" "F - test-do-not-spill-same-register-in-block/11") + 2714 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-do-not-spill-same-register-in-block/12") + 2715 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-do-not-spill-same-register-in-block/13") + 2716 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-do-not-spill-same-register-in-block/14") + 2717 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-do-not-spill-same-register-in-block/15") + 2718 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-do-not-spill-same-register-in-block/16") + 2719 # . epilogue + 2720 89/<- %esp 5/r32/ebp + 2721 5d/pop-to-ebp + 2722 c3/return + 2723 + 2724 test-spill-different-register-in-block: + 2725 # . prologue + 2726 55/push-ebp + 2727 89/<- %ebp 4/r32/esp + 2728 # setup + 2729 (clear-stream _test-input-stream) + 2730 (clear-stream $_test-input-buffered-file->buffer) + 2731 (clear-stream _test-output-stream) + 2732 (clear-stream $_test-output-buffered-file->buffer) + 2733 # + 2734 (write _test-input-stream "fn foo {\n") + 2735 (write _test-input-stream " var x/eax: int <- copy 3\n") + 2736 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2737 (write _test-input-stream " y <- increment\n") + 2738 (write _test-input-stream "}\n") + 2739 # convert + 2740 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2741 (flush _test-output-buffered-file) + 2742 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2748 # check output + 2749 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") + 2750 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") + 2751 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-spill-different-register-in-block/2") + 2752 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-spill-different-register-in-block/3") + 2753 (check-next-stream-line-equal _test-output-stream " {" "F - test-spill-different-register-in-block/4") + 2754 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-spill-different-register-in-block/5") + 2755 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-spill-different-register-in-block/6") + 2756 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-spill-different-register-in-block/7") + 2757 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-spill-different-register-in-block/8") + 2758 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-spill-different-register-in-block/9") + 2759 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-spill-different-register-in-block/10") + 2760 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-spill-different-register-in-block/11") + 2761 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-spill-different-register-in-block/12") + 2762 (check-next-stream-line-equal _test-output-stream " }" "F - test-spill-different-register-in-block/13") + 2763 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-spill-different-register-in-block/14") + 2764 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-spill-different-register-in-block/15") + 2765 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-spill-different-register-in-block/16") + 2766 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-spill-different-register-in-block/17") + 2767 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-spill-different-register-in-block/18") + 2768 # . epilogue + 2769 89/<- %esp 5/r32/ebp + 2770 5d/pop-to-ebp + 2771 c3/return + 2772 + 2773 test-shadow-live-output: + 2774 # . prologue + 2775 55/push-ebp + 2776 89/<- %ebp 4/r32/esp + 2777 # setup + 2778 (clear-stream _test-input-stream) + 2779 (clear-stream $_test-input-buffered-file->buffer) + 2780 (clear-stream _test-output-stream) + 2781 (clear-stream $_test-output-buffered-file->buffer) + 2782 # + 2783 (write _test-input-stream "fn foo -> x/ecx: int {\n") + 2784 (write _test-input-stream " x <- copy 3\n") + 2785 (write _test-input-stream " {\n") + 2786 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2787 (write _test-input-stream " }\n") + 2788 (write _test-input-stream " x <- increment\n") + 2789 (write _test-input-stream "}\n") + 2790 # convert + 2791 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2792 (flush _test-output-buffered-file) + 2793 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2799 # check output + 2800 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-output/0") + 2801 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-output/1") + 2802 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-live-output/2") + 2803 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-live-output/3") + 2804 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-output/4") + 2805 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-live-output/5") + 2806 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-live-output/7") # no push because it's an output reg + 2807 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-live-output/8") + 2808 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-live-output/9") + 2809 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-live-output/10") + 2810 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-live-output/11") + 2811 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-live-output/12") + 2812 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-output/13") + 2813 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-live-output/14") + 2814 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-live-output/15") + 2815 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-live-output/17") + 2816 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-live-output/18") + 2817 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-live-output/19") + 2818 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-live-output/20") + 2819 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-live-output/21") + 2820 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-live-output/21") + 2821 # . epilogue + 2822 89/<- %esp 5/r32/ebp + 2823 5d/pop-to-ebp + 2824 c3/return + 2825 + 2826 test-stmt-defines-output-in-same-register-as-inout: + 2827 # . prologue + 2828 55/push-ebp + 2829 89/<- %ebp 4/r32/esp + 2830 # setup + 2831 (clear-stream _test-input-stream) + 2832 (clear-stream $_test-input-buffered-file->buffer) + 2833 (clear-stream _test-output-stream) + 2834 (clear-stream $_test-output-buffered-file->buffer) + 2835 (clear-stream _test-error-stream) + 2836 (clear-stream $_test-error-buffered-file->buffer) + 2837 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2838 68/push 0/imm32 + 2839 68/push 0/imm32 + 2840 89/<- %edx 4/r32/esp + 2841 (tailor-exit-descriptor %edx 0x10) + 2842 # + 2843 (write _test-input-stream "fn foo -> x/ecx: int {\n") + 2844 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2845 (write _test-input-stream " x <- copy y\n") # writing to a fn output is currently the only way for a statement to define a new var + 2846 (write _test-input-stream "}\n") + 2847 # convert + 2848 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2849 # registers except esp clobbered at this point + 2850 # restore ed + 2851 89/<- %edx 4/r32/esp + 2852 (flush _test-output-buffered-file) + 2853 (flush _test-error-buffered-file) + 2854 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 2860 # no error; we looked up 'y' correctly before pushing the binding for 'x' + 2861 (check-stream-equal _test-error-stream "" "F - test-stmt-defines-output-in-same-register-as-inout: error stream should be empty") + 2862 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below + 2863 # don't restore from ebp + 2864 81 0/subop/add %esp 8/imm32 + 2865 # . epilogue + 2866 5d/pop-to-ebp + 2867 c3/return + 2868 + 2869 test-local-clobbered-by-fn-output: + 2870 # . prologue + 2871 55/push-ebp + 2872 89/<- %ebp 4/r32/esp + 2873 # setup + 2874 (clear-stream _test-input-stream) + 2875 (clear-stream $_test-input-buffered-file->buffer) + 2876 (clear-stream _test-output-stream) + 2877 (clear-stream $_test-output-buffered-file->buffer) + 2878 # + 2879 (write _test-input-stream "fn foo -> x/ecx: int {\n") + 2880 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2881 (write _test-input-stream " x <- copy y\n") + 2882 (write _test-input-stream "}\n") + 2883 # convert + 2884 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2885 (flush _test-output-buffered-file) + 2886 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2892 # check output + 2893 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-local-clobbered-by-fn-output/0") + 2894 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-local-clobbered-by-fn-output/1") + 2895 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-local-clobbered-by-fn-output/2") + 2896 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-local-clobbered-by-fn-output/3") + 2897 (check-next-stream-line-equal _test-output-stream " {" "F - test-local-clobbered-by-fn-output/4") + 2898 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-local-clobbered-by-fn-output/5") + 2899 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-local-clobbered-by-fn-output/6") # no push because it's an output reg + 2900 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0x00000001/r32" "F - test-local-clobbered-by-fn-output/7") + 2901 (check-next-stream-line-equal _test-output-stream " }" "F - test-local-clobbered-by-fn-output/8") + 2902 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-local-clobbered-by-fn-output/9") + 2903 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-local-clobbered-by-fn-output/10") + 2904 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-local-clobbered-by-fn-output/11") + 2905 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-local-clobbered-by-fn-output/12") + 2906 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-local-clobbered-by-fn-output/13") + 2907 # . epilogue + 2908 89/<- %esp 5/r32/ebp + 2909 5d/pop-to-ebp + 2910 c3/return + 2911 + 2912 test-read-output: + 2913 # . prologue + 2914 55/push-ebp + 2915 89/<- %ebp 4/r32/esp + 2916 # setup + 2917 (clear-stream _test-input-stream) + 2918 (clear-stream $_test-input-buffered-file->buffer) + 2919 (clear-stream _test-output-stream) + 2920 (clear-stream $_test-output-buffered-file->buffer) + 2921 # + 2922 (write _test-input-stream "fn foo -> x/ecx: int {\n") + 2923 (write _test-input-stream " x <- copy 0x34\n") + 2924 (write _test-input-stream " compare x, 0x35\n") + 2925 (write _test-input-stream "}\n") + 2926 # convert + 2927 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2928 (flush _test-output-buffered-file) + 2929 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2935 # check output + 2936 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-read-output/0") + 2937 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-read-output/1") + 2938 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-read-output/2") + 2939 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-read-output/3") + 2940 (check-next-stream-line-equal _test-output-stream " {" "F - test-read-output/4") + 2941 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-read-output/5") + 2942 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x34/imm32" "F - test-read-output/6") + 2943 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0x35/imm32" "F - test-read-output/7") + 2944 (check-next-stream-line-equal _test-output-stream " }" "F - test-read-output/8") + 2945 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-read-output/9") + 2946 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-read-output/10") + 2947 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-read-output/11") + 2948 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-read-output/12") + 2949 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-read-output/13") + 2950 # . epilogue + 2951 89/<- %esp 5/r32/ebp + 2952 5d/pop-to-ebp + 2953 c3/return + 2954 + 2955 test-fn-output-written-in-inner-block: + 2956 # . prologue + 2957 55/push-ebp + 2958 89/<- %ebp 4/r32/esp + 2959 # setup + 2960 (clear-stream _test-input-stream) + 2961 (clear-stream $_test-input-buffered-file->buffer) + 2962 (clear-stream _test-output-stream) + 2963 (clear-stream $_test-output-buffered-file->buffer) + 2964 # + 2965 (write _test-input-stream "fn foo -> out/edi: int {\n") + 2966 (write _test-input-stream " var a/eax: int <- copy 3\n") # define outer local + 2967 (write _test-input-stream " {\n") + 2968 (write _test-input-stream " var a/ecx: int <- copy 4\n") # shadow outer local + 2969 (write _test-input-stream " out <- copy a\n") # write to fn output + 2970 (write _test-input-stream " }\n") + 2971 (write _test-input-stream " compare a, 0\n") # use outer local + 2972 (write _test-input-stream "}\n") + 2973 # convert + 2974 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2975 (flush _test-output-buffered-file) + 2976 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2982 # no error; defining 'out' didn't interfere with the reclamation of 'b' + 2983 # check output + 2984 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-fn-output-written-in-inner-block/0") + 2985 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-fn-output-written-in-inner-block/1") + 2986 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-fn-output-written-in-inner-block/2") + 2987 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-fn-output-written-in-inner-block/3") + 2988 (check-next-stream-line-equal _test-output-stream " {" "F - test-fn-output-written-in-inner-block/4") + 2989 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-fn-output-written-in-inner-block/5") + 2990 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-fn-output-written-in-inner-block/6") + 2991 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-fn-output-written-in-inner-block/7") + 2992 (check-next-stream-line-equal _test-output-stream " {" "F - test-fn-output-written-in-inner-block/8") + 2993 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-fn-output-written-in-inner-block/9") + 2994 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-fn-output-written-in-inner-block/10") + 2995 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-fn-output-written-in-inner-block/10") + 2996 (check-next-stream-line-equal _test-output-stream " 89/<- %edi 0x00000001/r32" "F - test-fn-output-written-in-inner-block/11") + 2997 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-fn-output-written-in-inner-block/12") + 2998 (check-next-stream-line-equal _test-output-stream " }" "F - test-fn-output-written-in-inner-block/13") + 2999 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-fn-output-written-in-inner-block/14") + 3000 (check-next-stream-line-equal _test-output-stream " 3d/compare-eax-with 0/imm32" "F - test-fn-output-written-in-inner-block/15") + 3001 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-fn-output-written-in-inner-block/16") + 3002 (check-next-stream-line-equal _test-output-stream " }" "F - test-fn-output-written-in-inner-block/17") + 3003 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-fn-output-written-in-inner-block/18") + 3004 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-fn-output-written-in-inner-block/19") + 3005 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-fn-output-written-in-inner-block/20") + 3006 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-fn-output-written-in-inner-block/21") + 3007 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-fn-output-written-in-inner-block/22") + 3008 # . epilogue + 3009 89/<- %esp 5/r32/ebp + 3010 5d/pop-to-ebp + 3011 c3/return + 3012 + 3013 test-convert-function-with-branches-in-block: + 3014 # . prologue + 3015 55/push-ebp + 3016 89/<- %ebp 4/r32/esp + 3017 # setup + 3018 (clear-stream _test-input-stream) + 3019 (clear-stream $_test-input-buffered-file->buffer) + 3020 (clear-stream _test-output-stream) + 3021 (clear-stream $_test-output-buffered-file->buffer) + 3022 # + 3023 (write _test-input-stream "fn foo x: int {\n") + 3024 (write _test-input-stream " {\n") + 3025 (write _test-input-stream " break-if->=\n") + 3026 (write _test-input-stream " loop-if-addr<\n") + 3027 (write _test-input-stream " increment x\n") + 3028 (write _test-input-stream " loop\n") + 3029 (write _test-input-stream " }\n") + 3030 (write _test-input-stream "}\n") + 3031 # convert + 3032 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3033 (flush _test-output-buffered-file) + 3034 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3040 # check output + 3041 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") + 3042 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") + 3043 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") + 3044 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") + 3045 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") + 3046 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") + 3047 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") + 3048 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") + 3049 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") + 3050 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") + 3051 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") + 3052 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") + 3053 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") + 3054 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") + 3055 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") + 3056 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") + 3057 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") + 3058 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") + 3059 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") + 3060 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") + 3061 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") + 3062 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") + 3063 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") + 3064 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") + 3065 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") + 3066 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") + 3067 # . epilogue + 3068 89/<- %esp 5/r32/ebp + 3069 5d/pop-to-ebp + 3070 c3/return + 3071 + 3072 test-convert-function-with-branches-in-named-block: + 3073 # . prologue + 3074 55/push-ebp + 3075 89/<- %ebp 4/r32/esp + 3076 # setup + 3077 (clear-stream _test-input-stream) + 3078 (clear-stream $_test-input-buffered-file->buffer) + 3079 (clear-stream _test-output-stream) + 3080 (clear-stream $_test-output-buffered-file->buffer) + 3081 # + 3082 (write _test-input-stream "fn foo x: int {\n") + 3083 (write _test-input-stream " $bar: {\n") + 3084 (write _test-input-stream " break-if->= $bar\n") + 3085 (write _test-input-stream " loop-if-addr< $bar\n") + 3086 (write _test-input-stream " increment x\n") + 3087 (write _test-input-stream " loop\n") + 3088 (write _test-input-stream " }\n") + 3089 (write _test-input-stream "}\n") + 3090 # convert + 3091 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3092 (flush _test-output-buffered-file) + 3093 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3099 # check output + 3100 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") + 3101 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") + 3102 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-named-block/2") + 3103 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-named-block/3") + 3104 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/4") + 3105 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-named-block/5") + 3106 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/6") + 3107 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-branches-in-named-block/7") + 3108 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/8") + 3109 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-named-block/9") + 3110 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:break/disp32" "F - test-convert-function-with-branches-in-named-block/10") + 3111 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/11") + 3112 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/12") + 3113 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-named-block/13") + 3114 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:loop/disp32" "F - test-convert-function-with-branches-in-named-block/14") + 3115 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/15") + 3116 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-named-block/16") + 3117 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-named-block/17") + 3118 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/18") + 3119 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-branches-in-named-block/19") + 3120 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/20") + 3121 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-named-block/21") + 3122 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-named-block/22") + 3123 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-named-block/23") + 3124 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-named-block/24") + 3125 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-named-block/25") + 3126 # . epilogue + 3127 89/<- %esp 5/r32/ebp + 3128 5d/pop-to-ebp + 3129 c3/return + 3130 + 3131 test-convert-function-with-var-in-nested-block: + 3132 # . prologue + 3133 55/push-ebp + 3134 89/<- %ebp 4/r32/esp + 3135 # setup + 3136 (clear-stream _test-input-stream) + 3137 (clear-stream $_test-input-buffered-file->buffer) + 3138 (clear-stream _test-output-stream) + 3139 (clear-stream $_test-output-buffered-file->buffer) + 3140 # + 3141 (write _test-input-stream "fn foo x: int {\n") + 3142 (write _test-input-stream " {\n") + 3143 (write _test-input-stream " {\n") + 3144 (write _test-input-stream " var x: int\n") + 3145 (write _test-input-stream " increment x\n") + 3146 (write _test-input-stream " }\n") + 3147 (write _test-input-stream " }\n") + 3148 (write _test-input-stream "}\n") + 3149 # convert + 3150 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3151 (flush _test-output-buffered-file) + 3152 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3158 # check output + 3159 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") + 3160 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") + 3161 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-var-in-nested-block/2") + 3162 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-var-in-nested-block/3") + 3163 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/4") + 3164 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-var-in-nested-block/5") + 3165 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/6") + 3166 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-var-in-nested-block/7") + 3167 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/8") + 3168 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-var-in-nested-block/9") + 3169 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-var-in-nested-block/10") + 3170 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-var-in-nested-block/11") + 3171 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-var-in-nested-block/12") + 3172 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/13") + 3173 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-var-in-nested-block/14") + 3174 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/15") + 3175 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-var-in-nested-block/16") + 3176 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/17") + 3177 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-var-in-nested-block/18") + 3178 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-var-in-nested-block/19") + 3179 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-var-in-nested-block/20") + 3180 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-var-in-nested-block/21") + 3181 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-var-in-nested-block/22") + 3182 # . epilogue + 3183 89/<- %esp 5/r32/ebp + 3184 5d/pop-to-ebp + 3185 c3/return + 3186 + 3187 test-convert-function-with-multiple-vars-in-nested-blocks: + 3188 # . prologue + 3189 55/push-ebp + 3190 89/<- %ebp 4/r32/esp + 3191 # setup + 3192 (clear-stream _test-input-stream) + 3193 (clear-stream $_test-input-buffered-file->buffer) + 3194 (clear-stream _test-output-stream) + 3195 (clear-stream $_test-output-buffered-file->buffer) + 3196 # + 3197 (write _test-input-stream "fn foo x: int {\n") + 3198 (write _test-input-stream " {\n") + 3199 (write _test-input-stream " var x/eax: int <- copy 0\n") + 3200 (write _test-input-stream " {\n") + 3201 (write _test-input-stream " var y: int\n") + 3202 (write _test-input-stream " x <- add y\n") + 3203 (write _test-input-stream " }\n") + 3204 (write _test-input-stream " }\n") + 3205 (write _test-input-stream "}\n") + 3206 # convert + 3207 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3208 (flush _test-output-buffered-file) + 3209 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3215 # check output + 3216 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") + 3217 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") + 3218 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/2") + 3219 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/3") + 3220 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/4") + 3221 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/5") + 3222 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/6") + 3223 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/7") + 3224 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/8") + 3225 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/9") + 3226 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/10") + 3227 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/11") + 3228 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/12") + 3229 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/13") + 3230 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/14") + 3231 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/15") + 3232 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/16") + 3233 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/17") + 3234 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/18") + 3235 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/19") + 3236 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/20") + 3237 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/21") + 3238 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/22") + 3239 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/23") + 3240 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/24") + 3241 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-multiple-vars-in-nested-blocks/25") + 3242 # . epilogue + 3243 89/<- %esp 5/r32/ebp + 3244 5d/pop-to-ebp + 3245 c3/return + 3246 + 3247 test-convert-function-with-branches-and-local-vars: + 3248 # A conditional 'break' after a 'var' in a block is converted into a + 3249 # nested block that performs all necessary cleanup before jumping. This + 3250 # results in some ugly code duplication. + 3251 # . prologue + 3252 55/push-ebp + 3253 89/<- %ebp 4/r32/esp + 3254 # setup + 3255 (clear-stream _test-input-stream) + 3256 (clear-stream $_test-input-buffered-file->buffer) + 3257 (clear-stream _test-output-stream) + 3258 (clear-stream $_test-output-buffered-file->buffer) + 3259 # + 3260 (write _test-input-stream "fn foo {\n") + 3261 (write _test-input-stream " {\n") + 3262 (write _test-input-stream " var x: int\n") + 3263 (write _test-input-stream " break-if->=\n") + 3264 (write _test-input-stream " increment x\n") + 3265 (write _test-input-stream " }\n") + 3266 (write _test-input-stream "}\n") + 3267 # convert + 3268 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3269 (flush _test-output-buffered-file) + 3270 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3276 # check output + 3277 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") + 3278 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") + 3279 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-local-vars/2") + 3280 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-local-vars/3") + 3281 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/4") + 3282 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-local-vars/5") + 3283 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/6") + 3284 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-local-vars/7") + 3285 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-local-vars/8") + 3286 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/9") + 3287 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-local-vars/10") + 3288 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/11") + 3289 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-local-vars/12") + 3290 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/13") + 3291 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-local-vars/14") + 3292 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/15") + 3293 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/16") + 3294 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-local-vars/17") + 3295 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/18") + 3296 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-local-vars/19") + 3297 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-local-vars/20") + 3298 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-local-vars/21") + 3299 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-local-vars/22") + 3300 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-local-vars/23") + 3301 # . epilogue + 3302 89/<- %esp 5/r32/ebp + 3303 5d/pop-to-ebp + 3304 c3/return + 3305 + 3306 test-convert-function-with-conditional-loops-and-local-vars: + 3307 # A conditional 'loop' after a 'var' in a block is converted into a nested + 3308 # block that performs all necessary cleanup before jumping. This results + 3309 # in some ugly code duplication. + 3310 # . prologue + 3311 55/push-ebp + 3312 89/<- %ebp 4/r32/esp + 3313 # setup + 3314 (clear-stream _test-input-stream) + 3315 (clear-stream $_test-input-buffered-file->buffer) + 3316 (clear-stream _test-output-stream) + 3317 (clear-stream $_test-output-buffered-file->buffer) + 3318 # + 3319 (write _test-input-stream "fn foo {\n") + 3320 (write _test-input-stream " {\n") + 3321 (write _test-input-stream " var x: int\n") + 3322 (write _test-input-stream " loop-if->=\n") + 3323 (write _test-input-stream " increment x\n") + 3324 (write _test-input-stream " }\n") + 3325 (write _test-input-stream "}\n") + 3326 # convert + 3327 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3328 (flush _test-output-buffered-file) + 3329 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3335 # check output + 3336 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") + 3337 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") + 3338 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/2") + 3339 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-conditional-loops-and-local-vars/3") + 3340 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/4") + 3341 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/5") + 3342 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/6") + 3343 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/7") + 3344 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/8") + 3345 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/9") + 3346 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/10") + 3347 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/11") + 3348 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/12") + 3349 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/13") + 3350 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-conditional-loops-and-local-vars/14") + 3351 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/15") + 3352 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/16") + 3353 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/17") + 3354 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/18") + 3355 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/19") + 3356 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-conditional-loops-and-local-vars/20") + 3357 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/21") + 3358 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/22") + 3359 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-conditional-loops-and-local-vars/23") + 3360 # . epilogue + 3361 89/<- %esp 5/r32/ebp + 3362 5d/pop-to-ebp + 3363 c3/return + 3364 + 3365 test-convert-function-with-unconditional-loops-and-local-vars: + 3366 # An unconditional 'loop' after a 'var' in a block is emitted _after_ the + 3367 # regular block cleanup. Any instructions after 'loop' are dead and + 3368 # therefore skipped. + 3369 # . prologue + 3370 55/push-ebp + 3371 89/<- %ebp 4/r32/esp + 3372 # setup + 3373 (clear-stream _test-input-stream) + 3374 (clear-stream $_test-input-buffered-file->buffer) + 3375 (clear-stream _test-output-stream) + 3376 (clear-stream $_test-output-buffered-file->buffer) + 3377 # + 3378 (write _test-input-stream "fn foo {\n") + 3379 (write _test-input-stream " {\n") + 3380 (write _test-input-stream " var x: int\n") + 3381 (write _test-input-stream " loop\n") + 3382 (write _test-input-stream " increment x\n") + 3383 (write _test-input-stream " }\n") + 3384 (write _test-input-stream "}\n") + 3385 # convert + 3386 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3387 (flush _test-output-buffered-file) + 3388 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3394 # check output + 3395 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") + 3396 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") + 3397 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/2") + 3398 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-loops-and-local-vars/3") + 3399 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/4") + 3400 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/5") + 3401 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/6") + 3402 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/7") + 3403 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/8") + 3404 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/9") + 3405 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-unconditional-loops-and-local-vars/10") + 3406 # not emitted: ff 0/subop/increment *(ebp+0xfffffffc) + 3407 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/11") + 3408 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/12") + 3409 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/13") + 3410 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/14") + 3411 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-loops-and-local-vars/15") + 3412 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/16") + 3413 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/17") + 3414 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-loops-and-local-vars/18") + 3415 # . epilogue + 3416 89/<- %esp 5/r32/ebp + 3417 5d/pop-to-ebp + 3418 c3/return + 3419 + 3420 test-convert-function-with-branches-and-loops-and-local-vars: + 3421 # . prologue + 3422 55/push-ebp + 3423 89/<- %ebp 4/r32/esp + 3424 # setup + 3425 (clear-stream _test-input-stream) + 3426 (clear-stream $_test-input-buffered-file->buffer) + 3427 (clear-stream _test-output-stream) + 3428 (clear-stream $_test-output-buffered-file->buffer) + 3429 # + 3430 (write _test-input-stream "fn foo {\n") + 3431 (write _test-input-stream " {\n") + 3432 (write _test-input-stream " var x: int\n") + 3433 (write _test-input-stream " break-if->=\n") + 3434 (write _test-input-stream " increment x\n") + 3435 (write _test-input-stream " loop\n") + 3436 (write _test-input-stream " }\n") + 3437 (write _test-input-stream "}\n") + 3438 # convert + 3439 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3440 (flush _test-output-buffered-file) + 3441 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3447 # check output + 3448 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") + 3449 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") + 3450 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/2") + 3451 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-loops-and-local-vars/3") + 3452 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/4") + 3453 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/5") + 3454 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/6") + 3455 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/7") + 3456 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/8") + 3457 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/9") + 3458 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/10") + 3459 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/11") + 3460 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/12") + 3461 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/13") + 3462 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-loops-and-local-vars/14") + 3463 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/15") + 3464 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/16") + 3465 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/17") + 3466 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/18") + 3467 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/19") + 3468 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/20") + 3469 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-loops-and-local-vars/21") + 3470 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/22") + 3471 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/23") + 3472 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-loops-and-local-vars/24") + 3473 # . epilogue + 3474 89/<- %esp 5/r32/ebp + 3475 5d/pop-to-ebp + 3476 c3/return + 3477 + 3478 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars: + 3479 # . prologue + 3480 55/push-ebp + 3481 89/<- %ebp 4/r32/esp + 3482 # setup + 3483 (clear-stream _test-input-stream) + 3484 (clear-stream $_test-input-buffered-file->buffer) + 3485 (clear-stream _test-output-stream) + 3486 (clear-stream $_test-output-buffered-file->buffer) + 3487 # + 3488 (write _test-input-stream "fn foo {\n") + 3489 (write _test-input-stream " a: {\n") + 3490 (write _test-input-stream " var x: int\n") + 3491 (write _test-input-stream " {\n") + 3492 (write _test-input-stream " var y: int\n") + 3493 (write _test-input-stream " break-if->= a\n") + 3494 (write _test-input-stream " increment x\n") + 3495 (write _test-input-stream " loop\n") + 3496 (write _test-input-stream " }\n") + 3497 (write _test-input-stream " }\n") + 3498 (write _test-input-stream "}\n") + 3499 # convert + 3500 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3501 (flush _test-output-buffered-file) + 3502 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3508 # check output + 3509 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") + 3510 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") + 3511 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/2") + 3512 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/3") + 3513 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/4") + 3514 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/5") + 3515 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/6") + 3516 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/7") + 3517 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/8") + 3518 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/9") + 3519 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/10") + 3520 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/11") + 3521 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/12") + 3522 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/13") + 3523 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/14") + 3524 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/15") + 3525 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/16") + 3526 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/17") + 3527 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/18") + 3528 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/19") + 3529 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/20") + 3530 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/21") + 3531 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/22") + 3532 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/23") + 3533 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/24") + 3534 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/25") + 3535 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/26") + 3536 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/27") + 3537 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/28") + 3538 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/29") + 3539 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/30") + 3540 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/31") + 3541 # . epilogue + 3542 89/<- %esp 5/r32/ebp + 3543 5d/pop-to-ebp + 3544 c3/return + 3545 + 3546 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2: + 3547 # . prologue + 3548 55/push-ebp + 3549 89/<- %ebp 4/r32/esp + 3550 # setup + 3551 (clear-stream _test-input-stream) + 3552 (clear-stream $_test-input-buffered-file->buffer) + 3553 (clear-stream _test-output-stream) + 3554 (clear-stream $_test-output-buffered-file->buffer) + 3555 # non-local conditional branch from a block without a local variable, + 3556 # unwinding a local on the stack + 3557 (write _test-input-stream "fn foo {\n") + 3558 (write _test-input-stream " a: {\n") + 3559 (write _test-input-stream " var x: int\n") + 3560 (write _test-input-stream " {\n") + 3561 (write _test-input-stream " break-if->= a\n") + 3562 (write _test-input-stream " }\n") + 3563 (write _test-input-stream " }\n") + 3564 (write _test-input-stream "}\n") + 3565 # convert + 3566 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3567 (flush _test-output-buffered-file) + 3568 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3574 # check output + 3575 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0") + 3576 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1") + 3577 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/2") + 3578 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/3") + 3579 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/4") + 3580 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/5") + 3581 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/6") + 3582 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/7") + 3583 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/8") + 3584 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/9") + 3585 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/10") + 3586 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/11") + 3587 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/12") + 3588 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/13") + 3589 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/14") + 3590 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/15") + 3591 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/16") + 3592 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/17") + 3593 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/18") + 3594 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/19") + 3595 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/20") + 3596 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/21") + 3597 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/22") + 3598 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/23") + 3599 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/24") + 3600 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/25") + 3601 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/26") + 3602 # . epilogue + 3603 89/<- %esp 5/r32/ebp + 3604 5d/pop-to-ebp + 3605 c3/return + 3606 + 3607 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3: + 3608 # . prologue + 3609 55/push-ebp + 3610 89/<- %ebp 4/r32/esp + 3611 # setup + 3612 (clear-stream _test-input-stream) + 3613 (clear-stream $_test-input-buffered-file->buffer) + 3614 (clear-stream _test-output-stream) + 3615 (clear-stream $_test-output-buffered-file->buffer) + 3616 # non-local unconditional branch from a block without a local variable, + 3617 # unwinding a local on the stack + 3618 (write _test-input-stream "fn foo {\n") + 3619 (write _test-input-stream " a: {\n") + 3620 (write _test-input-stream " var x: int\n") + 3621 (write _test-input-stream " {\n") + 3622 (write _test-input-stream " break a\n") + 3623 (write _test-input-stream " }\n") + 3624 (write _test-input-stream " }\n") + 3625 (write _test-input-stream "}\n") + 3626 # convert + 3627 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3628 (flush _test-output-buffered-file) + 3629 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3635 # check output + 3636 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0") + 3637 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1") + 3638 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/2") + 3639 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/3") + 3640 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/4") + 3641 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/5") + 3642 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/6") + 3643 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/7") + 3644 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/8") + 3645 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/9") + 3646 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/10") + 3647 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/11") + 3648 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/12") + 3649 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/14") + 3650 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/15") + 3651 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/16") + 3652 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/17") + 3653 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/18") + 3654 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/19") + 3655 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/20") + 3656 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/21") + 3657 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/22") + 3658 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/23") + 3659 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/24") + 3660 # . epilogue + 3661 89/<- %esp 5/r32/ebp + 3662 5d/pop-to-ebp + 3663 c3/return + 3664 + 3665 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4: + 3666 # . prologue + 3667 55/push-ebp + 3668 89/<- %ebp 4/r32/esp + 3669 # setup + 3670 (clear-stream _test-input-stream) + 3671 (clear-stream $_test-input-buffered-file->buffer) + 3672 (clear-stream _test-output-stream) + 3673 (clear-stream $_test-output-buffered-file->buffer) + 3674 # + 3675 (write _test-input-stream "fn foo {\n") + 3676 (write _test-input-stream " a: {\n") + 3677 (write _test-input-stream " var x/esi: int <- copy 0\n") + 3678 (write _test-input-stream " {\n") + 3679 (write _test-input-stream " break a\n") + 3680 (write _test-input-stream " }\n") + 3681 (write _test-input-stream " }\n") + 3682 (write _test-input-stream "}\n") + 3683 # convert + 3684 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3685 (flush _test-output-buffered-file) + 3686 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3692 # check output + 3693 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0") + 3694 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1") + 3695 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/2") + 3696 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/3") + 3697 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/4") + 3698 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/5") + 3699 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/6") + 3700 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/7") + 3701 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/8") + 3702 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/9") + 3703 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/10") + 3704 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/11") + 3705 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/12") + 3706 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/13") + 3707 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/14") + 3708 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/15") + 3709 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/16") + 3710 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/17") + 3711 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/18") + 3712 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/19") + 3713 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/20") + 3714 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/21") + 3715 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/22") + 3716 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/23") + 3717 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/24") + 3718 # . epilogue + 3719 89/<- %esp 5/r32/ebp + 3720 5d/pop-to-ebp + 3721 c3/return + 3722 + 3723 test-convert-function-with-nonlocal-unconditional-break-and-local-vars: + 3724 # . prologue + 3725 55/push-ebp + 3726 89/<- %ebp 4/r32/esp + 3727 # setup + 3728 (clear-stream _test-input-stream) + 3729 (clear-stream $_test-input-buffered-file->buffer) + 3730 (clear-stream _test-output-stream) + 3731 (clear-stream $_test-output-buffered-file->buffer) + 3732 # + 3733 (write _test-input-stream "fn foo {\n") + 3734 (write _test-input-stream " a: {\n") + 3735 (write _test-input-stream " var x: int\n") + 3736 (write _test-input-stream " {\n") + 3737 (write _test-input-stream " var y: int\n") + 3738 (write _test-input-stream " break a\n") + 3739 (write _test-input-stream " increment x\n") + 3740 (write _test-input-stream " }\n") + 3741 (write _test-input-stream " }\n") + 3742 (write _test-input-stream "}\n") + 3743 # convert + 3744 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3745 (flush _test-output-buffered-file) + 3746 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3752 # check output + 3753 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") + 3754 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") + 3755 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/2") + 3756 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/3") + 3757 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/4") + 3758 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/5") + 3759 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/6") + 3760 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/7") + 3761 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/8") + 3762 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/9") + 3763 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/10") + 3764 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/11") + 3765 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/12") + 3766 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/13") + 3767 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/14") + 3768 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/15") + 3769 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/16") + 3770 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/17") + 3771 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/18") + 3772 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/19") + 3773 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/20") + 3774 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/21") + 3775 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/22") + 3776 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/23") + 3777 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/24") + 3778 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/25") + 3779 # . epilogue + 3780 89/<- %esp 5/r32/ebp + 3781 5d/pop-to-ebp + 3782 c3/return + 3783 + 3784 test-convert-function-with-unconditional-break-and-local-vars: + 3785 # . prologue + 3786 55/push-ebp + 3787 89/<- %ebp 4/r32/esp + 3788 # setup + 3789 (clear-stream _test-input-stream) + 3790 (clear-stream $_test-input-buffered-file->buffer) + 3791 (clear-stream _test-output-stream) + 3792 (clear-stream $_test-output-buffered-file->buffer) + 3793 # + 3794 (write _test-input-stream "fn foo {\n") + 3795 (write _test-input-stream " {\n") + 3796 (write _test-input-stream " var x: int\n") + 3797 (write _test-input-stream " {\n") + 3798 (write _test-input-stream " var y: int\n") + 3799 (write _test-input-stream " break\n") + 3800 (write _test-input-stream " increment x\n") + 3801 (write _test-input-stream " }\n") + 3802 (write _test-input-stream " }\n") + 3803 (write _test-input-stream "}\n") + 3804 # convert + 3805 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3806 (flush _test-output-buffered-file) + 3807 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3813 # check output + 3814 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") + 3815 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") + 3816 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/2") + 3817 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-break-and-local-vars/3") + 3818 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/4") + 3819 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/5") + 3820 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/6") + 3821 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/7") + 3822 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/8") + 3823 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/9") + 3824 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/10") + 3825 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/11") + 3826 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/12") + 3827 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/13") + 3828 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/14") + 3829 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/15") + 3830 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/16") + 3831 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/17") + 3832 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/18") + 3833 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/19") + 3834 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-break-and-local-vars/20") + 3835 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/21") + 3836 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/22") + 3837 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-break-and-local-vars/23") + 3838 # . epilogue + 3839 89/<- %esp 5/r32/ebp + 3840 5d/pop-to-ebp + 3841 c3/return + 3842 + 3843 test-convert-function-with-nonlocal-unconditional-loop-and-local-vars: + 3844 # . prologue + 3845 55/push-ebp + 3846 89/<- %ebp 4/r32/esp + 3847 # setup + 3848 (clear-stream _test-input-stream) + 3849 (clear-stream $_test-input-buffered-file->buffer) + 3850 (clear-stream _test-output-stream) + 3851 (clear-stream $_test-output-buffered-file->buffer) + 3852 # + 3853 (write _test-input-stream "fn foo {\n") + 3854 (write _test-input-stream " a: {\n") + 3855 (write _test-input-stream " var x: int\n") + 3856 (write _test-input-stream " {\n") + 3857 (write _test-input-stream " var y: int\n") + 3858 (write _test-input-stream " loop a\n") + 3859 (write _test-input-stream " increment x\n") + 3860 (write _test-input-stream " }\n") + 3861 (write _test-input-stream " }\n") + 3862 (write _test-input-stream "}\n") + 3863 # convert + 3864 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3865 (flush _test-output-buffered-file) + 3866 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3872 # check output + 3873 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") + 3874 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") + 3875 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/2") + 3876 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/3") + 3877 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/4") + 3878 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/5") + 3879 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/6") + 3880 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/7") + 3881 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/8") + 3882 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/9") + 3883 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/10") + 3884 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/11") + 3885 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/12") + 3886 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/13") + 3887 (check-next-stream-line-equal _test-output-stream " e9/jump a:loop/disp32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/14") + 3888 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/15") + 3889 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/16") + 3890 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/17") + 3891 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/18") + 3892 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/19") + 3893 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/20") + 3894 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/21") + 3895 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/22") + 3896 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/23") + 3897 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/24") + 3898 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/25") + 3899 # . epilogue + 3900 89/<- %esp 5/r32/ebp + 3901 5d/pop-to-ebp + 3902 c3/return + 3903 + 3904 test-convert-function-with-local-array-var-in-mem: + 3905 # . prologue + 3906 55/push-ebp + 3907 89/<- %ebp 4/r32/esp + 3908 # setup + 3909 (clear-stream _test-input-stream) + 3910 (clear-stream $_test-input-buffered-file->buffer) + 3911 (clear-stream _test-output-stream) + 3912 (clear-stream $_test-output-buffered-file->buffer) + 3913 # + 3914 (write _test-input-stream "fn foo {\n") + 3915 (write _test-input-stream " var x: (array int 3)\n") + 3916 (write _test-input-stream "}\n") + 3917 # convert + 3918 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3919 (flush _test-output-buffered-file) + 3920 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3926 # check output + 3927 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") + 3928 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") + 3929 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-var-in-mem/2") + 3930 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-var-in-mem/3") + 3931 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-var-in-mem/4") + 3932 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-var-in-mem/5") + 3933 # define x + 3934 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-function-with-local-array-var-in-mem/7") + 3935 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-function-with-local-array-var-in-mem/8") + 3936 # reclaim x + 3937 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-function-with-local-array-var-in-mem/9") + 3938 # + 3939 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-var-in-mem/10") + 3940 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-var-in-mem/11") + 3941 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-var-in-mem/12") + 3942 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-var-in-mem/13") + 3943 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-var-in-mem/14") + 3944 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-var-in-mem/15") 3945 # . epilogue - 3946 5d/pop-to-ebp - 3947 c3/return - 3948 - 3949 test-convert-function-with-populate: - 3950 # . prologue - 3951 55/push-ebp - 3952 89/<- %ebp 4/r32/esp - 3953 # setup - 3954 (clear-stream _test-input-stream) - 3955 (clear-stream $_test-input-buffered-file->buffer) - 3956 (clear-stream _test-output-stream) - 3957 (clear-stream $_test-output-buffered-file->buffer) - 3958 # - 3959 (write _test-input-stream "fn foo {\n") - 3960 (write _test-input-stream " var x/ecx: (addr handle array int) <- copy 0\n") - 3961 (write _test-input-stream " populate x, 7\n") - 3962 (write _test-input-stream "}\n") - 3963 # convert - 3964 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3965 (flush _test-output-buffered-file) - 3966 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 3972 # check output - 3973 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0") - 3974 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1") - 3975 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-populate/2") - 3976 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-populate/3") - 3977 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-populate/4") - 3978 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-populate/5") - 3979 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-populate/6") - 3980 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-populate/7") - 3981 (check-next-stream-line-equal _test-output-stream " (allocate-array2 Heap 0x00000004 7 %ecx)" "F - test-convert-function-with-populate/8") # 4 = size-of(int) - 3982 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-populate/9") - 3983 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-populate/10") - 3984 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-populate/11") - 3985 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-populate/12") - 3986 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-populate/13") - 3987 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-populate/14") - 3988 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-populate/15") - 3989 # . epilogue - 3990 89/<- %esp 5/r32/ebp + 3946 89/<- %esp 5/r32/ebp + 3947 5d/pop-to-ebp + 3948 c3/return + 3949 + 3950 test-array-size-in-hex: + 3951 # . prologue + 3952 55/push-ebp + 3953 89/<- %ebp 4/r32/esp + 3954 # setup + 3955 (clear-stream _test-input-stream) + 3956 (clear-stream $_test-input-buffered-file->buffer) + 3957 (clear-stream _test-output-stream) + 3958 (clear-stream $_test-output-buffered-file->buffer) + 3959 (clear-stream _test-error-stream) + 3960 (clear-stream $_test-error-buffered-file->buffer) + 3961 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3962 68/push 0/imm32 + 3963 68/push 0/imm32 + 3964 89/<- %edx 4/r32/esp + 3965 (tailor-exit-descriptor %edx 0x10) + 3966 # + 3967 (write _test-input-stream "fn foo {\n") + 3968 (write _test-input-stream " var x: (array int 10)\n") + 3969 (write _test-input-stream "}\n") + 3970 # convert + 3971 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3972 # registers except esp clobbered at this point + 3973 # restore ed + 3974 89/<- %edx 4/r32/esp + 3975 (flush _test-output-buffered-file) + 3976 (flush _test-error-buffered-file) + 3977 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 3983 # check output + 3984 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty") + 3985 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; either start '10' with a '0x' to be unambiguous, or convert it to decimal." "F - test-array-size-in-hex: error message") + 3986 # check that stop(1) was called + 3987 (check-ints-equal *(edx+4) 2 "F - test-array-size-in-hex: exit status") + 3988 # don't restore from ebp + 3989 81 0/subop/add %esp 8/imm32 + 3990 # . epilogue 3991 5d/pop-to-ebp 3992 c3/return 3993 - 3994 # special-case for size(byte) when allocating array - 3995 test-convert-function-with-local-array-of-bytes-in-mem: - 3996 # . prologue - 3997 55/push-ebp - 3998 89/<- %ebp 4/r32/esp - 3999 # setup - 4000 (clear-stream _test-input-stream) - 4001 (clear-stream $_test-input-buffered-file->buffer) - 4002 (clear-stream _test-output-stream) - 4003 (clear-stream $_test-output-buffered-file->buffer) - 4004 # - 4005 (write _test-input-stream "fn foo {\n") - 4006 (write _test-input-stream " var x: (array byte 3)\n") + 3994 test-convert-function-with-populate: + 3995 # . prologue + 3996 55/push-ebp + 3997 89/<- %ebp 4/r32/esp + 3998 # setup + 3999 (clear-stream _test-input-stream) + 4000 (clear-stream $_test-input-buffered-file->buffer) + 4001 (clear-stream _test-output-stream) + 4002 (clear-stream $_test-output-buffered-file->buffer) + 4003 # + 4004 (write _test-input-stream "fn foo {\n") + 4005 (write _test-input-stream " var x/ecx: (addr handle array int) <- copy 0\n") + 4006 (write _test-input-stream " populate x, 7\n") 4007 (write _test-input-stream "}\n") 4008 # convert 4009 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4010 (flush _test-output-buffered-file) 4011 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- 4017 # check output - 4018 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0") - 4019 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1") - 4020 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/2") - 4021 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-of-bytes-in-mem/3") - 4022 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-of-bytes-in-mem/4") - 4023 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-of-bytes-in-mem/5") - 4024 # define x - 4025 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-function-with-local-array-of-bytes-in-mem/7") - 4026 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/8") - 4027 # reclaim x - 4028 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/9") - 4029 # - 4030 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-of-bytes-in-mem/10") - 4031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-of-bytes-in-mem/11") - 4032 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-of-bytes-in-mem/12") - 4033 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/13") - 4034 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/14") - 4035 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-of-bytes-in-mem/15") - 4036 # . epilogue - 4037 89/<- %esp 5/r32/ebp - 4038 5d/pop-to-ebp - 4039 c3/return - 4040 - 4041 test-convert-address: - 4042 # . prologue - 4043 55/push-ebp - 4044 89/<- %ebp 4/r32/esp - 4045 # setup - 4046 (clear-stream _test-input-stream) - 4047 (clear-stream $_test-input-buffered-file->buffer) - 4048 (clear-stream _test-output-stream) - 4049 (clear-stream $_test-output-buffered-file->buffer) - 4050 # - 4051 (write _test-input-stream "fn foo {\n") - 4052 (write _test-input-stream " var a: int\n") - 4053 (write _test-input-stream " var b/eax: (addr int) <- address a\n") - 4054 (write _test-input-stream "}\n") - 4055 # convert - 4056 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4057 (flush _test-output-buffered-file) - 4058 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4064 # check output - 4065 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") - 4066 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") - 4067 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-address/2") - 4068 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-address/3") - 4069 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-address/4") - 4070 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-address/5") - 4071 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-address/6") - 4072 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-address/7") - 4073 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-address/8") - 4074 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-address/9") - 4075 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-address/10") - 4076 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-address/11") - 4077 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-address/12") - 4078 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-address/13") - 4079 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-address/14") - 4080 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-address/15") - 4081 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-address/16") - 4082 # . epilogue - 4083 89/<- %esp 5/r32/ebp - 4084 5d/pop-to-ebp - 4085 c3/return - 4086 - 4087 test-convert-length-of-array: - 4088 # . prologue - 4089 55/push-ebp - 4090 89/<- %ebp 4/r32/esp - 4091 # setup - 4092 (clear-stream _test-input-stream) - 4093 (clear-stream $_test-input-buffered-file->buffer) - 4094 (clear-stream _test-output-stream) - 4095 (clear-stream $_test-output-buffered-file->buffer) - 4096 # - 4097 (write _test-input-stream "fn foo a: (addr array int) {\n") - 4098 (write _test-input-stream " var b/eax: (addr array int) <- copy a\n") - 4099 (write _test-input-stream " var c/eax: int <- length b\n") - 4100 (write _test-input-stream "}\n") - 4101 # convert - 4102 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4103 (flush _test-output-buffered-file) - 4104 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4110 # check output - 4111 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") - 4112 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") - 4113 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array/2") - 4114 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array/3") - 4115 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array/4") - 4116 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array/5") - 4117 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array/6") - 4118 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array/7") - 4119 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array/8") - 4120 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array/9") - 4121 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array/10") - 4122 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array/11") - 4123 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array/12") - 4124 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array/13") - 4125 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array/14") - 4126 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array/15") - 4127 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array/16") - 4128 # . epilogue - 4129 89/<- %esp 5/r32/ebp - 4130 5d/pop-to-ebp - 4131 c3/return - 4132 - 4133 # special-case for size(byte) when computing array length - 4134 test-convert-length-of-array-of-bytes: - 4135 # . prologue - 4136 55/push-ebp - 4137 89/<- %ebp 4/r32/esp - 4138 # setup - 4139 (clear-stream _test-input-stream) - 4140 (clear-stream $_test-input-buffered-file->buffer) - 4141 (clear-stream _test-output-stream) - 4142 (clear-stream $_test-output-buffered-file->buffer) - 4143 # - 4144 (write _test-input-stream "fn foo a: (addr array byte) {\n") - 4145 (write _test-input-stream " var b/eax: (addr array byte) <- copy a\n") - 4146 (write _test-input-stream " var c/eax: int <- length b\n") - 4147 (write _test-input-stream "}\n") - 4148 # convert - 4149 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4150 (flush _test-output-buffered-file) - 4151 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4157 # check output - 4158 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0") - 4159 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1") - 4160 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-bytes/2") - 4161 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-bytes/3") - 4162 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-bytes/4") - 4163 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-bytes/5") - 4164 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-bytes/6") - 4165 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/7") - 4166 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/8") - 4167 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-bytes/9") - 4168 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-bytes/10") - 4169 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-bytes/11") - 4170 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-bytes/12") - 4171 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-bytes/13") - 4172 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-bytes/14") - 4173 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-bytes/15") - 4174 # . epilogue - 4175 89/<- %esp 5/r32/ebp - 4176 5d/pop-to-ebp - 4177 c3/return - 4178 - 4179 test-convert-length-of-array-on-stack: + 4018 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0") + 4019 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1") + 4020 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-populate/2") + 4021 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-populate/3") + 4022 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-populate/4") + 4023 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-populate/5") + 4024 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-populate/6") + 4025 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-populate/7") + 4026 (check-next-stream-line-equal _test-output-stream " (allocate-array2 Heap 0x00000004 7 %ecx)" "F - test-convert-function-with-populate/8") # 4 = size-of(int) + 4027 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-populate/9") + 4028 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-populate/10") + 4029 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-populate/11") + 4030 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-populate/12") + 4031 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-populate/13") + 4032 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-populate/14") + 4033 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-populate/15") + 4034 # . epilogue + 4035 89/<- %esp 5/r32/ebp + 4036 5d/pop-to-ebp + 4037 c3/return + 4038 + 4039 # special-case for size(byte) when allocating array + 4040 test-convert-function-with-local-array-of-bytes-in-mem: + 4041 # . prologue + 4042 55/push-ebp + 4043 89/<- %ebp 4/r32/esp + 4044 # setup + 4045 (clear-stream _test-input-stream) + 4046 (clear-stream $_test-input-buffered-file->buffer) + 4047 (clear-stream _test-output-stream) + 4048 (clear-stream $_test-output-buffered-file->buffer) + 4049 # + 4050 (write _test-input-stream "fn foo {\n") + 4051 (write _test-input-stream " var x: (array byte 3)\n") + 4052 (write _test-input-stream "}\n") + 4053 # convert + 4054 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4055 (flush _test-output-buffered-file) + 4056 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4062 # check output + 4063 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0") + 4064 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1") + 4065 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/2") + 4066 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-of-bytes-in-mem/3") + 4067 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-of-bytes-in-mem/4") + 4068 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-of-bytes-in-mem/5") + 4069 # define x + 4070 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-function-with-local-array-of-bytes-in-mem/7") + 4071 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/8") + 4072 # reclaim x + 4073 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/9") + 4074 # + 4075 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-of-bytes-in-mem/10") + 4076 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-of-bytes-in-mem/11") + 4077 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-of-bytes-in-mem/12") + 4078 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/13") + 4079 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/14") + 4080 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-of-bytes-in-mem/15") + 4081 # . epilogue + 4082 89/<- %esp 5/r32/ebp + 4083 5d/pop-to-ebp + 4084 c3/return + 4085 + 4086 test-convert-address: + 4087 # . prologue + 4088 55/push-ebp + 4089 89/<- %ebp 4/r32/esp + 4090 # setup + 4091 (clear-stream _test-input-stream) + 4092 (clear-stream $_test-input-buffered-file->buffer) + 4093 (clear-stream _test-output-stream) + 4094 (clear-stream $_test-output-buffered-file->buffer) + 4095 # + 4096 (write _test-input-stream "fn foo {\n") + 4097 (write _test-input-stream " var a: int\n") + 4098 (write _test-input-stream " var b/eax: (addr int) <- address a\n") + 4099 (write _test-input-stream "}\n") + 4100 # convert + 4101 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4102 (flush _test-output-buffered-file) + 4103 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4109 # check output + 4110 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") + 4111 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") + 4112 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-address/2") + 4113 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-address/3") + 4114 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-address/4") + 4115 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-address/5") + 4116 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-address/6") + 4117 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-address/7") + 4118 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-address/8") + 4119 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-address/9") + 4120 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-address/10") + 4121 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-address/11") + 4122 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-address/12") + 4123 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-address/13") + 4124 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-address/14") + 4125 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-address/15") + 4126 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-address/16") + 4127 # . epilogue + 4128 89/<- %esp 5/r32/ebp + 4129 5d/pop-to-ebp + 4130 c3/return + 4131 + 4132 test-convert-length-of-array: + 4133 # . prologue + 4134 55/push-ebp + 4135 89/<- %ebp 4/r32/esp + 4136 # setup + 4137 (clear-stream _test-input-stream) + 4138 (clear-stream $_test-input-buffered-file->buffer) + 4139 (clear-stream _test-output-stream) + 4140 (clear-stream $_test-output-buffered-file->buffer) + 4141 # + 4142 (write _test-input-stream "fn foo a: (addr array int) {\n") + 4143 (write _test-input-stream " var b/eax: (addr array int) <- copy a\n") + 4144 (write _test-input-stream " var c/eax: int <- length b\n") + 4145 (write _test-input-stream "}\n") + 4146 # convert + 4147 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4148 (flush _test-output-buffered-file) + 4149 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4155 # check output + 4156 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") + 4157 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") + 4158 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array/2") + 4159 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array/3") + 4160 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array/4") + 4161 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array/5") + 4162 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array/6") + 4163 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array/7") + 4164 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array/8") + 4165 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array/9") + 4166 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array/10") + 4167 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array/11") + 4168 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array/12") + 4169 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array/13") + 4170 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array/14") + 4171 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array/15") + 4172 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array/16") + 4173 # . epilogue + 4174 89/<- %esp 5/r32/ebp + 4175 5d/pop-to-ebp + 4176 c3/return + 4177 + 4178 # special-case for size(byte) when computing array length + 4179 test-convert-length-of-array-of-bytes: 4180 # . prologue 4181 55/push-ebp 4182 89/<- %ebp 4/r32/esp @@ -3878,1365 +3878,1365 @@ if ('onhashchange' in window) { 4186 (clear-stream _test-output-stream) 4187 (clear-stream $_test-output-buffered-file->buffer) 4188 # - 4189 (write _test-input-stream "fn foo {\n") - 4190 (write _test-input-stream " var a: (array int 3)\n") - 4191 (write _test-input-stream " var b/eax: int <- length a\n") + 4189 (write _test-input-stream "fn foo a: (addr array byte) {\n") + 4190 (write _test-input-stream " var b/eax: (addr array byte) <- copy a\n") + 4191 (write _test-input-stream " var c/eax: int <- length b\n") 4192 (write _test-input-stream "}\n") 4193 # convert 4194 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4195 (flush _test-output-buffered-file) 4196 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- 4202 # check output - 4203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") - 4204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") - 4205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-on-stack/2") - 4206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-on-stack/3") - 4207 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-on-stack/4") - 4208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-on-stack/5") - 4209 # define x - 4210 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-length-of-array-on-stack/6") - 4211 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-length-of-array-on-stack/7") - 4212 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-on-stack/8") - 4213 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff0) 0x00000000/r32" "F - test-convert-length-of-array-on-stack/9") - 4214 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array-on-stack/10") - 4215 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-on-stack/11") - 4216 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-length-of-array-on-stack/12") - 4217 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-on-stack/13") - 4218 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-on-stack/14") - 4219 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-on-stack/15") - 4220 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-on-stack/16") - 4221 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-on-stack/17") - 4222 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-on-stack/18") - 4223 # . epilogue - 4224 89/<- %esp 5/r32/ebp - 4225 5d/pop-to-ebp - 4226 c3/return - 4227 - 4228 test-reg-var-def-with-read-of-same-register: - 4229 # . prologue - 4230 55/push-ebp - 4231 89/<- %ebp 4/r32/esp - 4232 # setup - 4233 (clear-stream _test-input-stream) - 4234 (clear-stream $_test-input-buffered-file->buffer) - 4235 (clear-stream _test-output-stream) - 4236 (clear-stream $_test-output-buffered-file->buffer) - 4237 (clear-stream _test-error-stream) - 4238 (clear-stream $_test-error-buffered-file->buffer) - 4239 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu - 4240 68/push 0/imm32 - 4241 68/push 0/imm32 - 4242 89/<- %edx 4/r32/esp - 4243 (tailor-exit-descriptor %edx 0x10) - 4244 # - 4245 (write _test-input-stream "fn foo {\n") - 4246 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 4247 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 4248 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 4249 (write _test-input-stream "}\n") - 4250 # convert - 4251 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 4252 # registers except esp could be clobbered at this point (though they shouldn't be) - 4253 # restore ed - 4254 89/<- %edx 4/r32/esp - 4255 (flush _test-output-buffered-file) - 4256 (flush _test-error-buffered-file) - 4257 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4263 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty") - 4264 # check output - 4265 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0") - 4266 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-reg-var-def-with-read-of-same-register/1") - 4267 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-reg-var-def-with-read-of-same-register/2") - 4268 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-reg-var-def-with-read-of-same-register/3") - 4269 (check-next-stream-line-equal _test-output-stream " {" "F - test-reg-var-def-with-read-of-same-register/4") - 4270 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-reg-var-def-with-read-of-same-register/5") - 4271 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-reg-var-def-with-read-of-same-register/6") - 4272 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-reg-var-def-with-read-of-same-register/7") - 4273 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-reg-var-def-with-read-of-same-register/8") - 4274 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-reg-var-def-with-read-of-same-register/9") - 4275 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-reg-var-def-with-read-of-same-register/11") - 4276 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-reg-var-def-with-read-of-same-register/13") - 4277 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-reg-var-def-with-read-of-same-register/14") - 4278 (check-next-stream-line-equal _test-output-stream " }" "F - test-reg-var-def-with-read-of-same-register/15") - 4279 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-reg-var-def-with-read-of-same-register/16") - 4280 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-reg-var-def-with-read-of-same-register/17") - 4281 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-reg-var-def-with-read-of-same-register/18") - 4282 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-reg-var-def-with-read-of-same-register/19") - 4283 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-reg-var-def-with-read-of-same-register/20") - 4284 # don't restore from ebp - 4285 81 0/subop/add %esp 8/imm32 - 4286 # . epilogue - 4287 5d/pop-to-ebp - 4288 c3/return - 4289 - 4290 test-convert-index-into-array: - 4291 # . prologue - 4292 55/push-ebp - 4293 89/<- %ebp 4/r32/esp - 4294 # setup - 4295 (clear-stream _test-input-stream) - 4296 (clear-stream $_test-input-buffered-file->buffer) - 4297 (clear-stream _test-output-stream) - 4298 (clear-stream $_test-output-buffered-file->buffer) - 4299 # - 4300 (write _test-input-stream "fn foo {\n") - 4301 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 4302 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 4303 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 4304 (write _test-input-stream "}\n") - 4305 # convert - 4306 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4307 (flush _test-output-buffered-file) - 4308 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4314 # check output - 4315 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") - 4316 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") - 4317 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array/2") - 4318 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array/3") - 4319 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array/4") - 4320 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array/5") - 4321 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array/6") - 4322 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array/7") - 4323 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array/8") - 4324 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array/9") - 4325 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-convert-index-into-array/10") - 4326 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array/11") - 4327 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array/12") - 4328 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array/13") - 4329 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array/14") - 4330 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array/15") - 4331 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array/16") - 4332 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array/17") - 4333 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array/18") - 4334 # . epilogue - 4335 89/<- %esp 5/r32/ebp - 4336 5d/pop-to-ebp - 4337 c3/return - 4338 - 4339 test-convert-index-into-array-of-bytes: - 4340 # . prologue - 4341 55/push-ebp - 4342 89/<- %ebp 4/r32/esp - 4343 # setup - 4344 (clear-stream _test-input-stream) - 4345 (clear-stream $_test-input-buffered-file->buffer) - 4346 (clear-stream _test-output-stream) - 4347 (clear-stream $_test-output-buffered-file->buffer) - 4348 # - 4349 (write _test-input-stream "fn foo {\n") - 4350 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 4351 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 4352 (write _test-input-stream " var x/eax: (addr byte) <- index arr, idx\n") - 4353 (write _test-input-stream "}\n") - 4354 # convert - 4355 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4356 (flush _test-output-buffered-file) - 4357 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4363 # check output - 4364 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0") - 4365 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1") - 4366 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes/2") - 4367 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes/3") - 4368 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes/4") - 4369 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes/5") - 4370 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes/6") - 4371 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes/7") - 4372 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes/8") - 4373 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes/9") - 4374 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000000 + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes/11") - 4375 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes/13") - 4376 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes/14") - 4377 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes/15") - 4378 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes/16") - 4379 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes/17") - 4380 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes/18") - 4381 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes/19") - 4382 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes/20") - 4383 # . epilogue - 4384 89/<- %esp 5/r32/ebp - 4385 5d/pop-to-ebp - 4386 c3/return - 4387 - 4388 test-convert-index-into-array-with-literal: - 4389 # . prologue - 4390 55/push-ebp - 4391 89/<- %ebp 4/r32/esp - 4392 # setup - 4393 (clear-stream _test-input-stream) - 4394 (clear-stream $_test-input-buffered-file->buffer) - 4395 (clear-stream _test-output-stream) - 4396 (clear-stream $_test-output-buffered-file->buffer) - 4397 # - 4398 (write _test-input-stream "fn foo {\n") - 4399 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 4400 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") - 4401 (write _test-input-stream "}\n") - 4402 # convert - 4403 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4404 (flush _test-output-buffered-file) - 4405 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4411 # check output - 4412 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") - 4413 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") - 4414 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-with-literal/2") - 4415 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-with-literal/3") - 4416 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-with-literal/4") - 4417 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-with-literal/5") - 4418 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-with-literal/6") - 4419 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-with-literal/7") - 4420 # 2 * 4 bytes/elem + 4 bytes for size = offset 12 - 4421 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x0000000c) 0x00000000/r32" "F - test-convert-index-into-array-with-literal/8") - 4422 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-with-literal/9") - 4423 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-with-literal/10") - 4424 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-with-literal/11") - 4425 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-with-literal/12") - 4426 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-with-literal/13") - 4427 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-with-literal/14") - 4428 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-with-literal/15") - 4429 # . epilogue - 4430 89/<- %esp 5/r32/ebp - 4431 5d/pop-to-ebp - 4432 c3/return - 4433 - 4434 test-convert-index-into-array-of-bytes-with-literal: - 4435 # . prologue - 4436 55/push-ebp - 4437 89/<- %ebp 4/r32/esp - 4438 # setup - 4439 (clear-stream _test-input-stream) - 4440 (clear-stream $_test-input-buffered-file->buffer) - 4441 (clear-stream _test-output-stream) - 4442 (clear-stream $_test-output-buffered-file->buffer) - 4443 # - 4444 (write _test-input-stream "fn foo {\n") - 4445 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 4446 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") - 4447 (write _test-input-stream "}\n") - 4448 # convert - 4449 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4450 (flush _test-output-buffered-file) - 4451 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4457 # check output - 4458 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0") - 4459 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1") - 4460 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/2") - 4461 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-with-literal/3") - 4462 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-with-literal/4") - 4463 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-with-literal/5") - 4464 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-with-literal/6") - 4465 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-with-literal/7") - 4466 # 2 * 1 byte/elem + 4 bytes for size = offset 6 - 4467 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000006) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-with-literal/8") - 4468 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-with-literal/9") - 4469 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-with-literal/10") - 4470 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-with-literal/11") - 4471 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-with-literal/12") - 4472 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-with-literal/13") - 4473 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/14") - 4474 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-with-literal/15") - 4475 # . epilogue - 4476 89/<- %esp 5/r32/ebp - 4477 5d/pop-to-ebp - 4478 c3/return - 4479 - 4480 test-convert-index-into-array-on-stack: - 4481 # . prologue - 4482 55/push-ebp - 4483 89/<- %ebp 4/r32/esp - 4484 # setup - 4485 (clear-stream _test-input-stream) - 4486 (clear-stream $_test-input-buffered-file->buffer) - 4487 (clear-stream _test-output-stream) - 4488 (clear-stream $_test-output-buffered-file->buffer) - 4489 # - 4490 (write _test-input-stream "fn foo {\n") - 4491 (write _test-input-stream " var arr: (array int 3)\n") - 4492 (write _test-input-stream " var idx/eax: int <- copy 2\n") - 4493 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 4494 (write _test-input-stream "}\n") - 4495 # convert - 4496 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4497 (flush _test-output-buffered-file) - 4498 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4504 # check output - 4505 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") - 4506 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") - 4507 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack/2") - 4508 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack/3") - 4509 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack/4") - 4510 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack/5") - 4511 # var arr - 4512 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack/6") - 4513 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack/7") - 4514 # var idx - 4515 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack/8") - 4516 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 2/imm32" "F - test-convert-index-into-array-on-stack/9") - 4517 # var x is at (ebp-0x10) + idx<<2 + 4 = ebp + idx<<2 - 0xc - 4518 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + eax<<0x00000002 + 0xfffffff4) 0x00000000/r32" "F - test-convert-index-into-array-on-stack/10") - 4519 # reclaim idx - 4520 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack/11") - 4521 # reclaim arr - 4522 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack/12") - 4523 # - 4524 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack/13") - 4525 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack/14") - 4526 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack/15") - 4527 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack/16") - 4528 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack/17") - 4529 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack/18") - 4530 # . epilogue - 4531 89/<- %esp 5/r32/ebp - 4532 5d/pop-to-ebp - 4533 c3/return - 4534 - 4535 test-convert-index-into-array-on-stack-with-literal: - 4536 # . prologue - 4537 55/push-ebp - 4538 89/<- %ebp 4/r32/esp - 4539 # setup - 4540 (clear-stream _test-input-stream) - 4541 (clear-stream $_test-input-buffered-file->buffer) - 4542 (clear-stream _test-output-stream) - 4543 (clear-stream $_test-output-buffered-file->buffer) - 4544 # - 4545 (write _test-input-stream "fn foo {\n") - 4546 (write _test-input-stream " var arr: (array int 3)\n") - 4547 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") - 4548 (write _test-input-stream "}\n") - 4549 # convert - 4550 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4551 (flush _test-output-buffered-file) - 4552 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4558 # check output - 4559 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") - 4560 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") - 4561 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack-with-literal/2") - 4562 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack-with-literal/3") - 4563 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack-with-literal/4") - 4564 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack-with-literal/5") - 4565 # var arr - 4566 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack-with-literal/6") - 4567 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack-with-literal/7") - 4568 # var x - 4569 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack-with-literal/8") - 4570 # x is at (ebp-0x10) + 4 + 2*4 = ebp-4 - 4571 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xfffffffc) 0x00000000/r32" "F - test-convert-index-into-array-on-stack-with-literal/9") - 4572 # reclaim x - 4573 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack-with-literal/10") - 4574 # reclaim arr - 4575 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack-with-literal/11") - 4576 # - 4577 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack-with-literal/12") - 4578 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack-with-literal/13") - 4579 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack-with-literal/14") - 4580 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack-with-literal/15") - 4581 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack-with-literal/16") - 4582 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack-with-literal/17") - 4583 # . epilogue - 4584 89/<- %esp 5/r32/ebp - 4585 5d/pop-to-ebp - 4586 c3/return - 4587 - 4588 test-convert-index-into-array-of-bytes-on-stack-with-literal: - 4589 # . prologue - 4590 55/push-ebp - 4591 89/<- %ebp 4/r32/esp - 4592 # setup - 4593 (clear-stream _test-input-stream) - 4594 (clear-stream $_test-input-buffered-file->buffer) - 4595 (clear-stream _test-output-stream) - 4596 (clear-stream $_test-output-buffered-file->buffer) - 4597 # - 4598 (write _test-input-stream "fn foo {\n") - 4599 (write _test-input-stream " var arr: (array byte 3)\n") - 4600 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") - 4601 (write _test-input-stream "}\n") - 4602 # convert - 4603 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4604 (flush _test-output-buffered-file) - 4605 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4611 # check output - 4612 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0") - 4613 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1") - 4614 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/2") - 4615 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/3") - 4616 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/4") - 4617 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/5") - 4618 # var arr - 4619 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/6") - 4620 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/7") - 4621 # var x - 4622 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/8") - 4623 # x is at (ebp-7) + 4 + 2 = ebp-1 - 4624 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xffffffff) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/9") - 4625 # reclaim x - 4626 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/10") - 4627 # reclaim arr - 4628 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/11") - 4629 # - 4630 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/12") - 4631 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/13") - 4632 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/14") - 4633 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/15") - 4634 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/16") - 4635 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/17") - 4636 # . epilogue - 4637 89/<- %esp 5/r32/ebp - 4638 5d/pop-to-ebp - 4639 c3/return - 4640 - 4641 test-convert-index-into-array-using-offset: - 4642 # . prologue - 4643 55/push-ebp - 4644 89/<- %ebp 4/r32/esp - 4645 # setup - 4646 (clear-stream _test-input-stream) - 4647 (clear-stream $_test-input-buffered-file->buffer) - 4648 (clear-stream _test-output-stream) - 4649 (clear-stream $_test-output-buffered-file->buffer) - 4650 # - 4651 (write _test-input-stream "fn foo {\n") - 4652 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 4653 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 4654 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") - 4655 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") - 4656 (write _test-input-stream "}\n") - 4657 # convert - 4658 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4659 (flush _test-output-buffered-file) - 4660 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4666 # check output - 4667 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") - 4668 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") - 4669 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset/2") - 4670 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset/3") - 4671 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset/4") - 4672 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset/5") - 4673 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset/6") - 4674 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset/7") - 4675 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset/8") - 4676 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-using-offset/9") - 4677 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset/10") - 4678 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset/11") - 4679 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset/12") - 4680 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset/13") - 4681 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset/14") - 4682 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset/15") - 4683 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset/16") - 4684 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset/17") - 4685 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset/18") - 4686 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset/19") - 4687 # . epilogue - 4688 89/<- %esp 5/r32/ebp - 4689 5d/pop-to-ebp - 4690 c3/return - 4691 - 4692 test-convert-index-into-array-of-bytes-using-offset: - 4693 # . prologue - 4694 55/push-ebp - 4695 89/<- %ebp 4/r32/esp - 4696 # setup - 4697 (clear-stream _test-input-stream) - 4698 (clear-stream $_test-input-buffered-file->buffer) - 4699 (clear-stream _test-output-stream) - 4700 (clear-stream $_test-output-buffered-file->buffer) - 4701 # - 4702 (write _test-input-stream "fn foo {\n") - 4703 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 4704 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 4705 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") - 4706 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") - 4707 (write _test-input-stream "}\n") - 4708 # convert - 4709 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4710 (flush _test-output-buffered-file) - 4711 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4717 # check output - 4718 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0") - 4719 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1") - 4720 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/2") - 4721 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset/3") - 4722 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset/4") - 4723 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset/5") - 4724 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset/6") - 4725 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/7") - 4726 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/8") - 4727 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/9") - 4728 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset/10") - 4729 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset/11") - 4730 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/12") - 4731 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset/13") - 4732 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset/14") - 4733 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset/15") - 4734 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset/16") - 4735 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset/17") - 4736 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/18") - 4737 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset/19") - 4738 # . epilogue - 4739 89/<- %esp 5/r32/ebp - 4740 5d/pop-to-ebp - 4741 c3/return - 4742 - 4743 test-convert-index-into-array-using-offset-on-stack: - 4744 # . prologue - 4745 55/push-ebp - 4746 89/<- %ebp 4/r32/esp - 4747 # setup - 4748 (clear-stream _test-input-stream) - 4749 (clear-stream $_test-input-buffered-file->buffer) - 4750 (clear-stream _test-output-stream) - 4751 (clear-stream $_test-output-buffered-file->buffer) - 4752 # - 4753 (write _test-input-stream "fn foo {\n") - 4754 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 4755 (write _test-input-stream " var idx: int\n") - 4756 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") - 4757 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") - 4758 (write _test-input-stream "}\n") - 4759 # convert - 4760 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4761 (flush _test-output-buffered-file) - 4762 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4768 # check output - 4769 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") - 4770 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") - 4771 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset-on-stack/2") - 4772 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset-on-stack/3") - 4773 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset-on-stack/4") - 4774 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset-on-stack/5") - 4775 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset-on-stack/6") - 4776 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/7") - 4777 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/8") - 4778 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset-on-stack/9") - 4779 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset-on-stack/10") - 4780 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset-on-stack/11") - 4781 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset-on-stack/12") - 4782 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-using-offset-on-stack/13") - 4783 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset-on-stack/14") - 4784 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset-on-stack/15") - 4785 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset-on-stack/16") - 4786 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset-on-stack/17") - 4787 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset-on-stack/18") - 4788 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset-on-stack/19") - 4789 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset-on-stack/20") - 4790 # . epilogue - 4791 89/<- %esp 5/r32/ebp - 4792 5d/pop-to-ebp - 4793 c3/return - 4794 - 4795 test-convert-index-into-array-of-bytes-using-offset-on-stack: - 4796 # . prologue - 4797 55/push-ebp - 4798 89/<- %ebp 4/r32/esp - 4799 # setup - 4800 (clear-stream _test-input-stream) - 4801 (clear-stream $_test-input-buffered-file->buffer) - 4802 (clear-stream _test-output-stream) - 4803 (clear-stream $_test-output-buffered-file->buffer) - 4804 # - 4805 (write _test-input-stream "fn foo {\n") - 4806 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 4807 (write _test-input-stream " var idx: int\n") - 4808 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") - 4809 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") - 4810 (write _test-input-stream "}\n") - 4811 # convert - 4812 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4813 (flush _test-output-buffered-file) - 4814 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4820 # check output - 4821 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0") - 4822 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1") - 4823 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/2") - 4824 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/3") - 4825 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/4") - 4826 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/5") - 4827 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/6") - 4828 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/7") - 4829 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/8") - 4830 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/9") - 4831 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/10") - 4832 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/11") - 4833 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/12") - 4834 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/13") - 4835 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/14") - 4836 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/15") - 4837 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/16") - 4838 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/17") - 4839 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/18") - 4840 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/19") - 4841 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/20") - 4842 # . epilogue - 4843 89/<- %esp 5/r32/ebp - 4844 5d/pop-to-ebp - 4845 c3/return - 4846 - 4847 test-convert-function-and-type-definition: - 4848 # . prologue - 4849 55/push-ebp - 4850 89/<- %ebp 4/r32/esp - 4851 # setup - 4852 (clear-stream _test-input-stream) - 4853 (clear-stream $_test-input-buffered-file->buffer) - 4854 (clear-stream _test-output-stream) - 4855 (clear-stream $_test-output-buffered-file->buffer) - 4856 # - 4857 (write _test-input-stream "fn foo a: (addr t) {\n") - 4858 (write _test-input-stream " var _a/eax: (addr t) <- copy a\n") - 4859 (write _test-input-stream " var b/ecx: (addr int) <- get _a, x\n") - 4860 (write _test-input-stream " var c/ecx: (addr int) <- get _a, y\n") - 4861 (write _test-input-stream "}\n") - 4862 (write _test-input-stream "type t {\n") - 4863 (write _test-input-stream " x: int\n") - 4864 (write _test-input-stream " y: int\n") - 4865 (write _test-input-stream "}\n") - 4866 # convert - 4867 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4868 (flush _test-output-buffered-file) - 4869 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 4875 # check output - 4876 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") - 4877 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") - 4878 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-and-type-definition/2") - 4879 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-and-type-definition/3") - 4880 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-and-type-definition/4") - 4881 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-and-type-definition/5") - 4882 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-and-type-definition/6") - 4883 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-and-type-definition/7") - 4884 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-and-type-definition/8") - 4885 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000000) 0x00000001/r32" "F - test-convert-function-and-type-definition/9") - 4886 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000004) 0x00000001/r32" "F - test-convert-function-and-type-definition/11") - 4887 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-and-type-definition/13") - 4888 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-and-type-definition/14") - 4889 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-and-type-definition/15") - 4890 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-and-type-definition/16") - 4891 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-and-type-definition/17") - 4892 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-and-type-definition/18") - 4893 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-and-type-definition/19") - 4894 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-and-type-definition/20") - 4895 # . epilogue - 4896 89/<- %esp 5/r32/ebp - 4897 5d/pop-to-ebp - 4898 c3/return - 4899 - 4900 test-type-definition-with-array: - 4901 # . prologue - 4902 55/push-ebp - 4903 89/<- %ebp 4/r32/esp - 4904 # setup - 4905 (clear-stream _test-input-stream) - 4906 (clear-stream $_test-input-buffered-file->buffer) - 4907 (clear-stream _test-output-stream) - 4908 (clear-stream $_test-output-buffered-file->buffer) - 4909 (clear-stream _test-error-stream) - 4910 (clear-stream $_test-error-buffered-file->buffer) - 4911 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 4912 68/push 0/imm32 - 4913 68/push 0/imm32 - 4914 89/<- %edx 4/r32/esp - 4915 (tailor-exit-descriptor %edx 0x10) - 4916 # - 4917 (write _test-input-stream "type t {\n") - 4918 (write _test-input-stream " a: (array int 3)\n") - 4919 (write _test-input-stream "}\n") - 4920 # convert - 4921 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 4922 # registers except esp clobbered at this point - 4923 # restore ed - 4924 89/<- %edx 4/r32/esp - 4925 (flush _test-output-buffered-file) - 4926 (flush _test-error-buffered-file) - 4927 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 4933 # check output - 4934 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty") - 4935 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message") - 4936 # check that stop(1) was called - 4937 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-array: exit status") - 4938 # don't restore from ebp - 4939 81 0/subop/add %esp 8/imm32 + 4203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0") + 4204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1") + 4205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-bytes/2") + 4206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-bytes/3") + 4207 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-bytes/4") + 4208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-bytes/5") + 4209 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-bytes/6") + 4210 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/7") + 4211 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/8") + 4212 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-bytes/9") + 4213 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-bytes/10") + 4214 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-bytes/11") + 4215 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-bytes/12") + 4216 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-bytes/13") + 4217 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-bytes/14") + 4218 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-bytes/15") + 4219 # . epilogue + 4220 89/<- %esp 5/r32/ebp + 4221 5d/pop-to-ebp + 4222 c3/return + 4223 + 4224 test-convert-length-of-array-on-stack: + 4225 # . prologue + 4226 55/push-ebp + 4227 89/<- %ebp 4/r32/esp + 4228 # setup + 4229 (clear-stream _test-input-stream) + 4230 (clear-stream $_test-input-buffered-file->buffer) + 4231 (clear-stream _test-output-stream) + 4232 (clear-stream $_test-output-buffered-file->buffer) + 4233 # + 4234 (write _test-input-stream "fn foo {\n") + 4235 (write _test-input-stream " var a: (array int 3)\n") + 4236 (write _test-input-stream " var b/eax: int <- length a\n") + 4237 (write _test-input-stream "}\n") + 4238 # convert + 4239 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4240 (flush _test-output-buffered-file) + 4241 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4247 # check output + 4248 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") + 4249 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") + 4250 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-on-stack/2") + 4251 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-on-stack/3") + 4252 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-on-stack/4") + 4253 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-on-stack/5") + 4254 # define x + 4255 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-length-of-array-on-stack/6") + 4256 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-length-of-array-on-stack/7") + 4257 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-on-stack/8") + 4258 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff0) 0x00000000/r32" "F - test-convert-length-of-array-on-stack/9") + 4259 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array-on-stack/10") + 4260 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-on-stack/11") + 4261 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-length-of-array-on-stack/12") + 4262 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-on-stack/13") + 4263 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-on-stack/14") + 4264 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-on-stack/15") + 4265 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-on-stack/16") + 4266 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-on-stack/17") + 4267 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-on-stack/18") + 4268 # . epilogue + 4269 89/<- %esp 5/r32/ebp + 4270 5d/pop-to-ebp + 4271 c3/return + 4272 + 4273 test-reg-var-def-with-read-of-same-register: + 4274 # . prologue + 4275 55/push-ebp + 4276 89/<- %ebp 4/r32/esp + 4277 # setup + 4278 (clear-stream _test-input-stream) + 4279 (clear-stream $_test-input-buffered-file->buffer) + 4280 (clear-stream _test-output-stream) + 4281 (clear-stream $_test-output-buffered-file->buffer) + 4282 (clear-stream _test-error-stream) + 4283 (clear-stream $_test-error-buffered-file->buffer) + 4284 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu + 4285 68/push 0/imm32 + 4286 68/push 0/imm32 + 4287 89/<- %edx 4/r32/esp + 4288 (tailor-exit-descriptor %edx 0x10) + 4289 # + 4290 (write _test-input-stream "fn foo {\n") + 4291 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 4292 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 4293 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 4294 (write _test-input-stream "}\n") + 4295 # convert + 4296 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 4297 # registers except esp could be clobbered at this point (though they shouldn't be) + 4298 # restore ed + 4299 89/<- %edx 4/r32/esp + 4300 (flush _test-output-buffered-file) + 4301 (flush _test-error-buffered-file) + 4302 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4308 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty") + 4309 # check output + 4310 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0") + 4311 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-reg-var-def-with-read-of-same-register/1") + 4312 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-reg-var-def-with-read-of-same-register/2") + 4313 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-reg-var-def-with-read-of-same-register/3") + 4314 (check-next-stream-line-equal _test-output-stream " {" "F - test-reg-var-def-with-read-of-same-register/4") + 4315 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-reg-var-def-with-read-of-same-register/5") + 4316 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-reg-var-def-with-read-of-same-register/6") + 4317 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-reg-var-def-with-read-of-same-register/7") + 4318 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-reg-var-def-with-read-of-same-register/8") + 4319 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-reg-var-def-with-read-of-same-register/9") + 4320 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-reg-var-def-with-read-of-same-register/11") + 4321 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-reg-var-def-with-read-of-same-register/13") + 4322 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-reg-var-def-with-read-of-same-register/14") + 4323 (check-next-stream-line-equal _test-output-stream " }" "F - test-reg-var-def-with-read-of-same-register/15") + 4324 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-reg-var-def-with-read-of-same-register/16") + 4325 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-reg-var-def-with-read-of-same-register/17") + 4326 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-reg-var-def-with-read-of-same-register/18") + 4327 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-reg-var-def-with-read-of-same-register/19") + 4328 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-reg-var-def-with-read-of-same-register/20") + 4329 # don't restore from ebp + 4330 81 0/subop/add %esp 8/imm32 + 4331 # . epilogue + 4332 5d/pop-to-ebp + 4333 c3/return + 4334 + 4335 test-convert-index-into-array: + 4336 # . prologue + 4337 55/push-ebp + 4338 89/<- %ebp 4/r32/esp + 4339 # setup + 4340 (clear-stream _test-input-stream) + 4341 (clear-stream $_test-input-buffered-file->buffer) + 4342 (clear-stream _test-output-stream) + 4343 (clear-stream $_test-output-buffered-file->buffer) + 4344 # + 4345 (write _test-input-stream "fn foo {\n") + 4346 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 4347 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 4348 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 4349 (write _test-input-stream "}\n") + 4350 # convert + 4351 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4352 (flush _test-output-buffered-file) + 4353 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4359 # check output + 4360 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") + 4361 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") + 4362 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array/2") + 4363 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array/3") + 4364 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array/4") + 4365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array/5") + 4366 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array/6") + 4367 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array/7") + 4368 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array/8") + 4369 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array/9") + 4370 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-convert-index-into-array/10") + 4371 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array/11") + 4372 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array/12") + 4373 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array/13") + 4374 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array/14") + 4375 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array/15") + 4376 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array/16") + 4377 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array/17") + 4378 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array/18") + 4379 # . epilogue + 4380 89/<- %esp 5/r32/ebp + 4381 5d/pop-to-ebp + 4382 c3/return + 4383 + 4384 test-convert-index-into-array-of-bytes: + 4385 # . prologue + 4386 55/push-ebp + 4387 89/<- %ebp 4/r32/esp + 4388 # setup + 4389 (clear-stream _test-input-stream) + 4390 (clear-stream $_test-input-buffered-file->buffer) + 4391 (clear-stream _test-output-stream) + 4392 (clear-stream $_test-output-buffered-file->buffer) + 4393 # + 4394 (write _test-input-stream "fn foo {\n") + 4395 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 4396 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 4397 (write _test-input-stream " var x/eax: (addr byte) <- index arr, idx\n") + 4398 (write _test-input-stream "}\n") + 4399 # convert + 4400 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4401 (flush _test-output-buffered-file) + 4402 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4408 # check output + 4409 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0") + 4410 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1") + 4411 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes/2") + 4412 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes/3") + 4413 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes/4") + 4414 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes/5") + 4415 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes/6") + 4416 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes/7") + 4417 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes/8") + 4418 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes/9") + 4419 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000000 + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes/11") + 4420 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes/13") + 4421 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes/14") + 4422 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes/15") + 4423 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes/16") + 4424 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes/17") + 4425 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes/18") + 4426 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes/19") + 4427 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes/20") + 4428 # . epilogue + 4429 89/<- %esp 5/r32/ebp + 4430 5d/pop-to-ebp + 4431 c3/return + 4432 + 4433 test-convert-index-into-array-with-literal: + 4434 # . prologue + 4435 55/push-ebp + 4436 89/<- %ebp 4/r32/esp + 4437 # setup + 4438 (clear-stream _test-input-stream) + 4439 (clear-stream $_test-input-buffered-file->buffer) + 4440 (clear-stream _test-output-stream) + 4441 (clear-stream $_test-output-buffered-file->buffer) + 4442 # + 4443 (write _test-input-stream "fn foo {\n") + 4444 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 4445 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") + 4446 (write _test-input-stream "}\n") + 4447 # convert + 4448 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4449 (flush _test-output-buffered-file) + 4450 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4456 # check output + 4457 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") + 4458 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") + 4459 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-with-literal/2") + 4460 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-with-literal/3") + 4461 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-with-literal/4") + 4462 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-with-literal/5") + 4463 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-with-literal/6") + 4464 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-with-literal/7") + 4465 # 2 * 4 bytes/elem + 4 bytes for size = offset 12 + 4466 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x0000000c) 0x00000000/r32" "F - test-convert-index-into-array-with-literal/8") + 4467 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-with-literal/9") + 4468 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-with-literal/10") + 4469 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-with-literal/11") + 4470 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-with-literal/12") + 4471 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-with-literal/13") + 4472 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-with-literal/14") + 4473 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-with-literal/15") + 4474 # . epilogue + 4475 89/<- %esp 5/r32/ebp + 4476 5d/pop-to-ebp + 4477 c3/return + 4478 + 4479 test-convert-index-into-array-of-bytes-with-literal: + 4480 # . prologue + 4481 55/push-ebp + 4482 89/<- %ebp 4/r32/esp + 4483 # setup + 4484 (clear-stream _test-input-stream) + 4485 (clear-stream $_test-input-buffered-file->buffer) + 4486 (clear-stream _test-output-stream) + 4487 (clear-stream $_test-output-buffered-file->buffer) + 4488 # + 4489 (write _test-input-stream "fn foo {\n") + 4490 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 4491 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") + 4492 (write _test-input-stream "}\n") + 4493 # convert + 4494 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4495 (flush _test-output-buffered-file) + 4496 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4502 # check output + 4503 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0") + 4504 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1") + 4505 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/2") + 4506 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-with-literal/3") + 4507 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-with-literal/4") + 4508 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-with-literal/5") + 4509 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-with-literal/6") + 4510 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-with-literal/7") + 4511 # 2 * 1 byte/elem + 4 bytes for size = offset 6 + 4512 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000006) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-with-literal/8") + 4513 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-with-literal/9") + 4514 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-with-literal/10") + 4515 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-with-literal/11") + 4516 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-with-literal/12") + 4517 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-with-literal/13") + 4518 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/14") + 4519 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-with-literal/15") + 4520 # . epilogue + 4521 89/<- %esp 5/r32/ebp + 4522 5d/pop-to-ebp + 4523 c3/return + 4524 + 4525 test-convert-index-into-array-on-stack: + 4526 # . prologue + 4527 55/push-ebp + 4528 89/<- %ebp 4/r32/esp + 4529 # setup + 4530 (clear-stream _test-input-stream) + 4531 (clear-stream $_test-input-buffered-file->buffer) + 4532 (clear-stream _test-output-stream) + 4533 (clear-stream $_test-output-buffered-file->buffer) + 4534 # + 4535 (write _test-input-stream "fn foo {\n") + 4536 (write _test-input-stream " var arr: (array int 3)\n") + 4537 (write _test-input-stream " var idx/eax: int <- copy 2\n") + 4538 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 4539 (write _test-input-stream "}\n") + 4540 # convert + 4541 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4542 (flush _test-output-buffered-file) + 4543 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4549 # check output + 4550 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") + 4551 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") + 4552 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack/2") + 4553 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack/3") + 4554 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack/4") + 4555 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack/5") + 4556 # var arr + 4557 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack/6") + 4558 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack/7") + 4559 # var idx + 4560 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack/8") + 4561 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 2/imm32" "F - test-convert-index-into-array-on-stack/9") + 4562 # var x is at (ebp-0x10) + idx<<2 + 4 = ebp + idx<<2 - 0xc + 4563 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + eax<<0x00000002 + 0xfffffff4) 0x00000000/r32" "F - test-convert-index-into-array-on-stack/10") + 4564 # reclaim idx + 4565 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack/11") + 4566 # reclaim arr + 4567 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack/12") + 4568 # + 4569 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack/13") + 4570 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack/14") + 4571 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack/15") + 4572 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack/16") + 4573 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack/17") + 4574 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack/18") + 4575 # . epilogue + 4576 89/<- %esp 5/r32/ebp + 4577 5d/pop-to-ebp + 4578 c3/return + 4579 + 4580 test-convert-index-into-array-on-stack-with-literal: + 4581 # . prologue + 4582 55/push-ebp + 4583 89/<- %ebp 4/r32/esp + 4584 # setup + 4585 (clear-stream _test-input-stream) + 4586 (clear-stream $_test-input-buffered-file->buffer) + 4587 (clear-stream _test-output-stream) + 4588 (clear-stream $_test-output-buffered-file->buffer) + 4589 # + 4590 (write _test-input-stream "fn foo {\n") + 4591 (write _test-input-stream " var arr: (array int 3)\n") + 4592 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") + 4593 (write _test-input-stream "}\n") + 4594 # convert + 4595 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4596 (flush _test-output-buffered-file) + 4597 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4603 # check output + 4604 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") + 4605 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") + 4606 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack-with-literal/2") + 4607 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack-with-literal/3") + 4608 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack-with-literal/4") + 4609 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack-with-literal/5") + 4610 # var arr + 4611 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack-with-literal/6") + 4612 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack-with-literal/7") + 4613 # var x + 4614 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack-with-literal/8") + 4615 # x is at (ebp-0x10) + 4 + 2*4 = ebp-4 + 4616 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xfffffffc) 0x00000000/r32" "F - test-convert-index-into-array-on-stack-with-literal/9") + 4617 # reclaim x + 4618 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack-with-literal/10") + 4619 # reclaim arr + 4620 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack-with-literal/11") + 4621 # + 4622 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack-with-literal/12") + 4623 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack-with-literal/13") + 4624 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack-with-literal/14") + 4625 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack-with-literal/15") + 4626 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack-with-literal/16") + 4627 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack-with-literal/17") + 4628 # . epilogue + 4629 89/<- %esp 5/r32/ebp + 4630 5d/pop-to-ebp + 4631 c3/return + 4632 + 4633 test-convert-index-into-array-of-bytes-on-stack-with-literal: + 4634 # . prologue + 4635 55/push-ebp + 4636 89/<- %ebp 4/r32/esp + 4637 # setup + 4638 (clear-stream _test-input-stream) + 4639 (clear-stream $_test-input-buffered-file->buffer) + 4640 (clear-stream _test-output-stream) + 4641 (clear-stream $_test-output-buffered-file->buffer) + 4642 # + 4643 (write _test-input-stream "fn foo {\n") + 4644 (write _test-input-stream " var arr: (array byte 3)\n") + 4645 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") + 4646 (write _test-input-stream "}\n") + 4647 # convert + 4648 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4649 (flush _test-output-buffered-file) + 4650 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4656 # check output + 4657 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0") + 4658 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1") + 4659 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/2") + 4660 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/3") + 4661 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/4") + 4662 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/5") + 4663 # var arr + 4664 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/6") + 4665 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/7") + 4666 # var x + 4667 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/8") + 4668 # x is at (ebp-7) + 4 + 2 = ebp-1 + 4669 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xffffffff) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/9") + 4670 # reclaim x + 4671 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/10") + 4672 # reclaim arr + 4673 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/11") + 4674 # + 4675 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/12") + 4676 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/13") + 4677 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/14") + 4678 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/15") + 4679 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/16") + 4680 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/17") + 4681 # . epilogue + 4682 89/<- %esp 5/r32/ebp + 4683 5d/pop-to-ebp + 4684 c3/return + 4685 + 4686 test-convert-index-into-array-using-offset: + 4687 # . prologue + 4688 55/push-ebp + 4689 89/<- %ebp 4/r32/esp + 4690 # setup + 4691 (clear-stream _test-input-stream) + 4692 (clear-stream $_test-input-buffered-file->buffer) + 4693 (clear-stream _test-output-stream) + 4694 (clear-stream $_test-output-buffered-file->buffer) + 4695 # + 4696 (write _test-input-stream "fn foo {\n") + 4697 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 4698 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 4699 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") + 4700 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") + 4701 (write _test-input-stream "}\n") + 4702 # convert + 4703 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4704 (flush _test-output-buffered-file) + 4705 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4711 # check output + 4712 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") + 4713 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") + 4714 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset/2") + 4715 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset/3") + 4716 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset/4") + 4717 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset/5") + 4718 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset/6") + 4719 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset/7") + 4720 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset/8") + 4721 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-using-offset/9") + 4722 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset/10") + 4723 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset/11") + 4724 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset/12") + 4725 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset/13") + 4726 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset/14") + 4727 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset/15") + 4728 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset/16") + 4729 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset/17") + 4730 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset/18") + 4731 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset/19") + 4732 # . epilogue + 4733 89/<- %esp 5/r32/ebp + 4734 5d/pop-to-ebp + 4735 c3/return + 4736 + 4737 test-convert-index-into-array-of-bytes-using-offset: + 4738 # . prologue + 4739 55/push-ebp + 4740 89/<- %ebp 4/r32/esp + 4741 # setup + 4742 (clear-stream _test-input-stream) + 4743 (clear-stream $_test-input-buffered-file->buffer) + 4744 (clear-stream _test-output-stream) + 4745 (clear-stream $_test-output-buffered-file->buffer) + 4746 # + 4747 (write _test-input-stream "fn foo {\n") + 4748 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 4749 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 4750 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") + 4751 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") + 4752 (write _test-input-stream "}\n") + 4753 # convert + 4754 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4755 (flush _test-output-buffered-file) + 4756 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4762 # check output + 4763 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0") + 4764 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1") + 4765 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/2") + 4766 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset/3") + 4767 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset/4") + 4768 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset/5") + 4769 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset/6") + 4770 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/7") + 4771 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/8") + 4772 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/9") + 4773 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset/10") + 4774 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset/11") + 4775 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/12") + 4776 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset/13") + 4777 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset/14") + 4778 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset/15") + 4779 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset/16") + 4780 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset/17") + 4781 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/18") + 4782 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset/19") + 4783 # . epilogue + 4784 89/<- %esp 5/r32/ebp + 4785 5d/pop-to-ebp + 4786 c3/return + 4787 + 4788 test-convert-index-into-array-using-offset-on-stack: + 4789 # . prologue + 4790 55/push-ebp + 4791 89/<- %ebp 4/r32/esp + 4792 # setup + 4793 (clear-stream _test-input-stream) + 4794 (clear-stream $_test-input-buffered-file->buffer) + 4795 (clear-stream _test-output-stream) + 4796 (clear-stream $_test-output-buffered-file->buffer) + 4797 # + 4798 (write _test-input-stream "fn foo {\n") + 4799 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 4800 (write _test-input-stream " var idx: int\n") + 4801 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") + 4802 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") + 4803 (write _test-input-stream "}\n") + 4804 # convert + 4805 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4806 (flush _test-output-buffered-file) + 4807 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4813 # check output + 4814 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") + 4815 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") + 4816 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset-on-stack/2") + 4817 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset-on-stack/3") + 4818 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset-on-stack/4") + 4819 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset-on-stack/5") + 4820 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset-on-stack/6") + 4821 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/7") + 4822 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/8") + 4823 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset-on-stack/9") + 4824 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset-on-stack/10") + 4825 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset-on-stack/11") + 4826 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset-on-stack/12") + 4827 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-using-offset-on-stack/13") + 4828 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset-on-stack/14") + 4829 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset-on-stack/15") + 4830 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset-on-stack/16") + 4831 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset-on-stack/17") + 4832 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset-on-stack/18") + 4833 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset-on-stack/19") + 4834 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset-on-stack/20") + 4835 # . epilogue + 4836 89/<- %esp 5/r32/ebp + 4837 5d/pop-to-ebp + 4838 c3/return + 4839 + 4840 test-convert-index-into-array-of-bytes-using-offset-on-stack: + 4841 # . prologue + 4842 55/push-ebp + 4843 89/<- %ebp 4/r32/esp + 4844 # setup + 4845 (clear-stream _test-input-stream) + 4846 (clear-stream $_test-input-buffered-file->buffer) + 4847 (clear-stream _test-output-stream) + 4848 (clear-stream $_test-output-buffered-file->buffer) + 4849 # + 4850 (write _test-input-stream "fn foo {\n") + 4851 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 4852 (write _test-input-stream " var idx: int\n") + 4853 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") + 4854 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") + 4855 (write _test-input-stream "}\n") + 4856 # convert + 4857 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4858 (flush _test-output-buffered-file) + 4859 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4865 # check output + 4866 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0") + 4867 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1") + 4868 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/2") + 4869 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/3") + 4870 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/4") + 4871 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/5") + 4872 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/6") + 4873 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/7") + 4874 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/8") + 4875 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/9") + 4876 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/10") + 4877 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/11") + 4878 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/12") + 4879 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/13") + 4880 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/14") + 4881 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/15") + 4882 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/16") + 4883 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/17") + 4884 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/18") + 4885 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/19") + 4886 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/20") + 4887 # . epilogue + 4888 89/<- %esp 5/r32/ebp + 4889 5d/pop-to-ebp + 4890 c3/return + 4891 + 4892 test-convert-function-and-type-definition: + 4893 # . prologue + 4894 55/push-ebp + 4895 89/<- %ebp 4/r32/esp + 4896 # setup + 4897 (clear-stream _test-input-stream) + 4898 (clear-stream $_test-input-buffered-file->buffer) + 4899 (clear-stream _test-output-stream) + 4900 (clear-stream $_test-output-buffered-file->buffer) + 4901 # + 4902 (write _test-input-stream "fn foo a: (addr t) {\n") + 4903 (write _test-input-stream " var _a/eax: (addr t) <- copy a\n") + 4904 (write _test-input-stream " var b/ecx: (addr int) <- get _a, x\n") + 4905 (write _test-input-stream " var c/ecx: (addr int) <- get _a, y\n") + 4906 (write _test-input-stream "}\n") + 4907 (write _test-input-stream "type t {\n") + 4908 (write _test-input-stream " x: int\n") + 4909 (write _test-input-stream " y: int\n") + 4910 (write _test-input-stream "}\n") + 4911 # convert + 4912 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4913 (flush _test-output-buffered-file) + 4914 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 4920 # check output + 4921 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") + 4922 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") + 4923 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-and-type-definition/2") + 4924 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-and-type-definition/3") + 4925 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-and-type-definition/4") + 4926 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-and-type-definition/5") + 4927 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-and-type-definition/6") + 4928 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-and-type-definition/7") + 4929 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-and-type-definition/8") + 4930 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000000) 0x00000001/r32" "F - test-convert-function-and-type-definition/9") + 4931 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000004) 0x00000001/r32" "F - test-convert-function-and-type-definition/11") + 4932 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-and-type-definition/13") + 4933 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-and-type-definition/14") + 4934 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-and-type-definition/15") + 4935 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-and-type-definition/16") + 4936 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-and-type-definition/17") + 4937 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-and-type-definition/18") + 4938 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-and-type-definition/19") + 4939 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-and-type-definition/20") 4940 # . epilogue - 4941 5d/pop-to-ebp - 4942 c3/return - 4943 - 4944 test-type-definition-with-addr: - 4945 # . prologue - 4946 55/push-ebp - 4947 89/<- %ebp 4/r32/esp - 4948 # setup - 4949 (clear-stream _test-input-stream) - 4950 (clear-stream $_test-input-buffered-file->buffer) - 4951 (clear-stream _test-output-stream) - 4952 (clear-stream $_test-output-buffered-file->buffer) - 4953 (clear-stream _test-error-stream) - 4954 (clear-stream $_test-error-buffered-file->buffer) - 4955 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 4956 68/push 0/imm32 + 4941 89/<- %esp 5/r32/ebp + 4942 5d/pop-to-ebp + 4943 c3/return + 4944 + 4945 test-type-definition-with-array: + 4946 # . prologue + 4947 55/push-ebp + 4948 89/<- %ebp 4/r32/esp + 4949 # setup + 4950 (clear-stream _test-input-stream) + 4951 (clear-stream $_test-input-buffered-file->buffer) + 4952 (clear-stream _test-output-stream) + 4953 (clear-stream $_test-output-buffered-file->buffer) + 4954 (clear-stream _test-error-stream) + 4955 (clear-stream $_test-error-buffered-file->buffer) + 4956 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) 4957 68/push 0/imm32 - 4958 89/<- %edx 4/r32/esp - 4959 (tailor-exit-descriptor %edx 0x10) - 4960 # - 4961 (write _test-input-stream "type t {\n") - 4962 (write _test-input-stream " a: (addr int)\n") - 4963 (write _test-input-stream "}\n") - 4964 # convert - 4965 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 4966 # registers except esp clobbered at this point - 4967 # restore ed - 4968 89/<- %edx 4/r32/esp - 4969 (flush _test-output-buffered-file) - 4970 (flush _test-error-buffered-file) - 4971 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 4977 # check output - 4978 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty") - 4979 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message") - 4980 # check that stop(1) was called - 4981 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-addr: exit status") - 4982 # don't restore from ebp - 4983 81 0/subop/add %esp 8/imm32 - 4984 # . epilogue - 4985 5d/pop-to-ebp - 4986 c3/return - 4987 - 4988 test-convert-function-with-local-var-with-user-defined-type: - 4989 # . prologue - 4990 55/push-ebp - 4991 89/<- %ebp 4/r32/esp - 4992 # setup - 4993 (clear-stream _test-input-stream) - 4994 (clear-stream $_test-input-buffered-file->buffer) - 4995 (clear-stream _test-output-stream) - 4996 (clear-stream $_test-output-buffered-file->buffer) - 4997 # - 4998 (write _test-input-stream "fn foo {\n") - 4999 (write _test-input-stream " var a: t\n") - 5000 (write _test-input-stream "}\n") - 5001 (write _test-input-stream "type t {\n") - 5002 (write _test-input-stream " x: int\n") - 5003 (write _test-input-stream " y: int\n") - 5004 (write _test-input-stream "}\n") - 5005 # convert - 5006 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5007 (flush _test-output-buffered-file) - 5008 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5014 # check output - 5015 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") - 5016 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") - 5017 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/2") - 5018 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type/3") - 5019 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type/4") - 5020 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type/5") - 5021 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/6") - 5022 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/7") - 5023 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/8") - 5024 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type/9") - 5025 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type/10") - 5026 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type/11") - 5027 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type/12") - 5028 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/13") - 5029 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type/14") - 5030 # . epilogue - 5031 89/<- %esp 5/r32/ebp - 5032 5d/pop-to-ebp - 5033 c3/return - 5034 - 5035 test-convert-function-call-with-arg-of-user-defined-type: - 5036 # . prologue - 5037 55/push-ebp - 5038 89/<- %ebp 4/r32/esp - 5039 # setup - 5040 (clear-stream _test-input-stream) - 5041 (clear-stream $_test-input-buffered-file->buffer) - 5042 (clear-stream _test-output-stream) - 5043 (clear-stream $_test-output-buffered-file->buffer) - 5044 # - 5045 (write _test-input-stream "fn f {\n") - 5046 (write _test-input-stream " var a: t\n") - 5047 (write _test-input-stream " foo a\n") - 5048 (write _test-input-stream "}\n") - 5049 (write _test-input-stream "fn foo x: t {\n") - 5050 (write _test-input-stream "}\n") - 5051 (write _test-input-stream "type t {\n") - 5052 (write _test-input-stream " x: int\n") - 5053 (write _test-input-stream " y: int\n") - 5054 (write _test-input-stream "}\n") - 5055 # convert - 5056 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5057 (flush _test-output-buffered-file) - 5058 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5064 # check output - 5065 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") - 5066 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") - 5067 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") - 5068 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") - 5069 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") - 5070 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") - 5071 # var a: t - 5072 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/6") - 5073 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") - 5074 # foo a - 5075 (check-next-stream-line-equal _test-output-stream " (foo *(ebp+0xfffffff8) *(ebp+0xfffffffc))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") - 5076 # - 5077 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/9") - 5078 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") - 5079 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") - 5080 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") - 5081 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") - 5082 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") - 5083 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") - 5084 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") - 5085 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") - 5086 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") - 5087 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") - 5088 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") - 5089 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") - 5090 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") - 5091 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") - 5092 # . epilogue - 5093 89/<- %esp 5/r32/ebp - 5094 5d/pop-to-ebp - 5095 c3/return - 5096 - 5097 test-convert-function-call-with-arg-of-user-defined-type-register-indirect: - 5098 # . prologue - 5099 55/push-ebp - 5100 89/<- %ebp 4/r32/esp - 5101 # setup - 5102 (clear-stream _test-input-stream) - 5103 (clear-stream $_test-input-buffered-file->buffer) - 5104 (clear-stream _test-output-stream) - 5105 (clear-stream $_test-output-buffered-file->buffer) - 5106 # - 5107 (write _test-input-stream "fn f {\n") - 5108 (write _test-input-stream " var a/eax: (addr t) <- copy 0\n") - 5109 (write _test-input-stream " foo *a\n") - 5110 (write _test-input-stream "}\n") - 5111 (write _test-input-stream "fn foo x: t {\n") - 5112 (write _test-input-stream "}\n") - 5113 (write _test-input-stream "type t {\n") - 5114 (write _test-input-stream " x: int\n") - 5115 (write _test-input-stream " y: int\n") - 5116 (write _test-input-stream "}\n") - 5117 # convert - 5118 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5119 (flush _test-output-buffered-file) - 5120 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5126 # check output - 5127 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") - 5128 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") - 5129 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") - 5130 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") - 5131 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") - 5132 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") - 5133 # var a - 5134 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/6") - 5135 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") - 5136 # foo a - 5137 (check-next-stream-line-equal _test-output-stream " (foo *(eax+0x00000000) *(eax+0x00000004))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") - 5138 # - 5139 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/9") - 5140 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") - 5141 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") - 5142 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") - 5143 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") - 5144 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") - 5145 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") - 5146 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") - 5147 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") - 5148 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") - 5149 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") - 5150 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") - 5151 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") - 5152 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") - 5153 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") - 5154 # . epilogue - 5155 89/<- %esp 5/r32/ebp - 5156 5d/pop-to-ebp - 5157 c3/return - 5158 - 5159 # we don't have special support for call-by-reference; just explicitly create - 5160 # a new variable with the address of the arg - 5161 test-convert-function-call-with-arg-of-user-defined-type-by-reference: - 5162 # . prologue - 5163 55/push-ebp - 5164 89/<- %ebp 4/r32/esp - 5165 # setup - 5166 (clear-stream _test-input-stream) - 5167 (clear-stream $_test-input-buffered-file->buffer) - 5168 (clear-stream _test-output-stream) - 5169 (clear-stream $_test-output-buffered-file->buffer) - 5170 # - 5171 (write _test-input-stream "fn f {\n") - 5172 (write _test-input-stream " var a: t\n") - 5173 (write _test-input-stream " var b/eax: (addr t) <- address a\n") - 5174 (write _test-input-stream " foo b\n") - 5175 (write _test-input-stream "}\n") - 5176 (write _test-input-stream "fn foo x: (addr t) {\n") - 5177 (write _test-input-stream " var x/ecx: (addr int) <- copy x\n") - 5178 (write _test-input-stream " increment *x\n") - 5179 (write _test-input-stream "}\n") - 5180 (write _test-input-stream "type t {\n") - 5181 (write _test-input-stream " x: int\n") - 5182 (write _test-input-stream " y: int\n") - 5183 (write _test-input-stream "}\n") - 5184 # convert - 5185 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5186 (flush _test-output-buffered-file) - 5187 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5193 # check output - 5194 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") - 5195 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") - 5196 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/2") - 5197 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/3") - 5198 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/4") - 5199 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/5") - 5200 # var a: t - 5201 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/6") - 5202 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/7") - 5203 # var b/eax: (addr t) - 5204 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/8") - 5205 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/9") - 5206 # foo a - 5207 (check-next-stream-line-equal _test-output-stream " (foo %eax)" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/10") - 5208 # - 5209 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/11") - 5210 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/12") - 5211 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/13") - 5212 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/14") - 5213 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/15") - 5214 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/16") - 5215 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/17") - 5216 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/18") - 5217 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/19") - 5218 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/20") - 5219 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/21") - 5220 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/22") - 5221 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23") - 5222 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24") - 5223 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25") - 5224 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000001/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26") - 5225 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27") - 5226 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28") - 5227 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29") - 5228 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/30") - 5229 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/31") - 5230 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/32") - 5231 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/33") - 5232 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/34") - 5233 # . epilogue - 5234 89/<- %esp 5/r32/ebp - 5235 5d/pop-to-ebp - 5236 c3/return - 5237 - 5238 test-convert-get-on-local-variable: - 5239 # . prologue - 5240 55/push-ebp - 5241 89/<- %ebp 4/r32/esp - 5242 # setup - 5243 (clear-stream _test-input-stream) - 5244 (clear-stream $_test-input-buffered-file->buffer) - 5245 (clear-stream _test-output-stream) - 5246 (clear-stream $_test-output-buffered-file->buffer) - 5247 # - 5248 (write _test-input-stream "fn foo {\n") - 5249 (write _test-input-stream " var a: t\n") - 5250 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 5251 (write _test-input-stream "}\n") - 5252 (write _test-input-stream "type t {\n") - 5253 (write _test-input-stream " x: int\n") - 5254 (write _test-input-stream " y: int\n") - 5255 (write _test-input-stream "}\n") - 5256 # convert - 5257 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5258 (flush _test-output-buffered-file) - 5259 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5265 # check output - 5266 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") - 5267 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") - 5268 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-local-variable/2") - 5269 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-local-variable/3") - 5270 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-local-variable/4") - 5271 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-local-variable/5") - 5272 # var a - 5273 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/6") - 5274 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/7") - 5275 # var c - 5276 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-local-variable/8") - 5277 # get - 5278 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000001/r32" "F - test-convert-get-on-local-variable/9") - 5279 # reclaim c - 5280 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-local-variable/10") - 5281 # reclaim a - 5282 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-get-on-local-variable/11") - 5283 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-local-variable/12") - 5284 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-local-variable/13") - 5285 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-local-variable/14") - 5286 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-local-variable/15") - 5287 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-local-variable/16") - 5288 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-local-variable/17") - 5289 # . epilogue - 5290 89/<- %esp 5/r32/ebp - 5291 5d/pop-to-ebp - 5292 c3/return - 5293 - 5294 test-convert-get-on-function-argument: - 5295 # . prologue - 5296 55/push-ebp - 5297 89/<- %ebp 4/r32/esp - 5298 # setup - 5299 (clear-stream _test-input-stream) - 5300 (clear-stream $_test-input-buffered-file->buffer) - 5301 (clear-stream _test-output-stream) - 5302 (clear-stream $_test-output-buffered-file->buffer) - 5303 # - 5304 (write _test-input-stream "fn foo a: t {\n") - 5305 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 5306 (write _test-input-stream "}\n") - 5307 (write _test-input-stream "type t {\n") - 5308 (write _test-input-stream " x: int\n") - 5309 (write _test-input-stream " y: int\n") - 5310 (write _test-input-stream "}\n") - 5311 # convert - 5312 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5313 (flush _test-output-buffered-file) - 5314 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5320 # check output - 5321 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") - 5322 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") - 5323 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument/2") - 5324 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument/3") - 5325 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument/4") - 5326 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument/5") - 5327 # var c - 5328 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument/6") - 5329 # get - 5330 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument/7") - 5331 # reclaim c - 5332 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument/8") - 5333 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument/9") - 5334 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument/10") - 5335 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument/11") - 5336 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument/12") - 5337 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument/13") - 5338 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument/14") - 5339 # . epilogue - 5340 89/<- %esp 5/r32/ebp - 5341 5d/pop-to-ebp - 5342 c3/return - 5343 - 5344 test-convert-get-on-function-argument-with-known-type: - 5345 # . prologue - 5346 55/push-ebp - 5347 89/<- %ebp 4/r32/esp - 5348 # setup - 5349 (clear-stream _test-input-stream) - 5350 (clear-stream $_test-input-buffered-file->buffer) - 5351 (clear-stream _test-output-stream) - 5352 (clear-stream $_test-output-buffered-file->buffer) - 5353 # - 5354 (write _test-input-stream "type t {\n") - 5355 (write _test-input-stream " x: int\n") - 5356 (write _test-input-stream " y: int\n") - 5357 (write _test-input-stream "}\n") - 5358 (write _test-input-stream "fn foo a: t {\n") - 5359 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 5360 (write _test-input-stream "}\n") - 5361 # convert - 5362 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5363 (flush _test-output-buffered-file) - 5364 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 5370 # check output - 5371 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") - 5372 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") - 5373 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument-with-known-type/2") - 5374 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument-with-known-type/3") - 5375 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument-with-known-type/4") - 5376 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument-with-known-type/5") - 5377 # var c - 5378 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument-with-known-type/6") - 5379 # get - 5380 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument-with-known-type/7") - 5381 # reclaim c - 5382 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument-with-known-type/8") - 5383 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument-with-known-type/9") - 5384 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument-with-known-type/10") - 5385 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument-with-known-type/11") - 5386 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument-with-known-type/12") - 5387 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument-with-known-type/13") - 5388 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument-with-known-type/14") - 5389 # . epilogue - 5390 89/<- %esp 5/r32/ebp - 5391 5d/pop-to-ebp - 5392 c3/return - 5393 - 5394 test-add-with-too-many-inouts: - 5395 # . prologue - 5396 55/push-ebp - 5397 89/<- %ebp 4/r32/esp - 5398 # setup - 5399 (clear-stream _test-input-stream) - 5400 (clear-stream $_test-input-buffered-file->buffer) - 5401 (clear-stream _test-output-stream) - 5402 (clear-stream $_test-output-buffered-file->buffer) - 5403 (clear-stream _test-error-stream) - 5404 (clear-stream $_test-error-buffered-file->buffer) - 5405 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5406 68/push 0/imm32 - 5407 68/push 0/imm32 - 5408 89/<- %edx 4/r32/esp - 5409 (tailor-exit-descriptor %edx 0x10) - 5410 # - 5411 (write _test-input-stream "fn foo {\n") - 5412 (write _test-input-stream " var a: int\n") - 5413 (write _test-input-stream " var b/ecx: int <- add a, 0\n") - 5414 (write _test-input-stream "}\n") - 5415 # convert - 5416 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5417 # registers except esp clobbered at this point - 5418 # restore ed - 5419 89/<- %edx 4/r32/esp - 5420 (flush _test-output-buffered-file) - 5421 (flush _test-error-buffered-file) - 5422 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5428 # check output - 5429 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty") - 5430 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message") - 5431 # check that stop(1) was called - 5432 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts: exit status") - 5433 # don't restore from ebp - 5434 81 0/subop/add %esp 8/imm32 - 5435 # . epilogue - 5436 5d/pop-to-ebp - 5437 c3/return - 5438 - 5439 test-add-with-too-many-inouts-2: - 5440 # . prologue - 5441 55/push-ebp - 5442 89/<- %ebp 4/r32/esp - 5443 # setup - 5444 (clear-stream _test-input-stream) - 5445 (clear-stream $_test-input-buffered-file->buffer) - 5446 (clear-stream _test-output-stream) - 5447 (clear-stream $_test-output-buffered-file->buffer) - 5448 (clear-stream _test-error-stream) - 5449 (clear-stream $_test-error-buffered-file->buffer) - 5450 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5451 68/push 0/imm32 - 5452 68/push 0/imm32 - 5453 89/<- %edx 4/r32/esp - 5454 (tailor-exit-descriptor %edx 0x10) - 5455 # - 5456 (write _test-input-stream "fn foo {\n") - 5457 (write _test-input-stream " var a: int\n") - 5458 (write _test-input-stream " add-to a, 0, 1\n") - 5459 (write _test-input-stream "}\n") - 5460 # convert - 5461 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5462 # registers except esp clobbered at this point - 5463 # restore ed - 5464 89/<- %edx 4/r32/esp - 5465 (flush _test-output-buffered-file) - 5466 (flush _test-error-buffered-file) - 5467 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5473 # check output - 5474 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty") - 5475 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message") - 5476 # check that stop(1) was called - 5477 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts-2: exit status") - 5478 # don't restore from ebp - 5479 81 0/subop/add %esp 8/imm32 - 5480 # . epilogue - 5481 5d/pop-to-ebp - 5482 c3/return - 5483 - 5484 test-add-with-too-many-outputs: - 5485 # . prologue - 5486 55/push-ebp - 5487 89/<- %ebp 4/r32/esp - 5488 # setup - 5489 (clear-stream _test-input-stream) - 5490 (clear-stream $_test-input-buffered-file->buffer) - 5491 (clear-stream _test-output-stream) - 5492 (clear-stream $_test-output-buffered-file->buffer) - 5493 (clear-stream _test-error-stream) - 5494 (clear-stream $_test-error-buffered-file->buffer) - 5495 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5496 68/push 0/imm32 - 5497 68/push 0/imm32 - 5498 89/<- %edx 4/r32/esp - 5499 (tailor-exit-descriptor %edx 0x10) - 5500 # - 5501 (write _test-input-stream "fn foo {\n") - 5502 (write _test-input-stream " var a/eax: int <- copy 0\n") - 5503 (write _test-input-stream " var b/ebx: int <- copy 0\n") - 5504 (write _test-input-stream " var c/ecx: int <- copy 0\n") - 5505 (write _test-input-stream " c, b <- add a\n") - 5506 (write _test-input-stream "}\n") - 5507 # convert - 5508 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5509 # registers except esp clobbered at this point - 5510 # restore ed - 5511 89/<- %edx 4/r32/esp - 5512 (flush _test-output-buffered-file) - 5513 (flush _test-error-buffered-file) - 5514 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5520 # check output - 5521 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty") - 5522 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message") - 5523 # check that stop(1) was called - 5524 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-outputs: exit status") - 5525 # don't restore from ebp - 5526 81 0/subop/add %esp 8/imm32 - 5527 # . epilogue - 5528 5d/pop-to-ebp - 5529 c3/return - 5530 - 5531 test-add-with-non-number: - 5532 # . prologue - 5533 55/push-ebp - 5534 89/<- %ebp 4/r32/esp - 5535 # setup - 5536 (clear-stream _test-input-stream) - 5537 (clear-stream $_test-input-buffered-file->buffer) - 5538 (clear-stream _test-output-stream) - 5539 (clear-stream $_test-output-buffered-file->buffer) - 5540 (clear-stream _test-error-stream) - 5541 (clear-stream $_test-error-buffered-file->buffer) - 5542 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5543 68/push 0/imm32 + 4958 68/push 0/imm32 + 4959 89/<- %edx 4/r32/esp + 4960 (tailor-exit-descriptor %edx 0x10) + 4961 # + 4962 (write _test-input-stream "type t {\n") + 4963 (write _test-input-stream " a: (array int 3)\n") + 4964 (write _test-input-stream "}\n") + 4965 # convert + 4966 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 4967 # registers except esp clobbered at this point + 4968 # restore ed + 4969 89/<- %edx 4/r32/esp + 4970 (flush _test-output-buffered-file) + 4971 (flush _test-error-buffered-file) + 4972 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 4978 # check output + 4979 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty") + 4980 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message") + 4981 # check that stop(1) was called + 4982 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-array: exit status") + 4983 # don't restore from ebp + 4984 81 0/subop/add %esp 8/imm32 + 4985 # . epilogue + 4986 5d/pop-to-ebp + 4987 c3/return + 4988 + 4989 test-type-definition-with-addr: + 4990 # . prologue + 4991 55/push-ebp + 4992 89/<- %ebp 4/r32/esp + 4993 # setup + 4994 (clear-stream _test-input-stream) + 4995 (clear-stream $_test-input-buffered-file->buffer) + 4996 (clear-stream _test-output-stream) + 4997 (clear-stream $_test-output-buffered-file->buffer) + 4998 (clear-stream _test-error-stream) + 4999 (clear-stream $_test-error-buffered-file->buffer) + 5000 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5001 68/push 0/imm32 + 5002 68/push 0/imm32 + 5003 89/<- %edx 4/r32/esp + 5004 (tailor-exit-descriptor %edx 0x10) + 5005 # + 5006 (write _test-input-stream "type t {\n") + 5007 (write _test-input-stream " a: (addr int)\n") + 5008 (write _test-input-stream "}\n") + 5009 # convert + 5010 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5011 # registers except esp clobbered at this point + 5012 # restore ed + 5013 89/<- %edx 4/r32/esp + 5014 (flush _test-output-buffered-file) + 5015 (flush _test-error-buffered-file) + 5016 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5022 # check output + 5023 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty") + 5024 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message") + 5025 # check that stop(1) was called + 5026 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-addr: exit status") + 5027 # don't restore from ebp + 5028 81 0/subop/add %esp 8/imm32 + 5029 # . epilogue + 5030 5d/pop-to-ebp + 5031 c3/return + 5032 + 5033 test-convert-function-with-local-var-with-user-defined-type: + 5034 # . prologue + 5035 55/push-ebp + 5036 89/<- %ebp 4/r32/esp + 5037 # setup + 5038 (clear-stream _test-input-stream) + 5039 (clear-stream $_test-input-buffered-file->buffer) + 5040 (clear-stream _test-output-stream) + 5041 (clear-stream $_test-output-buffered-file->buffer) + 5042 # + 5043 (write _test-input-stream "fn foo {\n") + 5044 (write _test-input-stream " var a: t\n") + 5045 (write _test-input-stream "}\n") + 5046 (write _test-input-stream "type t {\n") + 5047 (write _test-input-stream " x: int\n") + 5048 (write _test-input-stream " y: int\n") + 5049 (write _test-input-stream "}\n") + 5050 # convert + 5051 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5052 (flush _test-output-buffered-file) + 5053 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5059 # check output + 5060 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") + 5061 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") + 5062 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/2") + 5063 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type/3") + 5064 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type/4") + 5065 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type/5") + 5066 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/6") + 5067 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/7") + 5068 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/8") + 5069 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type/9") + 5070 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type/10") + 5071 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type/11") + 5072 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type/12") + 5073 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/13") + 5074 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type/14") + 5075 # . epilogue + 5076 89/<- %esp 5/r32/ebp + 5077 5d/pop-to-ebp + 5078 c3/return + 5079 + 5080 test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type: + 5081 # . prologue + 5082 55/push-ebp + 5083 89/<- %ebp 4/r32/esp + 5084 # setup + 5085 (clear-stream _test-input-stream) + 5086 (clear-stream $_test-input-buffered-file->buffer) + 5087 (clear-stream _test-output-stream) + 5088 (clear-stream $_test-output-buffered-file->buffer) + 5089 # + 5090 (write _test-input-stream "fn foo {\n") + 5091 (write _test-input-stream " var a: t\n") + 5092 (write _test-input-stream "}\n") + 5093 (write _test-input-stream "type t {\n") + 5094 (write _test-input-stream " x: s\n") + 5095 (write _test-input-stream "}\n") + 5096 (write _test-input-stream "type s {\n") + 5097 (write _test-input-stream " z: int\n") + 5098 (write _test-input-stream "}\n") + 5099 # convert + 5100 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5101 (flush _test-output-buffered-file) + 5102 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5108 # check output + 5109 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/0") + 5110 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/1") + 5111 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/2") + 5112 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/3") + 5113 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/4") + 5114 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/5") + 5115 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/7") + 5116 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/8") + 5117 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/9") + 5118 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/10") + 5119 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/11") + 5120 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/12") + 5121 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/13") + 5122 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/14") + 5123 # . epilogue + 5124 89/<- %esp 5/r32/ebp + 5125 5d/pop-to-ebp + 5126 c3/return + 5127 + 5128 test-convert-function-call-with-arg-of-user-defined-type: + 5129 # . prologue + 5130 55/push-ebp + 5131 89/<- %ebp 4/r32/esp + 5132 # setup + 5133 (clear-stream _test-input-stream) + 5134 (clear-stream $_test-input-buffered-file->buffer) + 5135 (clear-stream _test-output-stream) + 5136 (clear-stream $_test-output-buffered-file->buffer) + 5137 # + 5138 (write _test-input-stream "fn f {\n") + 5139 (write _test-input-stream " var a: t\n") + 5140 (write _test-input-stream " foo a\n") + 5141 (write _test-input-stream "}\n") + 5142 (write _test-input-stream "fn foo x: t {\n") + 5143 (write _test-input-stream "}\n") + 5144 (write _test-input-stream "type t {\n") + 5145 (write _test-input-stream " x: int\n") + 5146 (write _test-input-stream " y: int\n") + 5147 (write _test-input-stream "}\n") + 5148 # convert + 5149 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5150 (flush _test-output-buffered-file) + 5151 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5157 # check output + 5158 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") + 5159 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") + 5160 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") + 5161 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") + 5162 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") + 5163 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") + 5164 # var a: t + 5165 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/6") + 5166 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") + 5167 # foo a + 5168 (check-next-stream-line-equal _test-output-stream " (foo *(ebp+0xfffffff8) *(ebp+0xfffffffc))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") + 5169 # + 5170 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/9") + 5171 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") + 5172 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") + 5173 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") + 5174 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") + 5175 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") + 5176 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") + 5177 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") + 5178 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") + 5179 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") + 5180 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") + 5181 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") + 5182 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") + 5183 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") + 5184 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") + 5185 # . epilogue + 5186 89/<- %esp 5/r32/ebp + 5187 5d/pop-to-ebp + 5188 c3/return + 5189 + 5190 test-convert-function-call-with-arg-of-user-defined-type-register-indirect: + 5191 # . prologue + 5192 55/push-ebp + 5193 89/<- %ebp 4/r32/esp + 5194 # setup + 5195 (clear-stream _test-input-stream) + 5196 (clear-stream $_test-input-buffered-file->buffer) + 5197 (clear-stream _test-output-stream) + 5198 (clear-stream $_test-output-buffered-file->buffer) + 5199 # + 5200 (write _test-input-stream "fn f {\n") + 5201 (write _test-input-stream " var a/eax: (addr t) <- copy 0\n") + 5202 (write _test-input-stream " foo *a\n") + 5203 (write _test-input-stream "}\n") + 5204 (write _test-input-stream "fn foo x: t {\n") + 5205 (write _test-input-stream "}\n") + 5206 (write _test-input-stream "type t {\n") + 5207 (write _test-input-stream " x: int\n") + 5208 (write _test-input-stream " y: int\n") + 5209 (write _test-input-stream "}\n") + 5210 # convert + 5211 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5212 (flush _test-output-buffered-file) + 5213 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5219 # check output + 5220 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") + 5221 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") + 5222 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") + 5223 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") + 5224 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") + 5225 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") + 5226 # var a + 5227 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/6") + 5228 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") + 5229 # foo a + 5230 (check-next-stream-line-equal _test-output-stream " (foo *(eax+0x00000000) *(eax+0x00000004))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") + 5231 # + 5232 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/9") + 5233 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") + 5234 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") + 5235 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") + 5236 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") + 5237 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") + 5238 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") + 5239 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") + 5240 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") + 5241 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") + 5242 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") + 5243 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") + 5244 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") + 5245 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") + 5246 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") + 5247 # . epilogue + 5248 89/<- %esp 5/r32/ebp + 5249 5d/pop-to-ebp + 5250 c3/return + 5251 + 5252 # we don't have special support for call-by-reference; just explicitly create + 5253 # a new variable with the address of the arg + 5254 test-convert-function-call-with-arg-of-user-defined-type-by-reference: + 5255 # . prologue + 5256 55/push-ebp + 5257 89/<- %ebp 4/r32/esp + 5258 # setup + 5259 (clear-stream _test-input-stream) + 5260 (clear-stream $_test-input-buffered-file->buffer) + 5261 (clear-stream _test-output-stream) + 5262 (clear-stream $_test-output-buffered-file->buffer) + 5263 # + 5264 (write _test-input-stream "fn f {\n") + 5265 (write _test-input-stream " var a: t\n") + 5266 (write _test-input-stream " var b/eax: (addr t) <- address a\n") + 5267 (write _test-input-stream " foo b\n") + 5268 (write _test-input-stream "}\n") + 5269 (write _test-input-stream "fn foo x: (addr t) {\n") + 5270 (write _test-input-stream " var x/ecx: (addr int) <- copy x\n") + 5271 (write _test-input-stream " increment *x\n") + 5272 (write _test-input-stream "}\n") + 5273 (write _test-input-stream "type t {\n") + 5274 (write _test-input-stream " x: int\n") + 5275 (write _test-input-stream " y: int\n") + 5276 (write _test-input-stream "}\n") + 5277 # convert + 5278 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5279 (flush _test-output-buffered-file) + 5280 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5286 # check output + 5287 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") + 5288 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") + 5289 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/2") + 5290 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/3") + 5291 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/4") + 5292 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/5") + 5293 # var a: t + 5294 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/6") + 5295 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/7") + 5296 # var b/eax: (addr t) + 5297 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/8") + 5298 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/9") + 5299 # foo a + 5300 (check-next-stream-line-equal _test-output-stream " (foo %eax)" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/10") + 5301 # + 5302 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/11") + 5303 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/12") + 5304 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/13") + 5305 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/14") + 5306 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/15") + 5307 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/16") + 5308 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/17") + 5309 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/18") + 5310 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/19") + 5311 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/20") + 5312 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/21") + 5313 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/22") + 5314 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23") + 5315 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24") + 5316 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25") + 5317 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000001/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26") + 5318 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27") + 5319 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28") + 5320 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29") + 5321 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/30") + 5322 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/31") + 5323 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/32") + 5324 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/33") + 5325 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/34") + 5326 # . epilogue + 5327 89/<- %esp 5/r32/ebp + 5328 5d/pop-to-ebp + 5329 c3/return + 5330 + 5331 test-convert-get-on-local-variable: + 5332 # . prologue + 5333 55/push-ebp + 5334 89/<- %ebp 4/r32/esp + 5335 # setup + 5336 (clear-stream _test-input-stream) + 5337 (clear-stream $_test-input-buffered-file->buffer) + 5338 (clear-stream _test-output-stream) + 5339 (clear-stream $_test-output-buffered-file->buffer) + 5340 # + 5341 (write _test-input-stream "fn foo {\n") + 5342 (write _test-input-stream " var a: t\n") + 5343 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 5344 (write _test-input-stream "}\n") + 5345 (write _test-input-stream "type t {\n") + 5346 (write _test-input-stream " x: int\n") + 5347 (write _test-input-stream " y: int\n") + 5348 (write _test-input-stream "}\n") + 5349 # convert + 5350 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5351 (flush _test-output-buffered-file) + 5352 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5358 # check output + 5359 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") + 5360 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") + 5361 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-local-variable/2") + 5362 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-local-variable/3") + 5363 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-local-variable/4") + 5364 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-local-variable/5") + 5365 # var a + 5366 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/6") + 5367 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/7") + 5368 # var c + 5369 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-local-variable/8") + 5370 # get + 5371 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000001/r32" "F - test-convert-get-on-local-variable/9") + 5372 # reclaim c + 5373 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-local-variable/10") + 5374 # reclaim a + 5375 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-get-on-local-variable/11") + 5376 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-local-variable/12") + 5377 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-local-variable/13") + 5378 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-local-variable/14") + 5379 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-local-variable/15") + 5380 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-local-variable/16") + 5381 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-local-variable/17") + 5382 # . epilogue + 5383 89/<- %esp 5/r32/ebp + 5384 5d/pop-to-ebp + 5385 c3/return + 5386 + 5387 test-convert-get-on-function-argument: + 5388 # . prologue + 5389 55/push-ebp + 5390 89/<- %ebp 4/r32/esp + 5391 # setup + 5392 (clear-stream _test-input-stream) + 5393 (clear-stream $_test-input-buffered-file->buffer) + 5394 (clear-stream _test-output-stream) + 5395 (clear-stream $_test-output-buffered-file->buffer) + 5396 # + 5397 (write _test-input-stream "fn foo a: t {\n") + 5398 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 5399 (write _test-input-stream "}\n") + 5400 (write _test-input-stream "type t {\n") + 5401 (write _test-input-stream " x: int\n") + 5402 (write _test-input-stream " y: int\n") + 5403 (write _test-input-stream "}\n") + 5404 # convert + 5405 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5406 (flush _test-output-buffered-file) + 5407 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5413 # check output + 5414 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") + 5415 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") + 5416 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument/2") + 5417 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument/3") + 5418 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument/4") + 5419 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument/5") + 5420 # var c + 5421 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument/6") + 5422 # get + 5423 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument/7") + 5424 # reclaim c + 5425 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument/8") + 5426 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument/9") + 5427 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument/10") + 5428 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument/11") + 5429 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument/12") + 5430 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument/13") + 5431 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument/14") + 5432 # . epilogue + 5433 89/<- %esp 5/r32/ebp + 5434 5d/pop-to-ebp + 5435 c3/return + 5436 + 5437 test-convert-get-on-function-argument-with-known-type: + 5438 # . prologue + 5439 55/push-ebp + 5440 89/<- %ebp 4/r32/esp + 5441 # setup + 5442 (clear-stream _test-input-stream) + 5443 (clear-stream $_test-input-buffered-file->buffer) + 5444 (clear-stream _test-output-stream) + 5445 (clear-stream $_test-output-buffered-file->buffer) + 5446 # + 5447 (write _test-input-stream "type t {\n") + 5448 (write _test-input-stream " x: int\n") + 5449 (write _test-input-stream " y: int\n") + 5450 (write _test-input-stream "}\n") + 5451 (write _test-input-stream "fn foo a: t {\n") + 5452 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 5453 (write _test-input-stream "}\n") + 5454 # convert + 5455 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5456 (flush _test-output-buffered-file) + 5457 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 5463 # check output + 5464 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") + 5465 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") + 5466 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument-with-known-type/2") + 5467 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument-with-known-type/3") + 5468 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument-with-known-type/4") + 5469 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument-with-known-type/5") + 5470 # var c + 5471 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument-with-known-type/6") + 5472 # get + 5473 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument-with-known-type/7") + 5474 # reclaim c + 5475 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument-with-known-type/8") + 5476 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument-with-known-type/9") + 5477 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument-with-known-type/10") + 5478 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument-with-known-type/11") + 5479 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument-with-known-type/12") + 5480 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument-with-known-type/13") + 5481 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument-with-known-type/14") + 5482 # . epilogue + 5483 89/<- %esp 5/r32/ebp + 5484 5d/pop-to-ebp + 5485 c3/return + 5486 + 5487 test-add-with-too-many-inouts: + 5488 # . prologue + 5489 55/push-ebp + 5490 89/<- %ebp 4/r32/esp + 5491 # setup + 5492 (clear-stream _test-input-stream) + 5493 (clear-stream $_test-input-buffered-file->buffer) + 5494 (clear-stream _test-output-stream) + 5495 (clear-stream $_test-output-buffered-file->buffer) + 5496 (clear-stream _test-error-stream) + 5497 (clear-stream $_test-error-buffered-file->buffer) + 5498 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5499 68/push 0/imm32 + 5500 68/push 0/imm32 + 5501 89/<- %edx 4/r32/esp + 5502 (tailor-exit-descriptor %edx 0x10) + 5503 # + 5504 (write _test-input-stream "fn foo {\n") + 5505 (write _test-input-stream " var a: int\n") + 5506 (write _test-input-stream " var b/ecx: int <- add a, 0\n") + 5507 (write _test-input-stream "}\n") + 5508 # convert + 5509 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5510 # registers except esp clobbered at this point + 5511 # restore ed + 5512 89/<- %edx 4/r32/esp + 5513 (flush _test-output-buffered-file) + 5514 (flush _test-error-buffered-file) + 5515 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5521 # check output + 5522 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty") + 5523 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message") + 5524 # check that stop(1) was called + 5525 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts: exit status") + 5526 # don't restore from ebp + 5527 81 0/subop/add %esp 8/imm32 + 5528 # . epilogue + 5529 5d/pop-to-ebp + 5530 c3/return + 5531 + 5532 test-add-with-too-many-inouts-2: + 5533 # . prologue + 5534 55/push-ebp + 5535 89/<- %ebp 4/r32/esp + 5536 # setup + 5537 (clear-stream _test-input-stream) + 5538 (clear-stream $_test-input-buffered-file->buffer) + 5539 (clear-stream _test-output-stream) + 5540 (clear-stream $_test-output-buffered-file->buffer) + 5541 (clear-stream _test-error-stream) + 5542 (clear-stream $_test-error-buffered-file->buffer) + 5543 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) 5544 68/push 0/imm32 - 5545 89/<- %edx 4/r32/esp - 5546 (tailor-exit-descriptor %edx 0x10) - 5547 # - 5548 (write _test-input-stream "fn foo {\n") - 5549 (write _test-input-stream " var a: int\n") - 5550 (write _test-input-stream " var b/ecx: (addr int) <- add a\n") - 5551 (write _test-input-stream "}\n") - 5552 # convert - 5553 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5554 # registers except esp clobbered at this point - 5555 # restore ed - 5556 89/<- %edx 4/r32/esp - 5557 (flush _test-output-buffered-file) - 5558 (flush _test-error-buffered-file) - 5559 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5565 # check output - 5566 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty") - 5567 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: only non-addr scalar args permitted" "F - test-add-with-non-number: error message") - 5568 # check that stop(1) was called - 5569 (check-ints-equal *(edx+4) 2 "F - test-add-with-non-number: exit status") - 5570 # don't restore from ebp - 5571 81 0/subop/add %esp 8/imm32 - 5572 # . epilogue - 5573 5d/pop-to-ebp - 5574 c3/return - 5575 - 5576 test-add-with-addr-dereferenced: - 5577 # . prologue - 5578 55/push-ebp - 5579 89/<- %ebp 4/r32/esp - 5580 # setup - 5581 (clear-stream _test-input-stream) - 5582 (clear-stream $_test-input-buffered-file->buffer) - 5583 (clear-stream _test-output-stream) - 5584 (clear-stream $_test-output-buffered-file->buffer) - 5585 # - 5586 (write _test-input-stream "fn foo {\n") - 5587 (write _test-input-stream " var a/eax: (addr int) <- copy 0\n") - 5588 (write _test-input-stream " add-to *a, 1\n") - 5589 (write _test-input-stream "}\n") - 5590 # convert - 5591 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5592 (flush _test-output-buffered-file) - 5593 # no error - 5594 # . epilogue - 5595 89/<- %esp 5/r32/ebp - 5596 5d/pop-to-ebp - 5597 c3/return - 5598 - 5599 test-get-with-wrong-field: - 5600 # . prologue - 5601 55/push-ebp - 5602 89/<- %ebp 4/r32/esp - 5603 # setup - 5604 (clear-stream _test-input-stream) - 5605 (clear-stream $_test-input-buffered-file->buffer) - 5606 (clear-stream _test-output-stream) - 5607 (clear-stream $_test-output-buffered-file->buffer) - 5608 (clear-stream _test-error-stream) - 5609 (clear-stream $_test-error-buffered-file->buffer) - 5610 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5611 68/push 0/imm32 - 5612 68/push 0/imm32 - 5613 89/<- %edx 4/r32/esp - 5614 (tailor-exit-descriptor %edx 0x10) - 5615 # - 5616 (write _test-input-stream "fn foo {\n") - 5617 (write _test-input-stream " var a: t\n") - 5618 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 5619 (write _test-input-stream "}\n") - 5620 (write _test-input-stream "type t {\n") - 5621 (write _test-input-stream " x: int\n") - 5622 (write _test-input-stream "}\n") - 5623 # convert - 5624 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5625 # registers except esp clobbered at this point - 5626 # restore ed - 5627 89/<- %edx 4/r32/esp - 5628 (flush _test-output-buffered-file) - 5629 (flush _test-error-buffered-file) - 5630 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5636 # check output - 5637 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty") - 5638 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message") - 5639 # check that stop(1) was called - 5640 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-field: exit status") - 5641 # don't restore from ebp - 5642 81 0/subop/add %esp 8/imm32 - 5643 # . epilogue - 5644 5d/pop-to-ebp - 5645 c3/return - 5646 - 5647 test-get-with-wrong-base-type: - 5648 # . prologue - 5649 55/push-ebp - 5650 89/<- %ebp 4/r32/esp - 5651 # setup - 5652 (clear-stream _test-input-stream) - 5653 (clear-stream $_test-input-buffered-file->buffer) - 5654 (clear-stream _test-output-stream) - 5655 (clear-stream $_test-output-buffered-file->buffer) - 5656 (clear-stream _test-error-stream) - 5657 (clear-stream $_test-error-buffered-file->buffer) - 5658 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5659 68/push 0/imm32 - 5660 68/push 0/imm32 - 5661 89/<- %edx 4/r32/esp - 5662 (tailor-exit-descriptor %edx 0x10) - 5663 # - 5664 (write _test-input-stream "fn foo {\n") - 5665 (write _test-input-stream " var a: int\n") - 5666 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 5667 (write _test-input-stream "}\n") - 5668 # convert - 5669 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5670 # registers except esp clobbered at this point - 5671 # restore ed - 5672 89/<- %edx 4/r32/esp - 5673 (flush _test-output-buffered-file) - 5674 (flush _test-error-buffered-file) - 5675 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5681 # check output - 5682 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty") - 5683 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message") - 5684 # check that stop(1) was called - 5685 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type: exit status") - 5686 # don't restore from ebp - 5687 81 0/subop/add %esp 8/imm32 - 5688 # . epilogue + 5545 68/push 0/imm32 + 5546 89/<- %edx 4/r32/esp + 5547 (tailor-exit-descriptor %edx 0x10) + 5548 # + 5549 (write _test-input-stream "fn foo {\n") + 5550 (write _test-input-stream " var a: int\n") + 5551 (write _test-input-stream " add-to a, 0, 1\n") + 5552 (write _test-input-stream "}\n") + 5553 # convert + 5554 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5555 # registers except esp clobbered at this point + 5556 # restore ed + 5557 89/<- %edx 4/r32/esp + 5558 (flush _test-output-buffered-file) + 5559 (flush _test-error-buffered-file) + 5560 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5566 # check output + 5567 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty") + 5568 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message") + 5569 # check that stop(1) was called + 5570 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts-2: exit status") + 5571 # don't restore from ebp + 5572 81 0/subop/add %esp 8/imm32 + 5573 # . epilogue + 5574 5d/pop-to-ebp + 5575 c3/return + 5576 + 5577 test-add-with-too-many-outputs: + 5578 # . prologue + 5579 55/push-ebp + 5580 89/<- %ebp 4/r32/esp + 5581 # setup + 5582 (clear-stream _test-input-stream) + 5583 (clear-stream $_test-input-buffered-file->buffer) + 5584 (clear-stream _test-output-stream) + 5585 (clear-stream $_test-output-buffered-file->buffer) + 5586 (clear-stream _test-error-stream) + 5587 (clear-stream $_test-error-buffered-file->buffer) + 5588 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5589 68/push 0/imm32 + 5590 68/push 0/imm32 + 5591 89/<- %edx 4/r32/esp + 5592 (tailor-exit-descriptor %edx 0x10) + 5593 # + 5594 (write _test-input-stream "fn foo {\n") + 5595 (write _test-input-stream " var a/eax: int <- copy 0\n") + 5596 (write _test-input-stream " var b/ebx: int <- copy 0\n") + 5597 (write _test-input-stream " var c/ecx: int <- copy 0\n") + 5598 (write _test-input-stream " c, b <- add a\n") + 5599 (write _test-input-stream "}\n") + 5600 # convert + 5601 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5602 # registers except esp clobbered at this point + 5603 # restore ed + 5604 89/<- %edx 4/r32/esp + 5605 (flush _test-output-buffered-file) + 5606 (flush _test-error-buffered-file) + 5607 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5613 # check output + 5614 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty") + 5615 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message") + 5616 # check that stop(1) was called + 5617 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-outputs: exit status") + 5618 # don't restore from ebp + 5619 81 0/subop/add %esp 8/imm32 + 5620 # . epilogue + 5621 5d/pop-to-ebp + 5622 c3/return + 5623 + 5624 test-add-with-non-number: + 5625 # . prologue + 5626 55/push-ebp + 5627 89/<- %ebp 4/r32/esp + 5628 # setup + 5629 (clear-stream _test-input-stream) + 5630 (clear-stream $_test-input-buffered-file->buffer) + 5631 (clear-stream _test-output-stream) + 5632 (clear-stream $_test-output-buffered-file->buffer) + 5633 (clear-stream _test-error-stream) + 5634 (clear-stream $_test-error-buffered-file->buffer) + 5635 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5636 68/push 0/imm32 + 5637 68/push 0/imm32 + 5638 89/<- %edx 4/r32/esp + 5639 (tailor-exit-descriptor %edx 0x10) + 5640 # + 5641 (write _test-input-stream "fn foo {\n") + 5642 (write _test-input-stream " var a: int\n") + 5643 (write _test-input-stream " var b/ecx: (addr int) <- add a\n") + 5644 (write _test-input-stream "}\n") + 5645 # convert + 5646 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5647 # registers except esp clobbered at this point + 5648 # restore ed + 5649 89/<- %edx 4/r32/esp + 5650 (flush _test-output-buffered-file) + 5651 (flush _test-error-buffered-file) + 5652 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5658 # check output + 5659 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty") + 5660 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: only non-addr scalar args permitted" "F - test-add-with-non-number: error message") + 5661 # check that stop(1) was called + 5662 (check-ints-equal *(edx+4) 2 "F - test-add-with-non-number: exit status") + 5663 # don't restore from ebp + 5664 81 0/subop/add %esp 8/imm32 + 5665 # . epilogue + 5666 5d/pop-to-ebp + 5667 c3/return + 5668 + 5669 test-add-with-addr-dereferenced: + 5670 # . prologue + 5671 55/push-ebp + 5672 89/<- %ebp 4/r32/esp + 5673 # setup + 5674 (clear-stream _test-input-stream) + 5675 (clear-stream $_test-input-buffered-file->buffer) + 5676 (clear-stream _test-output-stream) + 5677 (clear-stream $_test-output-buffered-file->buffer) + 5678 # + 5679 (write _test-input-stream "fn foo {\n") + 5680 (write _test-input-stream " var a/eax: (addr int) <- copy 0\n") + 5681 (write _test-input-stream " add-to *a, 1\n") + 5682 (write _test-input-stream "}\n") + 5683 # convert + 5684 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5685 (flush _test-output-buffered-file) + 5686 # no error + 5687 # . epilogue + 5688 89/<- %esp 5/r32/ebp 5689 5d/pop-to-ebp 5690 c3/return 5691 - 5692 test-get-with-wrong-base-type-2: + 5692 test-get-with-wrong-field: 5693 # . prologue 5694 55/push-ebp 5695 89/<- %ebp 4/r32/esp @@ -5254,7 +5254,7 @@ if ('onhashchange' in window) { 5707 (tailor-exit-descriptor %edx 0x10) 5708 # 5709 (write _test-input-stream "fn foo {\n") - 5710 (write _test-input-stream " var a: (addr t)\n") + 5710 (write _test-input-stream " var a: t\n") 5711 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") 5712 (write _test-input-stream "}\n") 5713 (write _test-input-stream "type t {\n") @@ -5269,17 +5269,17 @@ if ('onhashchange' in window) { 5722 (flush _test-error-buffered-file) 5723 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ 5729 # check output - 5730 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty") - 5731 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message") + 5730 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty") + 5731 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message") 5732 # check that stop(1) was called - 5733 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-2: exit status") + 5733 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-field: exit status") 5734 # don't restore from ebp 5735 81 0/subop/add %esp 8/imm32 5736 # . epilogue 5737 5d/pop-to-ebp 5738 c3/return 5739 - 5740 test-get-with-wrong-offset-type: + 5740 test-get-with-wrong-base-type: 5741 # . prologue 5742 55/push-ebp 5743 89/<- %ebp 4/r32/esp @@ -5297,6830 +5297,6820 @@ if ('onhashchange' in window) { 5755 (tailor-exit-descriptor %edx 0x10) 5756 # 5757 (write _test-input-stream "fn foo {\n") - 5758 (write _test-input-stream " var a: t\n") - 5759 (write _test-input-stream " var b: int\n") - 5760 (write _test-input-stream " var c/ecx: (addr int) <- get a, b\n") - 5761 (write _test-input-stream "}\n") - 5762 (write _test-input-stream "type t {\n") - 5763 (write _test-input-stream " x: int\n") - 5764 (write _test-input-stream "}\n") - 5765 # convert - 5766 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5767 # registers except esp clobbered at this point - 5768 # restore ed - 5769 89/<- %edx 4/r32/esp - 5770 (flush _test-output-buffered-file) - 5771 (flush _test-error-buffered-file) - 5772 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5778 # check output - 5779 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty") - 5780 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message") - 5781 # check that stop(1) was called - 5782 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-offset-type: exit status") - 5783 # don't restore from ebp - 5784 81 0/subop/add %esp 8/imm32 - 5785 # . epilogue - 5786 5d/pop-to-ebp - 5787 c3/return - 5788 - 5789 test-get-with-wrong-output-type: - 5790 # . prologue - 5791 55/push-ebp - 5792 89/<- %ebp 4/r32/esp - 5793 # setup - 5794 (clear-stream _test-input-stream) - 5795 (clear-stream $_test-input-buffered-file->buffer) - 5796 (clear-stream _test-output-stream) - 5797 (clear-stream $_test-output-buffered-file->buffer) - 5798 (clear-stream _test-error-stream) - 5799 (clear-stream $_test-error-buffered-file->buffer) - 5800 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5801 68/push 0/imm32 - 5802 68/push 0/imm32 - 5803 89/<- %edx 4/r32/esp - 5804 (tailor-exit-descriptor %edx 0x10) - 5805 # - 5806 (write _test-input-stream "fn foo {\n") - 5807 (write _test-input-stream " var a: t\n") - 5808 (write _test-input-stream " var c: (addr int)\n") - 5809 (write _test-input-stream " c <- get a, x\n") - 5810 (write _test-input-stream "}\n") - 5811 (write _test-input-stream "type t {\n") - 5812 (write _test-input-stream " x: int\n") - 5813 (write _test-input-stream "}\n") - 5814 # convert - 5815 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5816 # registers except esp clobbered at this point - 5817 # restore ed - 5818 89/<- %edx 4/r32/esp - 5819 (flush _test-output-buffered-file) - 5820 (flush _test-error-buffered-file) - 5821 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5827 # check output - 5828 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty") - 5829 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message") - 5830 # check that stop(1) was called - 5831 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type: exit status") - 5832 # don't restore from ebp - 5833 81 0/subop/add %esp 8/imm32 - 5834 # . epilogue - 5835 5d/pop-to-ebp - 5836 c3/return - 5837 - 5838 test-get-with-wrong-output-type-2: - 5839 # . prologue - 5840 55/push-ebp - 5841 89/<- %ebp 4/r32/esp - 5842 # setup - 5843 (clear-stream _test-input-stream) - 5844 (clear-stream $_test-input-buffered-file->buffer) - 5845 (clear-stream _test-output-stream) - 5846 (clear-stream $_test-output-buffered-file->buffer) - 5847 (clear-stream _test-error-stream) - 5848 (clear-stream $_test-error-buffered-file->buffer) - 5849 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5850 68/push 0/imm32 - 5851 68/push 0/imm32 - 5852 89/<- %edx 4/r32/esp - 5853 (tailor-exit-descriptor %edx 0x10) - 5854 # - 5855 (write _test-input-stream "fn foo {\n") - 5856 (write _test-input-stream " var a: t\n") - 5857 (write _test-input-stream " var c/ecx: int <- get a, x\n") - 5858 (write _test-input-stream "}\n") - 5859 (write _test-input-stream "type t {\n") - 5860 (write _test-input-stream " x: int\n") - 5861 (write _test-input-stream "}\n") - 5862 # convert - 5863 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5864 # registers except esp clobbered at this point - 5865 # restore ed - 5866 89/<- %edx 4/r32/esp - 5867 (flush _test-output-buffered-file) - 5868 (flush _test-error-buffered-file) - 5869 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5875 # check output - 5876 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty") - 5877 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-2: error message") - 5878 # check that stop(1) was called - 5879 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-2: exit status") - 5880 # don't restore from ebp - 5881 81 0/subop/add %esp 8/imm32 - 5882 # . epilogue - 5883 5d/pop-to-ebp - 5884 c3/return - 5885 - 5886 test-get-with-wrong-output-type-3: - 5887 # . prologue - 5888 55/push-ebp - 5889 89/<- %ebp 4/r32/esp - 5890 # setup - 5891 (clear-stream _test-input-stream) - 5892 (clear-stream $_test-input-buffered-file->buffer) - 5893 (clear-stream _test-output-stream) - 5894 (clear-stream $_test-output-buffered-file->buffer) - 5895 (clear-stream _test-error-stream) - 5896 (clear-stream $_test-error-buffered-file->buffer) - 5897 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5898 68/push 0/imm32 - 5899 68/push 0/imm32 - 5900 89/<- %edx 4/r32/esp - 5901 (tailor-exit-descriptor %edx 0x10) - 5902 # - 5903 (write _test-input-stream "fn foo {\n") - 5904 (write _test-input-stream " var a: t\n") - 5905 (write _test-input-stream " var c/ecx: (array int) <- get a, x\n") + 5758 (write _test-input-stream " var a: int\n") + 5759 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 5760 (write _test-input-stream "}\n") + 5761 # convert + 5762 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5763 # registers except esp clobbered at this point + 5764 # restore ed + 5765 89/<- %edx 4/r32/esp + 5766 (flush _test-output-buffered-file) + 5767 (flush _test-error-buffered-file) + 5768 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5774 # check output + 5775 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty") + 5776 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message") + 5777 # check that stop(1) was called + 5778 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type: exit status") + 5779 # don't restore from ebp + 5780 81 0/subop/add %esp 8/imm32 + 5781 # . epilogue + 5782 5d/pop-to-ebp + 5783 c3/return + 5784 + 5785 test-get-with-wrong-base-type-2: + 5786 # . prologue + 5787 55/push-ebp + 5788 89/<- %ebp 4/r32/esp + 5789 # setup + 5790 (clear-stream _test-input-stream) + 5791 (clear-stream $_test-input-buffered-file->buffer) + 5792 (clear-stream _test-output-stream) + 5793 (clear-stream $_test-output-buffered-file->buffer) + 5794 (clear-stream _test-error-stream) + 5795 (clear-stream $_test-error-buffered-file->buffer) + 5796 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5797 68/push 0/imm32 + 5798 68/push 0/imm32 + 5799 89/<- %edx 4/r32/esp + 5800 (tailor-exit-descriptor %edx 0x10) + 5801 # + 5802 (write _test-input-stream "fn foo {\n") + 5803 (write _test-input-stream " var a: (addr t)\n") + 5804 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 5805 (write _test-input-stream "}\n") + 5806 (write _test-input-stream "type t {\n") + 5807 (write _test-input-stream " x: int\n") + 5808 (write _test-input-stream "}\n") + 5809 # convert + 5810 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5811 # registers except esp clobbered at this point + 5812 # restore ed + 5813 89/<- %edx 4/r32/esp + 5814 (flush _test-output-buffered-file) + 5815 (flush _test-error-buffered-file) + 5816 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5822 # check output + 5823 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty") + 5824 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message") + 5825 # check that stop(1) was called + 5826 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-2: exit status") + 5827 # don't restore from ebp + 5828 81 0/subop/add %esp 8/imm32 + 5829 # . epilogue + 5830 5d/pop-to-ebp + 5831 c3/return + 5832 + 5833 test-get-with-wrong-offset-type: + 5834 # . prologue + 5835 55/push-ebp + 5836 89/<- %ebp 4/r32/esp + 5837 # setup + 5838 (clear-stream _test-input-stream) + 5839 (clear-stream $_test-input-buffered-file->buffer) + 5840 (clear-stream _test-output-stream) + 5841 (clear-stream $_test-output-buffered-file->buffer) + 5842 (clear-stream _test-error-stream) + 5843 (clear-stream $_test-error-buffered-file->buffer) + 5844 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5845 68/push 0/imm32 + 5846 68/push 0/imm32 + 5847 89/<- %edx 4/r32/esp + 5848 (tailor-exit-descriptor %edx 0x10) + 5849 # + 5850 (write _test-input-stream "fn foo {\n") + 5851 (write _test-input-stream " var a: t\n") + 5852 (write _test-input-stream " var b: int\n") + 5853 (write _test-input-stream " var c/ecx: (addr int) <- get a, b\n") + 5854 (write _test-input-stream "}\n") + 5855 (write _test-input-stream "type t {\n") + 5856 (write _test-input-stream " x: int\n") + 5857 (write _test-input-stream "}\n") + 5858 # convert + 5859 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5860 # registers except esp clobbered at this point + 5861 # restore ed + 5862 89/<- %edx 4/r32/esp + 5863 (flush _test-output-buffered-file) + 5864 (flush _test-error-buffered-file) + 5865 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5871 # check output + 5872 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty") + 5873 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message") + 5874 # check that stop(1) was called + 5875 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-offset-type: exit status") + 5876 # don't restore from ebp + 5877 81 0/subop/add %esp 8/imm32 + 5878 # . epilogue + 5879 5d/pop-to-ebp + 5880 c3/return + 5881 + 5882 test-get-with-wrong-output-type: + 5883 # . prologue + 5884 55/push-ebp + 5885 89/<- %ebp 4/r32/esp + 5886 # setup + 5887 (clear-stream _test-input-stream) + 5888 (clear-stream $_test-input-buffered-file->buffer) + 5889 (clear-stream _test-output-stream) + 5890 (clear-stream $_test-output-buffered-file->buffer) + 5891 (clear-stream _test-error-stream) + 5892 (clear-stream $_test-error-buffered-file->buffer) + 5893 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5894 68/push 0/imm32 + 5895 68/push 0/imm32 + 5896 89/<- %edx 4/r32/esp + 5897 (tailor-exit-descriptor %edx 0x10) + 5898 # + 5899 (write _test-input-stream "fn foo {\n") + 5900 (write _test-input-stream " var a: t\n") + 5901 (write _test-input-stream " var c: (addr int)\n") + 5902 (write _test-input-stream " c <- get a, x\n") + 5903 (write _test-input-stream "}\n") + 5904 (write _test-input-stream "type t {\n") + 5905 (write _test-input-stream " x: int\n") 5906 (write _test-input-stream "}\n") - 5907 (write _test-input-stream "type t {\n") - 5908 (write _test-input-stream " x: int\n") - 5909 (write _test-input-stream "}\n") - 5910 # convert - 5911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5912 # registers except esp clobbered at this point - 5913 # restore ed - 5914 89/<- %edx 4/r32/esp - 5915 (flush _test-output-buffered-file) - 5916 (flush _test-error-buffered-file) - 5917 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5923 # check output - 5924 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty") - 5925 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-3: error message") - 5926 # check that stop(1) was called - 5927 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-3: exit status") - 5928 # don't restore from ebp - 5929 81 0/subop/add %esp 8/imm32 - 5930 # . epilogue - 5931 5d/pop-to-ebp - 5932 c3/return - 5933 - 5934 test-get-with-wrong-output-type-4: - 5935 # . prologue - 5936 55/push-ebp - 5937 89/<- %ebp 4/r32/esp - 5938 # setup - 5939 (clear-stream _test-input-stream) - 5940 (clear-stream $_test-input-buffered-file->buffer) - 5941 (clear-stream _test-output-stream) - 5942 (clear-stream $_test-output-buffered-file->buffer) - 5943 (clear-stream _test-error-stream) - 5944 (clear-stream $_test-error-buffered-file->buffer) - 5945 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 5946 68/push 0/imm32 - 5947 68/push 0/imm32 - 5948 89/<- %edx 4/r32/esp - 5949 (tailor-exit-descriptor %edx 0x10) - 5950 # - 5951 (write _test-input-stream "fn foo {\n") - 5952 (write _test-input-stream " var a: t\n") - 5953 (write _test-input-stream " var c/ecx: (addr boolean) <- get a, x\n") + 5907 # convert + 5908 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5909 # registers except esp clobbered at this point + 5910 # restore ed + 5911 89/<- %edx 4/r32/esp + 5912 (flush _test-output-buffered-file) + 5913 (flush _test-error-buffered-file) + 5914 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5920 # check output + 5921 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty") + 5922 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message") + 5923 # check that stop(1) was called + 5924 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type: exit status") + 5925 # don't restore from ebp + 5926 81 0/subop/add %esp 8/imm32 + 5927 # . epilogue + 5928 5d/pop-to-ebp + 5929 c3/return + 5930 + 5931 test-get-with-wrong-output-type-2: + 5932 # . prologue + 5933 55/push-ebp + 5934 89/<- %ebp 4/r32/esp + 5935 # setup + 5936 (clear-stream _test-input-stream) + 5937 (clear-stream $_test-input-buffered-file->buffer) + 5938 (clear-stream _test-output-stream) + 5939 (clear-stream $_test-output-buffered-file->buffer) + 5940 (clear-stream _test-error-stream) + 5941 (clear-stream $_test-error-buffered-file->buffer) + 5942 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5943 68/push 0/imm32 + 5944 68/push 0/imm32 + 5945 89/<- %edx 4/r32/esp + 5946 (tailor-exit-descriptor %edx 0x10) + 5947 # + 5948 (write _test-input-stream "fn foo {\n") + 5949 (write _test-input-stream " var a: t\n") + 5950 (write _test-input-stream " var c/ecx: int <- get a, x\n") + 5951 (write _test-input-stream "}\n") + 5952 (write _test-input-stream "type t {\n") + 5953 (write _test-input-stream " x: int\n") 5954 (write _test-input-stream "}\n") - 5955 (write _test-input-stream "type t {\n") - 5956 (write _test-input-stream " x: int\n") - 5957 (write _test-input-stream "}\n") - 5958 # convert - 5959 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5960 # registers except esp clobbered at this point - 5961 # restore ed - 5962 89/<- %edx 4/r32/esp - 5963 (flush _test-output-buffered-file) - 5964 (flush _test-error-buffered-file) - 5965 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 5971 # check output - 5972 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty") - 5973 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message") - 5974 # check that stop(1) was called - 5975 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-4: exit status") - 5976 # don't restore from ebp - 5977 81 0/subop/add %esp 8/imm32 - 5978 # . epilogue - 5979 5d/pop-to-ebp - 5980 c3/return - 5981 - 5982 test-get-with-wrong-output-type-5: - 5983 # . prologue - 5984 55/push-ebp - 5985 89/<- %ebp 4/r32/esp - 5986 # setup - 5987 (clear-stream _test-input-stream) - 5988 (clear-stream $_test-input-buffered-file->buffer) - 5989 (clear-stream _test-output-stream) - 5990 (clear-stream $_test-output-buffered-file->buffer) - 5991 # - 5992 (write _test-input-stream "fn foo {\n") - 5993 (write _test-input-stream " var a: t\n") - 5994 (write _test-input-stream " var c/ecx: (addr handle int) <- get a, x\n") - 5995 (write _test-input-stream "}\n") - 5996 (write _test-input-stream "type t {\n") - 5997 (write _test-input-stream " x: (handle int)\n") - 5998 (write _test-input-stream "}\n") - 5999 # convert - 6000 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6001 (flush _test-output-buffered-file) - 6002 # no errors - 6003 # . epilogue - 6004 89/<- %esp 5/r32/ebp - 6005 5d/pop-to-ebp - 6006 c3/return - 6007 - 6008 test-get-with-too-few-inouts: - 6009 # . prologue - 6010 55/push-ebp - 6011 89/<- %ebp 4/r32/esp - 6012 # setup - 6013 (clear-stream _test-input-stream) - 6014 (clear-stream $_test-input-buffered-file->buffer) - 6015 (clear-stream _test-output-stream) - 6016 (clear-stream $_test-output-buffered-file->buffer) - 6017 (clear-stream _test-error-stream) - 6018 (clear-stream $_test-error-buffered-file->buffer) - 6019 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6020 68/push 0/imm32 - 6021 68/push 0/imm32 - 6022 89/<- %edx 4/r32/esp - 6023 (tailor-exit-descriptor %edx 0x10) - 6024 # - 6025 (write _test-input-stream "fn foo {\n") - 6026 (write _test-input-stream " var a: t\n") - 6027 (write _test-input-stream " var c/ecx: (addr int) <- get a\n") - 6028 (write _test-input-stream "}\n") - 6029 (write _test-input-stream "type t {\n") - 6030 (write _test-input-stream " x: int\n") - 6031 (write _test-input-stream "}\n") - 6032 # convert - 6033 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6034 # registers except esp clobbered at this point - 6035 # restore ed - 6036 89/<- %edx 4/r32/esp - 6037 (flush _test-output-buffered-file) - 6038 (flush _test-error-buffered-file) - 6039 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 6045 # check output - 6046 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") - 6047 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") - 6048 # check that stop(1) was called - 6049 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status") - 6050 # don't restore from ebp - 6051 81 0/subop/add %esp 8/imm32 - 6052 # . epilogue - 6053 5d/pop-to-ebp - 6054 c3/return - 6055 - 6056 test-get-with-too-many-inouts: - 6057 # . prologue - 6058 55/push-ebp - 6059 89/<- %ebp 4/r32/esp - 6060 # setup - 6061 (clear-stream _test-input-stream) - 6062 (clear-stream $_test-input-buffered-file->buffer) - 6063 (clear-stream _test-output-stream) - 6064 (clear-stream $_test-output-buffered-file->buffer) - 6065 (clear-stream _test-error-stream) - 6066 (clear-stream $_test-error-buffered-file->buffer) - 6067 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6068 68/push 0/imm32 - 6069 68/push 0/imm32 - 6070 89/<- %edx 4/r32/esp - 6071 (tailor-exit-descriptor %edx 0x10) - 6072 # - 6073 (write _test-input-stream "fn foo {\n") - 6074 (write _test-input-stream " var a: t\n") - 6075 (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n") - 6076 (write _test-input-stream "}\n") - 6077 (write _test-input-stream "type t {\n") - 6078 (write _test-input-stream " x: int\n") - 6079 (write _test-input-stream "}\n") - 6080 # convert - 6081 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6082 # registers except esp clobbered at this point - 6083 # restore ed - 6084 89/<- %edx 4/r32/esp - 6085 (flush _test-output-buffered-file) - 6086 (flush _test-error-buffered-file) - 6087 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 6093 # check output - 6094 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") - 6095 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") - 6096 # check that stop(1) was called - 6097 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status") - 6098 # don't restore from ebp - 6099 81 0/subop/add %esp 8/imm32 - 6100 # . epilogue - 6101 5d/pop-to-ebp - 6102 c3/return - 6103 - 6104 test-get-with-no-output: - 6105 # . prologue - 6106 55/push-ebp - 6107 89/<- %ebp 4/r32/esp - 6108 # setup - 6109 (clear-stream _test-input-stream) - 6110 (clear-stream $_test-input-buffered-file->buffer) - 6111 (clear-stream _test-output-stream) - 6112 (clear-stream $_test-output-buffered-file->buffer) - 6113 (clear-stream _test-error-stream) - 6114 (clear-stream $_test-error-buffered-file->buffer) - 6115 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6116 68/push 0/imm32 - 6117 68/push 0/imm32 - 6118 89/<- %edx 4/r32/esp - 6119 (tailor-exit-descriptor %edx 0x10) - 6120 # - 6121 (write _test-input-stream "fn foo {\n") - 6122 (write _test-input-stream " var a: t\n") - 6123 (write _test-input-stream " get a, x\n") + 5955 # convert + 5956 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5957 # registers except esp clobbered at this point + 5958 # restore ed + 5959 89/<- %edx 4/r32/esp + 5960 (flush _test-output-buffered-file) + 5961 (flush _test-error-buffered-file) + 5962 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 5968 # check output + 5969 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty") + 5970 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-2: error message") + 5971 # check that stop(1) was called + 5972 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-2: exit status") + 5973 # don't restore from ebp + 5974 81 0/subop/add %esp 8/imm32 + 5975 # . epilogue + 5976 5d/pop-to-ebp + 5977 c3/return + 5978 + 5979 test-get-with-wrong-output-type-3: + 5980 # . prologue + 5981 55/push-ebp + 5982 89/<- %ebp 4/r32/esp + 5983 # setup + 5984 (clear-stream _test-input-stream) + 5985 (clear-stream $_test-input-buffered-file->buffer) + 5986 (clear-stream _test-output-stream) + 5987 (clear-stream $_test-output-buffered-file->buffer) + 5988 (clear-stream _test-error-stream) + 5989 (clear-stream $_test-error-buffered-file->buffer) + 5990 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5991 68/push 0/imm32 + 5992 68/push 0/imm32 + 5993 89/<- %edx 4/r32/esp + 5994 (tailor-exit-descriptor %edx 0x10) + 5995 # + 5996 (write _test-input-stream "fn foo {\n") + 5997 (write _test-input-stream " var a: t\n") + 5998 (write _test-input-stream " var c/ecx: (array int) <- get a, x\n") + 5999 (write _test-input-stream "}\n") + 6000 (write _test-input-stream "type t {\n") + 6001 (write _test-input-stream " x: int\n") + 6002 (write _test-input-stream "}\n") + 6003 # convert + 6004 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6005 # registers except esp clobbered at this point + 6006 # restore ed + 6007 89/<- %edx 4/r32/esp + 6008 (flush _test-output-buffered-file) + 6009 (flush _test-error-buffered-file) + 6010 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6016 # check output + 6017 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty") + 6018 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an address" "F - test-get-with-wrong-output-type-3: error message") + 6019 # check that stop(1) was called + 6020 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-3: exit status") + 6021 # don't restore from ebp + 6022 81 0/subop/add %esp 8/imm32 + 6023 # . epilogue + 6024 5d/pop-to-ebp + 6025 c3/return + 6026 + 6027 test-get-with-wrong-output-type-4: + 6028 # . prologue + 6029 55/push-ebp + 6030 89/<- %ebp 4/r32/esp + 6031 # setup + 6032 (clear-stream _test-input-stream) + 6033 (clear-stream $_test-input-buffered-file->buffer) + 6034 (clear-stream _test-output-stream) + 6035 (clear-stream $_test-output-buffered-file->buffer) + 6036 (clear-stream _test-error-stream) + 6037 (clear-stream $_test-error-buffered-file->buffer) + 6038 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6039 68/push 0/imm32 + 6040 68/push 0/imm32 + 6041 89/<- %edx 4/r32/esp + 6042 (tailor-exit-descriptor %edx 0x10) + 6043 # + 6044 (write _test-input-stream "fn foo {\n") + 6045 (write _test-input-stream " var a: t\n") + 6046 (write _test-input-stream " var c/ecx: (addr boolean) <- get a, x\n") + 6047 (write _test-input-stream "}\n") + 6048 (write _test-input-stream "type t {\n") + 6049 (write _test-input-stream " x: int\n") + 6050 (write _test-input-stream "}\n") + 6051 # convert + 6052 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6053 # registers except esp clobbered at this point + 6054 # restore ed + 6055 89/<- %edx 4/r32/esp + 6056 (flush _test-output-buffered-file) + 6057 (flush _test-error-buffered-file) + 6058 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6064 # check output + 6065 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty") + 6066 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message") + 6067 # check that stop(1) was called + 6068 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-4: exit status") + 6069 # don't restore from ebp + 6070 81 0/subop/add %esp 8/imm32 + 6071 # . epilogue + 6072 5d/pop-to-ebp + 6073 c3/return + 6074 + 6075 test-get-with-wrong-output-type-5: + 6076 # . prologue + 6077 55/push-ebp + 6078 89/<- %ebp 4/r32/esp + 6079 # setup + 6080 (clear-stream _test-input-stream) + 6081 (clear-stream $_test-input-buffered-file->buffer) + 6082 (clear-stream _test-output-stream) + 6083 (clear-stream $_test-output-buffered-file->buffer) + 6084 # + 6085 (write _test-input-stream "fn foo {\n") + 6086 (write _test-input-stream " var a: t\n") + 6087 (write _test-input-stream " var c/ecx: (addr handle int) <- get a, x\n") + 6088 (write _test-input-stream "}\n") + 6089 (write _test-input-stream "type t {\n") + 6090 (write _test-input-stream " x: (handle int)\n") + 6091 (write _test-input-stream "}\n") + 6092 # convert + 6093 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6094 (flush _test-output-buffered-file) + 6095 # no errors + 6096 # . epilogue + 6097 89/<- %esp 5/r32/ebp + 6098 5d/pop-to-ebp + 6099 c3/return + 6100 + 6101 test-get-with-too-few-inouts: + 6102 # . prologue + 6103 55/push-ebp + 6104 89/<- %ebp 4/r32/esp + 6105 # setup + 6106 (clear-stream _test-input-stream) + 6107 (clear-stream $_test-input-buffered-file->buffer) + 6108 (clear-stream _test-output-stream) + 6109 (clear-stream $_test-output-buffered-file->buffer) + 6110 (clear-stream _test-error-stream) + 6111 (clear-stream $_test-error-buffered-file->buffer) + 6112 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6113 68/push 0/imm32 + 6114 68/push 0/imm32 + 6115 89/<- %edx 4/r32/esp + 6116 (tailor-exit-descriptor %edx 0x10) + 6117 # + 6118 (write _test-input-stream "fn foo {\n") + 6119 (write _test-input-stream " var a: t\n") + 6120 (write _test-input-stream " var c/ecx: (addr int) <- get a\n") + 6121 (write _test-input-stream "}\n") + 6122 (write _test-input-stream "type t {\n") + 6123 (write _test-input-stream " x: int\n") 6124 (write _test-input-stream "}\n") - 6125 (write _test-input-stream "type t {\n") - 6126 (write _test-input-stream " x: int\n") - 6127 (write _test-input-stream "}\n") - 6128 # convert - 6129 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6130 # registers except esp clobbered at this point - 6131 # restore ed - 6132 89/<- %edx 4/r32/esp - 6133 (flush _test-output-buffered-file) - 6134 (flush _test-error-buffered-file) - 6135 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 6141 # check output - 6142 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") - 6143 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") - 6144 # check that stop(1) was called - 6145 (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status") - 6146 # don't restore from ebp - 6147 81 0/subop/add %esp 8/imm32 - 6148 # . epilogue - 6149 5d/pop-to-ebp - 6150 c3/return - 6151 - 6152 test-get-with-too-many-outputs: - 6153 # . prologue - 6154 55/push-ebp - 6155 89/<- %ebp 4/r32/esp - 6156 # setup - 6157 (clear-stream _test-input-stream) - 6158 (clear-stream $_test-input-buffered-file->buffer) - 6159 (clear-stream _test-output-stream) - 6160 (clear-stream $_test-output-buffered-file->buffer) - 6161 (clear-stream _test-error-stream) - 6162 (clear-stream $_test-error-buffered-file->buffer) - 6163 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6164 68/push 0/imm32 - 6165 68/push 0/imm32 - 6166 89/<- %edx 4/r32/esp - 6167 (tailor-exit-descriptor %edx 0x10) - 6168 # - 6169 (write _test-input-stream "fn foo {\n") - 6170 (write _test-input-stream " var a: t\n") - 6171 (write _test-input-stream " var b: int\n") - 6172 (write _test-input-stream " var c/eax: (addr int) <- copy 0\n") - 6173 (write _test-input-stream " c, b <- get a, x\n") - 6174 (write _test-input-stream "}\n") - 6175 (write _test-input-stream "type t {\n") - 6176 (write _test-input-stream " x: int\n") - 6177 (write _test-input-stream "}\n") - 6178 # convert - 6179 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6180 # registers except esp clobbered at this point - 6181 # restore ed - 6182 89/<- %edx 4/r32/esp - 6183 (flush _test-output-buffered-file) - 6184 (flush _test-error-buffered-file) - 6185 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ - 6191 # check output - 6192 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") - 6193 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") - 6194 # check that stop(1) was called - 6195 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status") - 6196 # don't restore from ebp - 6197 81 0/subop/add %esp 8/imm32 - 6198 # . epilogue - 6199 5d/pop-to-ebp - 6200 c3/return - 6201 - 6202 test-convert-array-of-user-defined-types: - 6203 # . prologue - 6204 55/push-ebp - 6205 89/<- %ebp 4/r32/esp - 6206 # setup - 6207 (clear-stream _test-input-stream) - 6208 (clear-stream $_test-input-buffered-file->buffer) - 6209 (clear-stream _test-output-stream) - 6210 (clear-stream $_test-output-buffered-file->buffer) - 6211 # - 6212 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 - 6213 (write _test-input-stream " x: int\n") - 6214 (write _test-input-stream " y: int\n") - 6215 (write _test-input-stream "}\n") - 6216 (write _test-input-stream "fn foo {\n") - 6217 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 6218 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 6219 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 6125 # convert + 6126 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6127 # registers except esp clobbered at this point + 6128 # restore ed + 6129 89/<- %edx 4/r32/esp + 6130 (flush _test-output-buffered-file) + 6131 (flush _test-error-buffered-file) + 6132 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6138 # check output + 6139 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") + 6140 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") + 6141 # check that stop(1) was called + 6142 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status") + 6143 # don't restore from ebp + 6144 81 0/subop/add %esp 8/imm32 + 6145 # . epilogue + 6146 5d/pop-to-ebp + 6147 c3/return + 6148 + 6149 test-get-with-too-many-inouts: + 6150 # . prologue + 6151 55/push-ebp + 6152 89/<- %ebp 4/r32/esp + 6153 # setup + 6154 (clear-stream _test-input-stream) + 6155 (clear-stream $_test-input-buffered-file->buffer) + 6156 (clear-stream _test-output-stream) + 6157 (clear-stream $_test-output-buffered-file->buffer) + 6158 (clear-stream _test-error-stream) + 6159 (clear-stream $_test-error-buffered-file->buffer) + 6160 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6161 68/push 0/imm32 + 6162 68/push 0/imm32 + 6163 89/<- %edx 4/r32/esp + 6164 (tailor-exit-descriptor %edx 0x10) + 6165 # + 6166 (write _test-input-stream "fn foo {\n") + 6167 (write _test-input-stream " var a: t\n") + 6168 (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n") + 6169 (write _test-input-stream "}\n") + 6170 (write _test-input-stream "type t {\n") + 6171 (write _test-input-stream " x: int\n") + 6172 (write _test-input-stream "}\n") + 6173 # convert + 6174 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6175 # registers except esp clobbered at this point + 6176 # restore ed + 6177 89/<- %edx 4/r32/esp + 6178 (flush _test-output-buffered-file) + 6179 (flush _test-error-buffered-file) + 6180 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6186 # check output + 6187 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") + 6188 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") + 6189 # check that stop(1) was called + 6190 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status") + 6191 # don't restore from ebp + 6192 81 0/subop/add %esp 8/imm32 + 6193 # . epilogue + 6194 5d/pop-to-ebp + 6195 c3/return + 6196 + 6197 test-get-with-no-output: + 6198 # . prologue + 6199 55/push-ebp + 6200 89/<- %ebp 4/r32/esp + 6201 # setup + 6202 (clear-stream _test-input-stream) + 6203 (clear-stream $_test-input-buffered-file->buffer) + 6204 (clear-stream _test-output-stream) + 6205 (clear-stream $_test-output-buffered-file->buffer) + 6206 (clear-stream _test-error-stream) + 6207 (clear-stream $_test-error-buffered-file->buffer) + 6208 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6209 68/push 0/imm32 + 6210 68/push 0/imm32 + 6211 89/<- %edx 4/r32/esp + 6212 (tailor-exit-descriptor %edx 0x10) + 6213 # + 6214 (write _test-input-stream "fn foo {\n") + 6215 (write _test-input-stream " var a: t\n") + 6216 (write _test-input-stream " get a, x\n") + 6217 (write _test-input-stream "}\n") + 6218 (write _test-input-stream "type t {\n") + 6219 (write _test-input-stream " x: int\n") 6220 (write _test-input-stream "}\n") 6221 # convert - 6222 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6223 (flush _test-output-buffered-file) - 6224 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 6230 # check output - 6231 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") - 6232 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") - 6233 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-array-of-user-defined-types/2") - 6234 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-array-of-user-defined-types/3") - 6235 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-array-of-user-defined-types/4") - 6236 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-array-of-user-defined-types/5") - 6237 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-array-of-user-defined-types/6") - 6238 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-array-of-user-defined-types/7") - 6239 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-array-of-user-defined-types/8") - 6240 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-array-of-user-defined-types/9") - 6241 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000003 + 4) 0x00000000/r32" "F - test-convert-array-of-user-defined-types/11") - 6242 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-array-of-user-defined-types/13") - 6243 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-array-of-user-defined-types/14") - 6244 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-array-of-user-defined-types/15") - 6245 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-array-of-user-defined-types/16") - 6246 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-array-of-user-defined-types/17") - 6247 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-array-of-user-defined-types/18") - 6248 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-array-of-user-defined-types/19") - 6249 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-array-of-user-defined-types/20") - 6250 # . epilogue - 6251 89/<- %esp 5/r32/ebp - 6252 5d/pop-to-ebp - 6253 c3/return - 6254 - 6255 test-convert-length-of-array-of-user-defined-types-to-eax: - 6256 # . prologue - 6257 55/push-ebp - 6258 89/<- %ebp 4/r32/esp - 6259 # setup - 6260 (clear-stream _test-input-stream) - 6261 (clear-stream $_test-input-buffered-file->buffer) - 6262 (clear-stream _test-output-stream) - 6263 (clear-stream $_test-output-buffered-file->buffer) - 6264 # - 6265 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 6266 (write _test-input-stream " x: int\n") - 6267 (write _test-input-stream " y: int\n") - 6268 (write _test-input-stream " z: int\n") - 6269 (write _test-input-stream "}\n") - 6270 (write _test-input-stream "fn foo {\n") - 6271 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 6272 (write _test-input-stream " var x/eax: (addr t) <- length arr\n") - 6273 (write _test-input-stream "}\n") - 6274 # convert - 6275 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6222 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6223 # registers except esp clobbered at this point + 6224 # restore ed + 6225 89/<- %edx 4/r32/esp + 6226 (flush _test-output-buffered-file) + 6227 (flush _test-error-buffered-file) + 6228 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6234 # check output + 6235 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") + 6236 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") + 6237 # check that stop(1) was called + 6238 (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status") + 6239 # don't restore from ebp + 6240 81 0/subop/add %esp 8/imm32 + 6241 # . epilogue + 6242 5d/pop-to-ebp + 6243 c3/return + 6244 + 6245 test-get-with-too-many-outputs: + 6246 # . prologue + 6247 55/push-ebp + 6248 89/<- %ebp 4/r32/esp + 6249 # setup + 6250 (clear-stream _test-input-stream) + 6251 (clear-stream $_test-input-buffered-file->buffer) + 6252 (clear-stream _test-output-stream) + 6253 (clear-stream $_test-output-buffered-file->buffer) + 6254 (clear-stream _test-error-stream) + 6255 (clear-stream $_test-error-buffered-file->buffer) + 6256 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6257 68/push 0/imm32 + 6258 68/push 0/imm32 + 6259 89/<- %edx 4/r32/esp + 6260 (tailor-exit-descriptor %edx 0x10) + 6261 # + 6262 (write _test-input-stream "fn foo {\n") + 6263 (write _test-input-stream " var a: t\n") + 6264 (write _test-input-stream " var b: int\n") + 6265 (write _test-input-stream " var c/eax: (addr int) <- copy 0\n") + 6266 (write _test-input-stream " c, b <- get a, x\n") + 6267 (write _test-input-stream "}\n") + 6268 (write _test-input-stream "type t {\n") + 6269 (write _test-input-stream " x: int\n") + 6270 (write _test-input-stream "}\n") + 6271 # convert + 6272 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6273 # registers except esp clobbered at this point + 6274 # restore ed + 6275 89/<- %edx 4/r32/esp 6276 (flush _test-output-buffered-file) - 6277 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 6283 # check output - 6284 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") - 6285 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") - 6286 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/2") - 6287 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/3") - 6288 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-eax/4") - 6289 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/5") - 6290 # var arr - 6291 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/6") - 6292 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/7") - 6293 # length instruction - 6294 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/8") - 6295 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/9") - 6296 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/10") - 6297 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/11") - 6298 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/12") - 6299 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/13") - 6300 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/14") - 6301 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/15") - 6302 # reclaim arr - 6303 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/16") + 6277 (flush _test-error-buffered-file) + 6278 +-- 6 lines: #? # dump _test-error-stream ------------------------------------------------------------------------------------------------------------------------------------------ + 6284 # check output + 6285 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") + 6286 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") + 6287 # check that stop(1) was called + 6288 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status") + 6289 # don't restore from ebp + 6290 81 0/subop/add %esp 8/imm32 + 6291 # . epilogue + 6292 5d/pop-to-ebp + 6293 c3/return + 6294 + 6295 test-convert-array-of-user-defined-types: + 6296 # . prologue + 6297 55/push-ebp + 6298 89/<- %ebp 4/r32/esp + 6299 # setup + 6300 (clear-stream _test-input-stream) + 6301 (clear-stream $_test-input-buffered-file->buffer) + 6302 (clear-stream _test-output-stream) + 6303 (clear-stream $_test-output-buffered-file->buffer) 6304 # - 6305 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-eax/17") - 6306 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/18") - 6307 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/19") - 6308 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/20") - 6309 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/21") - 6310 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-eax/22") - 6311 # . epilogue - 6312 89/<- %esp 5/r32/ebp - 6313 5d/pop-to-ebp - 6314 c3/return - 6315 - 6316 test-convert-length-of-array-of-user-defined-types-to-ecx: - 6317 # . prologue - 6318 55/push-ebp - 6319 89/<- %ebp 4/r32/esp - 6320 # setup - 6321 (clear-stream _test-input-stream) - 6322 (clear-stream $_test-input-buffered-file->buffer) - 6323 (clear-stream _test-output-stream) - 6324 (clear-stream $_test-output-buffered-file->buffer) - 6325 # - 6326 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 6327 (write _test-input-stream " x: int\n") - 6328 (write _test-input-stream " y: int\n") - 6329 (write _test-input-stream " z: int\n") - 6330 (write _test-input-stream "}\n") - 6331 (write _test-input-stream "fn foo {\n") - 6332 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 6333 (write _test-input-stream " var x/ecx: (addr t) <- length arr\n") - 6334 (write _test-input-stream "}\n") - 6335 # convert - 6336 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6337 (flush _test-output-buffered-file) - 6338 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 6344 # check output - 6345 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") - 6346 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") - 6347 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/2") - 6348 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/3") - 6349 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/4") - 6350 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/5") - 6351 # var a - 6352 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/6") - 6353 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/7") - 6354 # var x - 6355 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/8") - 6356 # length instruction - 6357 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/9") - 6358 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/10") - 6359 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/11") - 6360 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/12") - 6361 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/13") - 6362 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/14") - 6363 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/15") - 6364 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/16") - 6365 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/17") - 6366 # reclaim x - 6367 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/18") - 6368 # reclaim a - 6369 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/19") - 6370 # - 6371 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/20") - 6372 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/21") - 6373 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/22") - 6374 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/23") - 6375 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/24") - 6376 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/25") - 6377 # . epilogue - 6378 89/<- %esp 5/r32/ebp - 6379 5d/pop-to-ebp - 6380 c3/return - 6381 - 6382 test-convert-length-of-array-of-user-defined-types-to-edx: - 6383 # . prologue - 6384 55/push-ebp - 6385 89/<- %ebp 4/r32/esp - 6386 # setup - 6387 (clear-stream _test-input-stream) - 6388 (clear-stream $_test-input-buffered-file->buffer) - 6389 (clear-stream _test-output-stream) - 6390 (clear-stream $_test-output-buffered-file->buffer) - 6391 # - 6392 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 6393 (write _test-input-stream " x: int\n") - 6394 (write _test-input-stream " y: int\n") - 6395 (write _test-input-stream " z: int\n") - 6396 (write _test-input-stream "}\n") - 6397 (write _test-input-stream "fn foo {\n") - 6398 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 6399 (write _test-input-stream " var x/edx: (addr t) <- length arr\n") - 6400 (write _test-input-stream "}\n") - 6401 # convert - 6402 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6403 (flush _test-output-buffered-file) - 6404 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 6410 # check output - 6411 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") - 6412 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") - 6413 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/2") - 6414 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/3") - 6415 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-edx/4") - 6416 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/5") - 6417 # var a - 6418 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/6") - 6419 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/7") - 6420 # var x - 6421 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/8") - 6422 # length instruction - 6423 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/9") - 6424 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/10") - 6425 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/11") - 6426 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/12") - 6427 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/13") - 6428 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/14") - 6429 (check-next-stream-line-equal _test-output-stream " 89/<- %edx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/15") - 6430 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/16") - 6431 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/17") - 6432 # reclaim x - 6433 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/18") - 6434 # reclaim a - 6435 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/19") - 6436 # - 6437 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-edx/20") - 6438 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/21") - 6439 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/22") - 6440 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/23") - 6441 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/24") - 6442 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-edx/25") - 6443 # . epilogue - 6444 89/<- %esp 5/r32/ebp - 6445 5d/pop-to-ebp - 6446 c3/return - 6447 - 6448 test-convert-length-of-array-of-user-defined-types: - 6449 # . prologue - 6450 55/push-ebp - 6451 89/<- %ebp 4/r32/esp - 6452 # setup - 6453 (clear-stream _test-input-stream) - 6454 (clear-stream $_test-input-buffered-file->buffer) - 6455 (clear-stream _test-output-stream) - 6456 (clear-stream $_test-output-buffered-file->buffer) - 6457 # - 6458 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 - 6459 (write _test-input-stream " x: int\n") - 6460 (write _test-input-stream " y: int\n") - 6461 (write _test-input-stream " z: int\n") - 6462 (write _test-input-stream "}\n") - 6463 (write _test-input-stream "fn foo {\n") - 6464 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 6465 (write _test-input-stream " var x/ebx: (addr t) <- length arr\n") - 6466 (write _test-input-stream "}\n") - 6467 # convert - 6468 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6469 (flush _test-output-buffered-file) - 6470 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- - 6476 # check output - 6477 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") - 6478 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") - 6479 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types/2") - 6480 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types/3") - 6481 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types/4") - 6482 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types/5") - 6483 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types/6") - 6484 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types/7") - 6485 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-length-of-array-of-user-defined-types/8") - 6486 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types/9") - 6487 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types/10") - 6488 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types/11") - 6489 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types/12") - 6490 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types/13") - 6491 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types/14") - 6492 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types/15") - 6493 (check-next-stream-line-equal _test-output-stream " 89/<- %ebx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types/16") - 6494 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types/17") - 6495 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types/18") - 6496 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types/19") - 6497 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ebx" "F - test-convert-length-of-array-of-user-defined-types/20") - 6498 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types/21") - 6499 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types/22") - 6500 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types/23") - 6501 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types/24") - 6502 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types/25") - 6503 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types/26") - 6504 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types/27") - 6505 # . epilogue - 6506 89/<- %esp 5/r32/ebp - 6507 5d/pop-to-ebp - 6508 c3/return - 6509 - 6510 ####################################################### - 6511 # Parsing - 6512 ####################################################### - 6513 - 6514 == data - 6515 - 6516 # Global state added to each var record when parsing a function - 6517 Next-block-index: # (addr int) - 6518 1/imm32 - 6519 - 6520 Curr-block-depth: # (addr int) - 6521 1/imm32 - 6522 - 6523 == code - 6524 - 6525 parse-mu: # in: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) - 6526 # pseudocode - 6527 # var curr-function: (addr handle function) = Program->functions - 6528 # var curr-signature: (addr handle function) = Program->signatures - 6529 # var curr-type: (addr handle typeinfo) = Program->types - 6530 # var line: (stream byte 512) - 6531 # var word-slice: slice - 6532 # while true # line loop - 6533 # clear-stream(line) - 6534 # read-line-buffered(in, line) - 6535 # if (line->write == 0) break # end of file - 6536 # word-slice = next-mu-token(line) - 6537 # if slice-empty?(word-slice) # end of line - 6538 # continue - 6539 # else if slice-starts-with?(word-slice, "#") # comment - 6540 # continue # end of line - 6541 # else if slice-equal?(word-slice, "fn") - 6542 # var new-function: (handle function) = allocate(function) - 6543 # var vars: (stack live-var 256) - 6544 # populate-mu-function-header(line, new-function, vars) - 6545 # populate-mu-function-body(in, new-function, vars) - 6546 # assert(vars->top == 0) - 6547 # *curr-function = new-function - 6548 # curr-function = &new-function->next - 6549 # else if slice-equal?(word-slice, "sig") - 6550 # var new-function: (handle function) = allocate(function) - 6551 # populate-mu-function-signature(line, new-function) - 6552 # *curr-signature = new-function - 6553 # curr-signature = &new-function->next - 6554 # else if slice-equal?(word-slice, "type") - 6555 # word-slice = next-mu-token(line) - 6556 # type-id = pos-or-insert-slice(Type-id, word-slice) - 6557 # var new-type: (handle typeinfo) = find-or-create-typeinfo(type-id) - 6558 # assert(next-word(line) == "{") - 6559 # populate-mu-type(in, new-type) - 6560 # else - 6561 # abort() - 6562 # - 6563 # . prologue - 6564 55/push-ebp - 6565 89/<- %ebp 4/r32/esp - 6566 # var curr-signature: (addr handle function) at *(ebp-4) - 6567 68/push _Program-signatures/imm32 - 6568 # . save registers - 6569 50/push-eax - 6570 51/push-ecx - 6571 52/push-edx - 6572 53/push-ebx - 6573 56/push-esi - 6574 57/push-edi - 6575 # var line/ecx: (stream byte 512) - 6576 81 5/subop/subtract %esp 0x200/imm32 - 6577 68/push 0x200/imm32/size - 6578 68/push 0/imm32/read - 6579 68/push 0/imm32/write - 6580 89/<- %ecx 4/r32/esp - 6581 # var word-slice/edx: slice - 6582 68/push 0/imm32/end - 6583 68/push 0/imm32/start - 6584 89/<- %edx 4/r32/esp - 6585 # var curr-function/edi: (addr handle function) - 6586 bf/copy-to-edi _Program-functions/imm32 - 6587 # var vars/ebx: (stack live-var 256) - 6588 81 5/subop/subtract %esp 0xc00/imm32 - 6589 68/push 0xc00/imm32/size - 6590 68/push 0/imm32/top - 6591 89/<- %ebx 4/r32/esp - 6592 { - 6593 $parse-mu:line-loop: - 6594 (clear-stream %ecx) - 6595 (read-line-buffered *(ebp+8) %ecx) - 6596 # if (line->write == 0) break - 6597 81 7/subop/compare *ecx 0/imm32 - 6598 0f 84/jump-if-= break/disp32 - 6599 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ - 6605 (next-mu-token %ecx %edx) - 6606 # if slice-empty?(word-slice) continue - 6607 (slice-empty? %edx) # => eax - 6608 3d/compare-eax-and 0/imm32/false - 6609 0f 85/jump-if-!= loop/disp32 - 6610 # if (*word-slice->start == "#") continue - 6611 # . eax = *word-slice->start - 6612 8b/-> *edx 0/r32/eax - 6613 8a/copy-byte *eax 0/r32/AL - 6614 81 4/subop/and %eax 0xff/imm32 - 6615 # . if (eax == '#') continue - 6616 3d/compare-eax-and 0x23/imm32/hash - 6617 0f 84/jump-if-= loop/disp32 - 6618 # if (slice-equal?(word-slice, "fn")) parse a function - 6619 { - 6620 $parse-mu:fn: - 6621 (slice-equal? %edx "fn") # => eax - 6622 3d/compare-eax-and 0/imm32/false - 6623 0f 84/jump-if-= break/disp32 - 6624 # var new-function/esi: (handle function) - 6625 68/push 0/imm32 - 6626 68/push 0/imm32 - 6627 89/<- %esi 4/r32/esp - 6628 # populate-mu-function(line, in, vars, new-function) - 6629 (allocate Heap *Function-size %esi) - 6630 # var new-function-addr/eax: (addr function) - 6631 (lookup *esi *(esi+4)) # => eax - 6632 # initialize vars - 6633 (clear-stack %ebx) - 6634 # - 6635 (populate-mu-function-header %ecx %eax %ebx *(ebp+0xc) *(ebp+0x10)) - 6636 (populate-mu-function-body *(ebp+8) %eax %ebx *(ebp+0xc) *(ebp+0x10)) - 6637 # *curr-function = new-function - 6638 8b/-> *esi 0/r32/eax - 6639 89/<- *edi 0/r32/eax - 6640 8b/-> *(esi+4) 0/r32/eax - 6641 89/<- *(edi+4) 0/r32/eax - 6642 # curr-function = &new-function->next - 6643 # . var tmp/eax: (addr function) = lookup(new-function) - 6644 (lookup *esi *(esi+4)) # => eax - 6645 # . curr-function = &tmp->next - 6646 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next - 6647 # reclaim new-function - 6648 81 0/subop/add %esp 8/imm32 - 6649 # - 6650 e9/jump $parse-mu:line-loop/disp32 - 6651 } - 6652 # if (slice-equal?(word-slice, "sig")) parse a function signature - 6653 # Function signatures are for providing types to SubX functions. - 6654 { - 6655 $parse-mu:sig: - 6656 (slice-equal? %edx "sig") # => eax - 6657 3d/compare-eax-and 0/imm32/false - 6658 0f 84/jump-if-= break/disp32 - 6659 # edi = curr-function - 6660 57/push-edi - 6661 8b/-> *(ebp-4) 7/r32/edi - 6662 # var new-function/esi: (handle function) - 6663 68/push 0/imm32 - 6664 68/push 0/imm32 - 6665 89/<- %esi 4/r32/esp - 6666 # populate-mu-function(line, in, vars, new-function) - 6667 (allocate Heap *Function-size %esi) - 6668 # var new-function-addr/eax: (addr function) - 6669 (lookup *esi *(esi+4)) # => eax - 6670 # - 6671 (populate-mu-function-signature %ecx %eax *(ebp+0xc) *(ebp+0x10)) - 6672 # *curr-signature = new-function - 6673 8b/-> *esi 0/r32/eax - 6674 89/<- *edi 0/r32/eax - 6675 8b/-> *(esi+4) 0/r32/eax - 6676 89/<- *(edi+4) 0/r32/eax - 6677 # curr-signature = &new-function->next - 6678 # . var tmp/eax: (addr function) = lookup(new-function) - 6679 (lookup *esi *(esi+4)) # => eax - 6680 # . curr-function = &tmp->next - 6681 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next - 6682 # reclaim new-function - 6683 81 0/subop/add %esp 8/imm32 - 6684 # save curr-function - 6685 89/<- *(ebp-4) 7/r32/edi - 6686 # restore edi - 6687 5f/pop-to-edi - 6688 # - 6689 e9/jump $parse-mu:line-loop/disp32 - 6690 } - 6691 # if (slice-equal?(word-slice, "type")) parse a type (struct/record) definition - 6692 { - 6693 $parse-mu:type: - 6694 (slice-equal? %edx "type") # => eax - 6695 3d/compare-eax-and 0/imm32 - 6696 0f 84/jump-if-= break/disp32 - 6697 (next-mu-token %ecx %edx) - 6698 # var type-id/eax: int - 6699 (pos-or-insert-slice Type-id %edx) # => eax - 6700 # spill - 6701 51/push-ecx - 6702 # var new-type/ecx: (handle typeinfo) - 6703 68/push 0/imm32 - 6704 68/push 0/imm32 - 6705 89/<- %ecx 4/r32/esp - 6706 (find-or-create-typeinfo %eax %ecx) - 6707 # - 6708 (lookup *ecx *(ecx+4)) # => eax - 6709 # TODO: ensure that 'line' has nothing else but '{' - 6710 #? (dump-typeinfos "=== aaa\n") - 6711 (populate-mu-type *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) # => eax - 6712 #? (dump-typeinfos "=== zzz\n") - 6713 # reclaim new-type - 6714 81 0/subop/add %esp 8/imm32 - 6715 # restore - 6716 59/pop-to-ecx - 6717 e9/jump $parse-mu:line-loop/disp32 - 6718 } - 6719 # otherwise abort - 6720 e9/jump $parse-mu:error1/disp32 - 6721 } # end line loop - 6722 $parse-mu:end: - 6723 # . reclaim locals - 6724 81 0/subop/add %esp 0x20c/imm32 # line - 6725 81 0/subop/add %esp 0xc08/imm32 # vars - 6726 81 0/subop/add %esp 8/imm32 - 6727 # . restore registers - 6728 5f/pop-to-edi - 6729 5e/pop-to-esi - 6730 5b/pop-to-ebx - 6731 5a/pop-to-edx - 6732 59/pop-to-ecx - 6733 58/pop-to-eax - 6734 # . reclaim local - 6735 81 0/subop/add %esp 4/imm32 - 6736 # . epilogue - 6737 89/<- %esp 5/r32/ebp - 6738 5d/pop-to-ebp - 6739 c3/return - 6740 - 6741 $parse-mu:error1: - 6742 # error("unexpected top-level command: " word-slice "\n") - 6743 (write-buffered *(ebp+0xc) "unexpected top-level command: ") - 6744 (write-slice-buffered *(ebp+0xc) %edx) - 6745 (write-buffered *(ebp+0xc) "\n") - 6746 (flush *(ebp+0xc)) - 6747 (stop *(ebp+0x10) 1) - 6748 # never gets here - 6749 - 6750 $parse-mu:error2: - 6751 # error(vars->top " vars not reclaimed after fn '" new-function->name "'\n") - 6752 (write-int32-hex-buffered *(ebp+0xc) *ebx) - 6753 (write-buffered *(ebp+0xc) " vars not reclaimed after fn '") - 6754 (write-slice-buffered *(ebp+0xc) *eax) # Function-name - 6755 (write-buffered *(ebp+0xc) "'\n") - 6756 (flush *(ebp+0xc)) - 6757 (stop *(ebp+0x10) 1) - 6758 # never gets here - 6759 - 6760 # scenarios considered: - 6761 # ✗ fn foo # no block - 6762 # ✓ fn foo { - 6763 # ✗ fn foo { { - 6764 # ✗ fn foo { } - 6765 # ✗ fn foo { } { - 6766 # ✗ fn foo x { - 6767 # ✗ fn foo x: { - 6768 # ✓ fn foo x: int { - 6769 # ✓ fn foo x: int { - 6770 # ✓ fn foo x: int -> y/eax: int { - 6771 # TODO: - 6772 # disallow outputs of type `(... addr ...)` - 6773 # disallow inputs of type `(... addr ... addr ...)` - 6774 populate-mu-function-header: # first-line: (addr stream byte), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) - 6775 # pseudocode: - 6776 # var word-slice: slice - 6777 # next-mu-token(first-line, word-slice) - 6778 # assert(word-slice not in '{' '}' '->') - 6779 # out->name = slice-to-string(word-slice) - 6780 # ## inouts - 6781 # while true - 6782 # word-slice = next-mu-token(first-line) - 6783 # if (word-slice == '{') goto done - 6784 # if (word-slice == '->') break - 6785 # assert(word-slice != '}') - 6786 # var v: (handle var) = parse-var-with-type(word-slice, first-line) - 6787 # assert(v->register == null) - 6788 # # v->block-depth is implicitly 0 - 6789 # out->inouts = append(v, out->inouts) - 6790 # push(vars, {v, false}) - 6791 # ## outputs - 6792 # while true - 6793 # word-slice = next-mu-token(first-line) - 6794 # if (word-slice == '{') break - 6795 # assert(word-slice not in '}' '->') - 6796 # var v: (handle var) = parse-var-with-type(word-slice, first-line) - 6797 # assert(v->register != null) - 6798 # out->outputs = append(v, out->outputs) - 6799 # done: - 6800 # - 6801 # . prologue - 6802 55/push-ebp - 6803 89/<- %ebp 4/r32/esp - 6804 # . save registers - 6805 50/push-eax - 6806 51/push-ecx - 6807 52/push-edx - 6808 53/push-ebx - 6809 57/push-edi - 6810 # edi = out - 6811 8b/-> *(ebp+0xc) 7/r32/edi - 6812 # var word-slice/ecx: slice - 6813 68/push 0/imm32/end - 6814 68/push 0/imm32/start - 6815 89/<- %ecx 4/r32/esp - 6816 # var v/ebx: (handle var) - 6817 68/push 0/imm32 - 6818 68/push 0/imm32 - 6819 89/<- %ebx 4/r32/esp - 6820 # read function name - 6821 (next-mu-token *(ebp+8) %ecx) - 6822 # error checking - 6823 # if (word-slice == '{') abort - 6824 (slice-equal? %ecx "{") # => eax - 6825 3d/compare-eax-and 0/imm32/false - 6826 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6827 # if (word-slice == '->') abort - 6828 (slice-equal? %ecx "->") # => eax - 6829 3d/compare-eax-and 0/imm32/false - 6830 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6831 # if (word-slice == '}') abort - 6832 (slice-equal? %ecx "}") # => eax - 6833 3d/compare-eax-and 0/imm32/false - 6834 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6835 # save function name - 6836 (slice-to-string Heap %ecx %edi) # Function-name - 6837 # save function inouts - 6838 { - 6839 $populate-mu-function-header:check-for-inout: - 6840 (next-mu-token *(ebp+8) %ecx) - 6841 # if (word-slice == '{') goto done - 6842 (slice-equal? %ecx "{") # => eax - 6843 3d/compare-eax-and 0/imm32/false - 6844 0f 85/jump-if-!= $populate-mu-function-header:done/disp32 - 6845 # if (word-slice == '->') break - 6846 (slice-equal? %ecx "->") # => eax - 6847 3d/compare-eax-and 0/imm32/false - 6848 0f 85/jump-if-!= break/disp32 - 6849 # if (word-slice == '}') abort - 6850 (slice-equal? %ecx "}") # => eax - 6851 3d/compare-eax-and 0/imm32/false - 6852 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6853 # v = parse-var-with-type(word-slice, first-line) - 6854 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) - 6855 # assert(v->register == null) - 6856 # . eax: (addr var) = lookup(v) - 6857 (lookup *ebx *(ebx+4)) # => eax - 6858 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 6859 0f 85/jump-if-!= $populate-mu-function-header:error2/disp32 - 6860 # v->block-depth is implicitly 0 - 6861 # - 6862 # out->inouts = append(v, out->inouts) - 6863 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts - 6864 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts - 6865 # push(vars, {v, false}) - 6866 (push *(ebp+0x10) *ebx) - 6867 (push *(ebp+0x10) *(ebx+4)) - 6868 (push *(ebp+0x10) 0) # false - 6869 # - 6870 e9/jump loop/disp32 - 6871 } - 6872 # save function outputs - 6873 { - 6874 $populate-mu-function-header:check-for-out: - 6875 (next-mu-token *(ebp+8) %ecx) - 6876 # if (word-slice == '{') break - 6877 (slice-equal? %ecx "{") # => eax - 6878 3d/compare-eax-and 0/imm32/false - 6879 0f 85/jump-if-!= break/disp32 - 6880 # if (word-slice == '->') abort - 6881 (slice-equal? %ecx "->") # => eax - 6882 3d/compare-eax-and 0/imm32/false - 6883 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6884 # if (word-slice == '}') abort - 6885 (slice-equal? %ecx "}") # => eax - 6886 3d/compare-eax-and 0/imm32/false - 6887 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 - 6888 # v = parse-var-with-type(word-slice, first-line) - 6889 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) - 6890 # assert(var->register != null) - 6891 # . eax: (addr var) = lookup(v) - 6892 (lookup *ebx *(ebx+4)) # => eax - 6893 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 6894 0f 84/jump-if-= $populate-mu-function-header:error3/disp32 - 6895 # out->outputs = append(v, out->outputs) - 6896 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs - 6897 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs - 6898 # - 6899 e9/jump loop/disp32 - 6900 } - 6901 $populate-mu-function-header:done: - 6902 (check-no-tokens-left *(ebp+8)) - 6903 $populate-mu-function-header:end: - 6904 # . reclaim locals - 6905 81 0/subop/add %esp 0x10/imm32 - 6906 # . restore registers - 6907 5f/pop-to-edi - 6908 5b/pop-to-ebx - 6909 5a/pop-to-edx - 6910 59/pop-to-ecx - 6911 58/pop-to-eax - 6912 # . epilogue - 6913 89/<- %esp 5/r32/ebp - 6914 5d/pop-to-ebp - 6915 c3/return - 6916 - 6917 $populate-mu-function-header:error1: - 6918 # error("function header not in form 'fn <name> {'") - 6919 (write-buffered *(ebp+0x14) "function header not in form 'fn <name> [inouts] [-> outputs] {' -- '") - 6920 (flush *(ebp+0x14)) - 6921 (rewind-stream *(ebp+8)) - 6922 (write-stream-data *(ebp+0x14) *(ebp+8)) - 6923 (write-buffered *(ebp+0x14) "'\n") - 6924 (flush *(ebp+0x14)) - 6925 (stop *(ebp+0x18) 1) - 6926 # never gets here - 6927 - 6928 $populate-mu-function-header:error2: - 6929 # error("fn " fn ": function inout '" var "' cannot be in a register") - 6930 (write-buffered *(ebp+0x14) "fn ") - 6931 50/push-eax - 6932 (lookup *edi *(edi+4)) # Function-name Function-name => eax - 6933 (write-buffered *(ebp+0x14) %eax) - 6934 58/pop-to-eax - 6935 (write-buffered *(ebp+0x14) ": function inout '") - 6936 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 6937 (write-buffered *(ebp+0x10) %eax) - 6938 (write-buffered *(ebp+0x14) "' cannot be in a register") - 6939 (flush *(ebp+0x14)) - 6940 (stop *(ebp+0x18) 1) - 6941 # never gets here - 6942 - 6943 $populate-mu-function-header:error3: - 6944 # error("fn " fn ": function output '" var "' must be in a register") - 6945 (write-buffered *(ebp+0x14) "fn ") - 6946 50/push-eax - 6947 (lookup *edi *(edi+4)) # Function-name Function-name => eax - 6948 (write-buffered *(ebp+0x14) %eax) - 6949 58/pop-to-eax - 6950 (write-buffered *(ebp+0x14) ": function output '") - 6951 (lookup *ebx *(ebx+4)) # => eax - 6952 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 6953 (write-buffered *(ebp+0x14) %eax) - 6954 (write-buffered *(ebp+0x14) "' must be in a register, in instruction '") - 6955 (rewind-stream *(ebp+8)) - 6956 (write-stream-data *(ebp+0x14) *(ebp+8)) - 6957 (write-buffered *(ebp+0x14) "'\n") - 6958 (flush *(ebp+0x14)) - 6959 (stop *(ebp+0x18) 1) - 6960 # never gets here - 6961 - 6962 # scenarios considered: - 6963 # ✓ fn foo - 6964 # ✗ fn foo { - 6965 # ✓ fn foo x - 6966 # ✓ fn foo x: int - 6967 # ✓ fn foo x: int -> y/eax: int - 6968 # TODO: - 6969 # disallow outputs of type `(... addr ...)` - 6970 # disallow inputs of type `(... addr ... addr ...)` - 6971 populate-mu-function-signature: # first-line: (addr stream byte), out: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 6972 # pseudocode: - 6973 # var word-slice: slice - 6974 # next-mu-token(first-line, word-slice) - 6975 # assert(word-slice not in '{' '}' '->') - 6976 # out->name = slice-to-string(word-slice) - 6977 # ## inouts - 6978 # while true - 6979 # word-slice = next-mu-token(first-line) - 6980 # if slice-empty?(word-slice) break - 6981 # if (word-slice == '->') break - 6982 # assert(word-slice not in '{' '}') - 6983 # var v: (handle var) = parse-var-with-type(word-slice, first-line) - 6984 # assert(v->register == null) - 6985 # # v->block-depth is implicitly 0 - 6986 # out->inouts = append(v, out->inouts) - 6987 # ## outputs - 6988 # while true - 6989 # word-slice = next-mu-token(first-line) - 6990 # if slice-empty?(word-slice) break - 6991 # assert(word-slice not in '{' '}' '->') - 6992 # var v: (handle var) = parse-var-with-type(word-slice, first-line) - 6993 # assert(v->register != null) - 6994 # out->outputs = append(v, out->outputs) - 6995 # - 6996 # . prologue - 6997 55/push-ebp - 6998 89/<- %ebp 4/r32/esp - 6999 # . save registers - 7000 50/push-eax - 7001 51/push-ecx - 7002 52/push-edx - 7003 53/push-ebx - 7004 57/push-edi - 7005 # edi = out - 7006 8b/-> *(ebp+0xc) 7/r32/edi - 7007 # var word-slice/ecx: slice - 7008 68/push 0/imm32/end - 7009 68/push 0/imm32/start - 7010 89/<- %ecx 4/r32/esp - 7011 # var v/ebx: (handle var) - 7012 68/push 0/imm32 - 7013 68/push 0/imm32 - 7014 89/<- %ebx 4/r32/esp - 7015 # read function name - 7016 (next-mu-token *(ebp+8) %ecx) - 7017 # error checking - 7018 # if (word-slice == '{') abort - 7019 (slice-equal? %ecx "{") # => eax - 7020 3d/compare-eax-and 0/imm32/false - 7021 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7022 # if (word-slice == '->') abort - 7023 (slice-equal? %ecx "->") # => eax - 7024 3d/compare-eax-and 0/imm32/false - 7025 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7026 # if (word-slice == '}') abort - 7027 (slice-equal? %ecx "}") # => eax - 7028 3d/compare-eax-and 0/imm32/false - 7029 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7030 # save function name - 7031 (slice-to-string Heap %ecx %edi) # Function-name - 7032 # save function inouts - 7033 { - 7034 $populate-mu-function-signature:check-for-inout: - 7035 (next-mu-token *(ebp+8) %ecx) - 7036 (slice-empty? %ecx) # => eax - 7037 3d/compare-eax-and 0/imm32/false - 7038 0f 85/jump-if-!= break/disp32 - 7039 # if (word-slice == '->') break - 7040 (slice-equal? %ecx "->") # => eax - 7041 3d/compare-eax-and 0/imm32/false - 7042 0f 85/jump-if-!= break/disp32 - 7043 # if (word-slice == '{') abort - 7044 (slice-equal? %ecx "{") # => eax - 7045 3d/compare-eax-and 0/imm32/false - 7046 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7047 # if (word-slice == '}') abort - 7048 (slice-equal? %ecx "}") # => eax - 7049 3d/compare-eax-and 0/imm32/false - 7050 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7051 # v = parse-var-with-type(word-slice, first-line) - 7052 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) - 7053 # assert(v->register == null) - 7054 # . eax: (addr var) = lookup(v) - 7055 (lookup *ebx *(ebx+4)) # => eax - 7056 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 7057 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32 - 7058 # v->block-depth is implicitly 0 - 7059 # - 7060 # out->inouts = append(v, out->inouts) - 7061 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts - 7062 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts - 7063 # - 7064 e9/jump loop/disp32 - 7065 } - 7066 # save function outputs - 7067 { - 7068 $populate-mu-function-signature:check-for-out: - 7069 (next-mu-token *(ebp+8) %ecx) - 7070 (slice-empty? %ecx) # => eax - 7071 3d/compare-eax-and 0/imm32/false - 7072 0f 85/jump-if-!= break/disp32 - 7073 # if (word-slice == '{') abort - 7074 (slice-equal? %ecx "{") # => eax - 7075 3d/compare-eax-and 0/imm32/false - 7076 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7077 # if (word-slice == '->') abort - 7078 (slice-equal? %ecx "->") # => eax - 7079 3d/compare-eax-and 0/imm32/false - 7080 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7081 # if (word-slice == '}') abort - 7082 (slice-equal? %ecx "}") # => eax - 7083 3d/compare-eax-and 0/imm32/false - 7084 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 - 7085 # v = parse-var-with-type(word-slice, first-line) - 7086 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) - 7087 # assert(var->register != null) - 7088 # . eax: (addr var) = lookup(v) - 7089 (lookup *ebx *(ebx+4)) # => eax - 7090 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 7091 0f 84/jump-if-= $populate-mu-function-signature:error3/disp32 - 7092 # out->outputs = append(v, out->outputs) - 7093 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs - 7094 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs - 7095 # - 7096 e9/jump loop/disp32 - 7097 } - 7098 $populate-mu-function-signature:done: - 7099 (check-no-tokens-left *(ebp+8)) - 7100 $populate-mu-function-signature:end: - 7101 # . reclaim locals - 7102 81 0/subop/add %esp 0x10/imm32 - 7103 # . restore registers - 7104 5f/pop-to-edi - 7105 5b/pop-to-ebx - 7106 5a/pop-to-edx - 7107 59/pop-to-ecx - 7108 58/pop-to-eax - 7109 # . epilogue - 7110 89/<- %esp 5/r32/ebp - 7111 5d/pop-to-ebp - 7112 c3/return - 7113 - 7114 $populate-mu-function-signature:error1: - 7115 # error("function signature not in form 'fn <name> {'") - 7116 (write-buffered *(ebp+0x10) "function signature not in form 'fn <name> [inouts] [-> outputs] {' -- '") - 7117 (flush *(ebp+0x10)) - 7118 (rewind-stream *(ebp+8)) - 7119 (write-stream-data *(ebp+0x10) *(ebp+8)) - 7120 (write-buffered *(ebp+0x10) "'\n") - 7121 (flush *(ebp+0x10)) - 7122 (stop *(ebp+0x14) 1) - 7123 # never gets here - 7124 - 7125 $populate-mu-function-signature:error2: - 7126 # error("fn " fn ": function inout '" var "' cannot be in a register") - 7127 (write-buffered *(ebp+0x10) "fn ") - 7128 50/push-eax - 7129 (lookup *edi *(edi+4)) # Function-name Function-name => eax - 7130 (write-buffered *(ebp+0x10) %eax) - 7131 58/pop-to-eax - 7132 (write-buffered *(ebp+0x10) ": function inout '") - 7133 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 7134 (write-buffered *(ebp+0x10) %eax) - 7135 (write-buffered *(ebp+0x10) "' cannot be in a register") - 7136 (flush *(ebp+0x10)) - 7137 (stop *(ebp+0x14) 1) - 7138 # never gets here - 7139 - 7140 $populate-mu-function-signature:error3: - 7141 # error("fn " fn ": function output '" var "' must be in a register") - 7142 (write-buffered *(ebp+0x10) "fn ") - 7143 50/push-eax - 7144 (lookup *edi *(edi+4)) # Function-name Function-name => eax - 7145 (write-buffered *(ebp+0x10) %eax) - 7146 58/pop-to-eax - 7147 (write-buffered *(ebp+0x10) ": function output '") - 7148 (lookup *ebx *(ebx+4)) # => eax - 7149 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 7150 (write-buffered *(ebp+0x10) %eax) - 7151 (write-buffered *(ebp+0x10) "' must be in a register, in instruction '") - 7152 (rewind-stream *(ebp+8)) - 7153 (write-stream-data *(ebp+0x10) *(ebp+8)) - 7154 (write-buffered *(ebp+0x10) "'\n") - 7155 (flush *(ebp+0x10)) - 7156 (stop *(ebp+0x14) 1) - 7157 # never gets here - 7158 - 7159 test-function-header-with-arg: - 7160 # . prologue - 7161 55/push-ebp - 7162 89/<- %ebp 4/r32/esp - 7163 # setup - 7164 (clear-stream _test-input-stream) - 7165 (write _test-input-stream "foo n: int {\n") - 7166 # var result/ecx: function - 7167 2b/subtract *Function-size 4/r32/esp - 7168 89/<- %ecx 4/r32/esp - 7169 (zero-out %ecx *Function-size) - 7170 # var vars/ebx: (stack live-var 16) - 7171 81 5/subop/subtract %esp 0xc0/imm32 - 7172 68/push 0xc0/imm32/size - 7173 68/push 0/imm32/top - 7174 89/<- %ebx 4/r32/esp - 7175 # convert - 7176 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) - 7177 # check result->name - 7178 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax - 7179 (check-strings-equal %eax "foo" "F - test-function-header-with-arg/name") - 7180 # var v/edx: (addr var) = result->inouts->value - 7181 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax - 7182 (lookup *eax *(eax+4)) # List-value List-value => eax - 7183 89/<- %edx 0/r32/eax - 7184 # check v->name - 7185 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 7186 (check-strings-equal %eax "n" "F - test-function-header-with-arg/inout:0") - 7187 # check v->type - 7188 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 7189 (check-ints-equal *eax 1 "F - test-function-header-with-arg/inout:0/type:0") # Type-tree-is-atom - 7190 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-arg/inout:0/type:1") # Type-tree-value - 7191 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-arg/inout:0/type:2") # Type-tree-right - 7192 # . epilogue - 7193 89/<- %esp 5/r32/ebp - 7194 5d/pop-to-ebp - 7195 c3/return - 7196 - 7197 test-function-header-with-multiple-args: - 7198 # . prologue - 7199 55/push-ebp - 7200 89/<- %ebp 4/r32/esp - 7201 # setup - 7202 (clear-stream _test-input-stream) - 7203 (write _test-input-stream "foo a: int, b: int c: int {\n") - 7204 # result/ecx: function - 7205 2b/subtract *Function-size 4/r32/esp - 7206 89/<- %ecx 4/r32/esp - 7207 (zero-out %ecx *Function-size) - 7208 # var vars/ebx: (stack live-var 16) - 7209 81 5/subop/subtract %esp 0xc0/imm32 - 7210 68/push 0xc0/imm32/size - 7211 68/push 0/imm32/top - 7212 89/<- %ebx 4/r32/esp - 7213 # convert - 7214 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) - 7215 # check result->name - 7216 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax - 7217 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args/name") - 7218 # var inouts/edx: (addr list var) = lookup(result->inouts) - 7219 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax - 7220 89/<- %edx 0/r32/eax - 7221 $test-function-header-with-multiple-args:inout0: - 7222 # var v/ebx: (addr var) = lookup(inouts->value) - 7223 (lookup *edx *(edx+4)) # List-value List-value => eax - 7224 89/<- %ebx 0/r32/eax - 7225 # check v->name - 7226 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7227 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args/inout:0") # Var-name - 7228 # check v->type - 7229 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7230 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:0/type:0") # Type-tree-is-atom - 7231 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:0/type:1") # Type-tree-value - 7232 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:0/type:2") # Type-tree-right - 7233 $test-function-header-with-multiple-args:inout1: - 7234 # inouts = lookup(inouts->next) - 7235 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax - 7236 89/<- %edx 0/r32/eax - 7237 # v = lookup(inouts->value) - 7238 (lookup *edx *(edx+4)) # List-value List-value => eax - 7239 89/<- %ebx 0/r32/eax - 7240 # check v->name - 7241 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7242 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args/inout:1") # Var-name - 7243 # check v->type - 7244 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7245 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:1/type:0") # Type-tree-is-atom - 7246 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:1/type:1") # Type-tree-value - 7247 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:1/type:2") # Type-tree-right - 7248 $test-function-header-with-multiple-args:inout2: - 7249 # inouts = lookup(inouts->next) - 7250 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax - 7251 89/<- %edx 0/r32/eax - 7252 # v = lookup(inouts->value) - 7253 (lookup *edx *(edx+4)) # List-value List-value => eax - 7254 89/<- %ebx 0/r32/eax - 7255 # check v->name - 7256 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7257 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args/inout:2") # Var-name - 7258 # check v->type - 7259 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7260 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:2/type:0") # Type-tree-is-atom - 7261 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:2/type:1") # Type-tree-value - 7262 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:2/type:2") # Type-tree-right - 7263 # . epilogue - 7264 89/<- %esp 5/r32/ebp - 7265 5d/pop-to-ebp - 7266 c3/return - 7267 - 7268 test-function-header-with-multiple-args-and-outputs: - 7269 # . prologue - 7270 55/push-ebp - 7271 89/<- %ebp 4/r32/esp - 7272 # setup - 7273 (clear-stream _test-input-stream) - 7274 (write _test-input-stream "foo a: int, b: int, c: int -> x/ecx: int y/edx: int {\n") - 7275 # result/ecx: function - 7276 2b/subtract *Function-size 4/r32/esp - 7277 89/<- %ecx 4/r32/esp - 7278 (zero-out %ecx *Function-size) - 7279 # var vars/ebx: (stack live-var 16) - 7280 81 5/subop/subtract %esp 0xc0/imm32 - 7281 68/push 0xc0/imm32/size - 7282 68/push 0/imm32/top - 7283 89/<- %ebx 4/r32/esp - 7284 # convert - 7285 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) - 7286 # check result->name - 7287 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax - 7288 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args-and-outputs/name") - 7289 # var inouts/edx: (addr list var) = lookup(result->inouts) - 7290 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax - 7291 89/<- %edx 0/r32/eax - 7292 $test-function-header-with-multiple-args-and-outputs:inout0: - 7293 # var v/ebx: (addr var) = lookup(inouts->value) - 7294 (lookup *edx *(edx+4)) # List-value List-value => eax - 7295 89/<- %ebx 0/r32/eax - 7296 # check v->name - 7297 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7298 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args-and-outputs/inout:0") - 7299 # check v->type - 7300 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7301 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:0") # Type-tree-is-atom - 7302 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:1") # Type-tree-value - 7303 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:2") # Type-tree-right - 7304 $test-function-header-with-multiple-args-and-outputs:inout1: - 7305 # inouts = lookup(inouts->next) - 7306 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax - 7307 89/<- %edx 0/r32/eax - 7308 # v = lookup(inouts->value) - 7309 (lookup *edx *(edx+4)) # List-value List-value => eax - 7310 89/<- %ebx 0/r32/eax - 7311 # check v->name - 7312 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7313 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args-and-outputs/inout:1") - 7314 # check v->type - 7315 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7316 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:0") # Type-tree-is-atom - 7317 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:1") # Type-tree-value - 7318 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:2") # Type-tree-right - 7319 $test-function-header-with-multiple-args-and-outputs:inout2: - 7320 # inouts = lookup(inouts->next) - 7321 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax - 7322 89/<- %edx 0/r32/eax - 7323 # v = lookup(inouts->value) - 7324 (lookup *edx *(edx+4)) # List-value List-value => eax - 7325 89/<- %ebx 0/r32/eax - 7326 # check v->name - 7327 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7328 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args-and-outputs/inout:2") - 7329 # check v->type - 7330 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7331 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:0") # Type-tree-is-atom - 7332 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:1") # Type-tree-value - 7333 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:2") # Type-tree-right - 7334 $test-function-header-with-multiple-args-and-outputs:out0: - 7335 # var outputs/edx: (addr list var) = lookup(result->outputs) - 7336 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax - 7337 89/<- %edx 0/r32/eax - 7338 # v = lookup(outputs->value) - 7339 (lookup *edx *(edx+4)) # List-value List-value => eax - 7340 89/<- %ebx 0/r32/eax - 7341 # check v->name - 7342 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7343 (check-strings-equal %eax "x" "F - test-function-header-with-multiple-args-and-outputs/output:0") - 7344 # check v->register - 7345 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 7346 (check-strings-equal %eax "ecx" "F - test-function-header-with-multiple-args-and-outputs/output:0/register") - 7347 # check v->type - 7348 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7349 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:0") # Type-tree-is-atom - 7350 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:1") # Type-tree-value - 7351 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:2") # Type-tree-right - 7352 $test-function-header-with-multiple-args-and-outputs:out1: - 7353 # outputs = lookup(outputs->next) - 7354 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax - 7355 89/<- %edx 0/r32/eax - 7356 # v = lookup(inouts->value) - 7357 (lookup *edx *(edx+4)) # List-value List-value => eax - 7358 89/<- %ebx 0/r32/eax - 7359 # check v->name - 7360 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 7361 (check-strings-equal %eax "y" "F - test-function-header-with-multiple-args-and-outputs/output:1") - 7362 # check v->register - 7363 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 7364 (check-strings-equal %eax "edx" "F - test-function-header-with-multiple-args-and-outputs/output:1/register") - 7365 # check v->type - 7366 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax - 7367 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:0") # Type-tree-is-atom - 7368 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:1") # Type-tree-value - 7369 (check-ints-equal *(eax+0c) 0 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:2") # Type-tree-right - 7370 # . epilogue - 7371 89/<- %esp 5/r32/ebp - 7372 5d/pop-to-ebp - 7373 c3/return - 7374 - 7375 # format for variables with types - 7376 # x: int - 7377 # x: int, - 7378 # x/eax: int - 7379 # x/eax: int, - 7380 # ignores at most one trailing comma - 7381 # WARNING: modifies name - 7382 parse-var-with-type: # name: (addr slice), first-line: (addr stream byte), out: (addr handle var), err: (addr buffered-file), ed: (addr exit-descriptor) - 7383 # pseudocode: - 7384 # var s: slice - 7385 # if (!slice-ends-with(name, ":")) - 7386 # abort - 7387 # --name->end to skip ':' - 7388 # next-token-from-slice(name->start, name->end, '/', s) - 7389 # new-var-from-slice(s, out) - 7390 # ## register - 7391 # next-token-from-slice(s->end, name->end, '/', s) - 7392 # if (!slice-empty?(s)) - 7393 # out->register = slice-to-string(s) - 7394 # ## type - 7395 # var type: (handle type-tree) = parse-type(first-line) - 7396 # out->type = type - 7397 # - 7398 # . prologue - 7399 55/push-ebp - 7400 89/<- %ebp 4/r32/esp - 7401 # . save registers - 7402 50/push-eax - 7403 51/push-ecx - 7404 52/push-edx - 7405 53/push-ebx - 7406 56/push-esi - 7407 57/push-edi - 7408 # esi = name - 7409 8b/-> *(ebp+8) 6/r32/esi - 7410 # if (!slice-ends-with?(name, ":")) abort - 7411 8b/-> *(esi+4) 1/r32/ecx # Slice-end - 7412 49/decrement-ecx - 7413 8a/copy-byte *ecx 1/r32/CL - 7414 81 4/subop/and %ecx 0xff/imm32 - 7415 81 7/subop/compare %ecx 0x3a/imm32/colon - 7416 0f 85/jump-if-!= $parse-var-with-type:abort/disp32 - 7417 # --name->end to skip ':' - 7418 ff 1/subop/decrement *(esi+4) - 7419 # var s/ecx: slice - 7420 68/push 0/imm32/end - 7421 68/push 0/imm32/start - 7422 89/<- %ecx 4/r32/esp - 7423 $parse-var-with-type:parse-name: - 7424 (next-token-from-slice *esi *(esi+4) 0x2f %ecx) # Slice-start, Slice-end, '/' - 7425 $parse-var-with-type:create-var: - 7426 # new-var-from-slice(s, out) - 7427 (new-var-from-slice Heap %ecx *(ebp+0x10)) - 7428 # save out->register - 7429 $parse-var-with-type:save-register: - 7430 # . var out-addr/edi: (addr var) = lookup(*out) - 7431 8b/-> *(ebp+0x10) 7/r32/edi - 7432 (lookup *edi *(edi+4)) # => eax - 7433 89/<- %edi 0/r32/eax - 7434 # . s = next-token(...) - 7435 (next-token-from-slice *(ecx+4) *(esi+4) 0x2f %ecx) # s->end, name->end, '/' - 7436 # . if (!slice-empty?(s)) out->register = slice-to-string(s) - 7437 { - 7438 $parse-var-with-type:write-register: - 7439 (slice-empty? %ecx) # => eax - 7440 3d/compare-eax-and 0/imm32/false - 7441 75/jump-if-!= break/disp8 - 7442 # out->register = slice-to-string(s) - 7443 8d/copy-address *(edi+0x18) 0/r32/eax # Var-register - 7444 (slice-to-string Heap %ecx %eax) - 7445 } - 7446 $parse-var-with-type:save-type: - 7447 8d/copy-address *(edi+8) 0/r32/eax # Var-type - 7448 (parse-type Heap *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) - 7449 $parse-var-with-type:end: - 7450 # . reclaim locals - 7451 81 0/subop/add %esp 8/imm32 - 7452 # . restore registers - 7453 5f/pop-to-edi - 7454 5e/pop-to-esi - 7455 5b/pop-to-ebx - 7456 5a/pop-to-edx - 7457 59/pop-to-ecx - 7458 58/pop-to-eax - 7459 # . epilogue - 7460 89/<- %esp 5/r32/ebp - 7461 5d/pop-to-ebp - 7462 c3/return - 7463 - 7464 $parse-var-with-type:abort: - 7465 # error("var should have form 'name: type' in '" line "'\n") - 7466 (write-buffered *(ebp+0x14) "var should have form 'name: type' in '") - 7467 (flush *(ebp+0x14)) - 7468 (rewind-stream *(ebp+0xc)) - 7469 (write-stream-data *(ebp+0x14) *(ebp+0xc)) - 7470 (write-buffered *(ebp+0x14) "'\n") - 7471 (flush *(ebp+0x14)) - 7472 (stop *(ebp+0x18) 1) - 7473 # never gets here - 7474 - 7475 parse-type: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) + 6305 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 + 6306 (write _test-input-stream " x: int\n") + 6307 (write _test-input-stream " y: int\n") + 6308 (write _test-input-stream "}\n") + 6309 (write _test-input-stream "fn foo {\n") + 6310 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 6311 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 6312 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 6313 (write _test-input-stream "}\n") + 6314 # convert + 6315 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6316 (flush _test-output-buffered-file) + 6317 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6323 # check output + 6324 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") + 6325 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") + 6326 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-array-of-user-defined-types/2") + 6327 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-array-of-user-defined-types/3") + 6328 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-array-of-user-defined-types/4") + 6329 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-array-of-user-defined-types/5") + 6330 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-array-of-user-defined-types/6") + 6331 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-array-of-user-defined-types/7") + 6332 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-array-of-user-defined-types/8") + 6333 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-array-of-user-defined-types/9") + 6334 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000003 + 4) 0x00000000/r32" "F - test-convert-array-of-user-defined-types/11") + 6335 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-array-of-user-defined-types/13") + 6336 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-array-of-user-defined-types/14") + 6337 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-array-of-user-defined-types/15") + 6338 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-array-of-user-defined-types/16") + 6339 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-array-of-user-defined-types/17") + 6340 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-array-of-user-defined-types/18") + 6341 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-array-of-user-defined-types/19") + 6342 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-array-of-user-defined-types/20") + 6343 # . epilogue + 6344 89/<- %esp 5/r32/ebp + 6345 5d/pop-to-ebp + 6346 c3/return + 6347 + 6348 test-convert-length-of-array-of-user-defined-types-to-eax: + 6349 # . prologue + 6350 55/push-ebp + 6351 89/<- %ebp 4/r32/esp + 6352 # setup + 6353 (clear-stream _test-input-stream) + 6354 (clear-stream $_test-input-buffered-file->buffer) + 6355 (clear-stream _test-output-stream) + 6356 (clear-stream $_test-output-buffered-file->buffer) + 6357 # + 6358 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 6359 (write _test-input-stream " x: int\n") + 6360 (write _test-input-stream " y: int\n") + 6361 (write _test-input-stream " z: int\n") + 6362 (write _test-input-stream "}\n") + 6363 (write _test-input-stream "fn foo {\n") + 6364 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 6365 (write _test-input-stream " var x/eax: (addr t) <- length arr\n") + 6366 (write _test-input-stream "}\n") + 6367 # convert + 6368 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6369 (flush _test-output-buffered-file) + 6370 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6376 # check output + 6377 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") + 6378 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") + 6379 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/2") + 6380 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/3") + 6381 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-eax/4") + 6382 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/5") + 6383 # var arr + 6384 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/6") + 6385 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/7") + 6386 # length instruction + 6387 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/8") + 6388 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/9") + 6389 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/10") + 6390 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/11") + 6391 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/12") + 6392 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/13") + 6393 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/14") + 6394 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/15") + 6395 # reclaim arr + 6396 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/16") + 6397 # + 6398 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-eax/17") + 6399 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/18") + 6400 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/19") + 6401 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/20") + 6402 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/21") + 6403 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-eax/22") + 6404 # . epilogue + 6405 89/<- %esp 5/r32/ebp + 6406 5d/pop-to-ebp + 6407 c3/return + 6408 + 6409 test-convert-length-of-array-of-user-defined-types-to-ecx: + 6410 # . prologue + 6411 55/push-ebp + 6412 89/<- %ebp 4/r32/esp + 6413 # setup + 6414 (clear-stream _test-input-stream) + 6415 (clear-stream $_test-input-buffered-file->buffer) + 6416 (clear-stream _test-output-stream) + 6417 (clear-stream $_test-output-buffered-file->buffer) + 6418 # + 6419 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 6420 (write _test-input-stream " x: int\n") + 6421 (write _test-input-stream " y: int\n") + 6422 (write _test-input-stream " z: int\n") + 6423 (write _test-input-stream "}\n") + 6424 (write _test-input-stream "fn foo {\n") + 6425 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 6426 (write _test-input-stream " var x/ecx: (addr t) <- length arr\n") + 6427 (write _test-input-stream "}\n") + 6428 # convert + 6429 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6430 (flush _test-output-buffered-file) + 6431 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6437 # check output + 6438 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") + 6439 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") + 6440 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/2") + 6441 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/3") + 6442 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/4") + 6443 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/5") + 6444 # var a + 6445 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/6") + 6446 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/7") + 6447 # var x + 6448 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/8") + 6449 # length instruction + 6450 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/9") + 6451 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/10") + 6452 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/11") + 6453 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/12") + 6454 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/13") + 6455 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/14") + 6456 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/15") + 6457 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/16") + 6458 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/17") + 6459 # reclaim x + 6460 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/18") + 6461 # reclaim a + 6462 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/19") + 6463 # + 6464 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/20") + 6465 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/21") + 6466 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/22") + 6467 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/23") + 6468 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/24") + 6469 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/25") + 6470 # . epilogue + 6471 89/<- %esp 5/r32/ebp + 6472 5d/pop-to-ebp + 6473 c3/return + 6474 + 6475 test-convert-length-of-array-of-user-defined-types-to-edx: + 6476 # . prologue + 6477 55/push-ebp + 6478 89/<- %ebp 4/r32/esp + 6479 # setup + 6480 (clear-stream _test-input-stream) + 6481 (clear-stream $_test-input-buffered-file->buffer) + 6482 (clear-stream _test-output-stream) + 6483 (clear-stream $_test-output-buffered-file->buffer) + 6484 # + 6485 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 6486 (write _test-input-stream " x: int\n") + 6487 (write _test-input-stream " y: int\n") + 6488 (write _test-input-stream " z: int\n") + 6489 (write _test-input-stream "}\n") + 6490 (write _test-input-stream "fn foo {\n") + 6491 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 6492 (write _test-input-stream " var x/edx: (addr t) <- length arr\n") + 6493 (write _test-input-stream "}\n") + 6494 # convert + 6495 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6496 (flush _test-output-buffered-file) + 6497 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6503 # check output + 6504 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") + 6505 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") + 6506 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/2") + 6507 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/3") + 6508 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-edx/4") + 6509 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/5") + 6510 # var a + 6511 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/6") + 6512 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/7") + 6513 # var x + 6514 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/8") + 6515 # length instruction + 6516 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/9") + 6517 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/10") + 6518 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/11") + 6519 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/12") + 6520 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/13") + 6521 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/14") + 6522 (check-next-stream-line-equal _test-output-stream " 89/<- %edx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/15") + 6523 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/16") + 6524 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/17") + 6525 # reclaim x + 6526 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/18") + 6527 # reclaim a + 6528 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/19") + 6529 # + 6530 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-edx/20") + 6531 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/21") + 6532 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/22") + 6533 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/23") + 6534 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/24") + 6535 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-edx/25") + 6536 # . epilogue + 6537 89/<- %esp 5/r32/ebp + 6538 5d/pop-to-ebp + 6539 c3/return + 6540 + 6541 test-convert-length-of-array-of-user-defined-types: + 6542 # . prologue + 6543 55/push-ebp + 6544 89/<- %ebp 4/r32/esp + 6545 # setup + 6546 (clear-stream _test-input-stream) + 6547 (clear-stream $_test-input-buffered-file->buffer) + 6548 (clear-stream _test-output-stream) + 6549 (clear-stream $_test-output-buffered-file->buffer) + 6550 # + 6551 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 + 6552 (write _test-input-stream " x: int\n") + 6553 (write _test-input-stream " y: int\n") + 6554 (write _test-input-stream " z: int\n") + 6555 (write _test-input-stream "}\n") + 6556 (write _test-input-stream "fn foo {\n") + 6557 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 6558 (write _test-input-stream " var x/ebx: (addr t) <- length arr\n") + 6559 (write _test-input-stream "}\n") + 6560 # convert + 6561 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6562 (flush _test-output-buffered-file) + 6563 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 6569 # check output + 6570 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") + 6571 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") + 6572 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types/2") + 6573 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types/3") + 6574 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types/4") + 6575 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types/5") + 6576 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types/6") + 6577 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types/7") + 6578 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-length-of-array-of-user-defined-types/8") + 6579 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types/9") + 6580 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types/10") + 6581 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types/11") + 6582 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types/12") + 6583 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types/13") + 6584 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types/14") + 6585 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types/15") + 6586 (check-next-stream-line-equal _test-output-stream " 89/<- %ebx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types/16") + 6587 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types/17") + 6588 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types/18") + 6589 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types/19") + 6590 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ebx" "F - test-convert-length-of-array-of-user-defined-types/20") + 6591 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types/21") + 6592 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types/22") + 6593 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types/23") + 6594 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types/24") + 6595 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types/25") + 6596 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types/26") + 6597 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types/27") + 6598 # . epilogue + 6599 89/<- %esp 5/r32/ebp + 6600 5d/pop-to-ebp + 6601 c3/return + 6602 + 6603 ####################################################### + 6604 # Parsing + 6605 ####################################################### + 6606 + 6607 == data + 6608 + 6609 # Global state added to each var record when parsing a function + 6610 Next-block-index: # (addr int) + 6611 1/imm32 + 6612 + 6613 Curr-block-depth: # (addr int) + 6614 1/imm32 + 6615 + 6616 == code + 6617 + 6618 parse-mu: # in: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) + 6619 # pseudocode + 6620 # var curr-function: (addr handle function) = Program->functions + 6621 # var curr-signature: (addr handle function) = Program->signatures + 6622 # var curr-type: (addr handle typeinfo) = Program->types + 6623 # var line: (stream byte 512) + 6624 # var word-slice: slice + 6625 # while true # line loop + 6626 # clear-stream(line) + 6627 # read-line-buffered(in, line) + 6628 # if (line->write == 0) break # end of file + 6629 # word-slice = next-mu-token(line) + 6630 # if slice-empty?(word-slice) # end of line + 6631 # continue + 6632 # else if slice-starts-with?(word-slice, "#") # comment + 6633 # continue # end of line + 6634 # else if slice-equal?(word-slice, "fn") + 6635 # var new-function: (handle function) = allocate(function) + 6636 # var vars: (stack live-var 256) + 6637 # populate-mu-function-header(line, new-function, vars) + 6638 # populate-mu-function-body(in, new-function, vars) + 6639 # assert(vars->top == 0) + 6640 # *curr-function = new-function + 6641 # curr-function = &new-function->next + 6642 # else if slice-equal?(word-slice, "sig") + 6643 # var new-function: (handle function) = allocate(function) + 6644 # populate-mu-function-signature(line, new-function) + 6645 # *curr-signature = new-function + 6646 # curr-signature = &new-function->next + 6647 # else if slice-equal?(word-slice, "type") + 6648 # word-slice = next-mu-token(line) + 6649 # type-id = pos-or-insert-slice(Type-id, word-slice) + 6650 # var new-type: (handle typeinfo) = find-or-create-typeinfo(type-id) + 6651 # assert(next-word(line) == "{") + 6652 # populate-mu-type(in, new-type) + 6653 # else + 6654 # abort() + 6655 # + 6656 # . prologue + 6657 55/push-ebp + 6658 89/<- %ebp 4/r32/esp + 6659 # var curr-signature: (addr handle function) at *(ebp-4) + 6660 68/push _Program-signatures/imm32 + 6661 # . save registers + 6662 50/push-eax + 6663 51/push-ecx + 6664 52/push-edx + 6665 53/push-ebx + 6666 56/push-esi + 6667 57/push-edi + 6668 # var line/ecx: (stream byte 512) + 6669 81 5/subop/subtract %esp 0x200/imm32 + 6670 68/push 0x200/imm32/size + 6671 68/push 0/imm32/read + 6672 68/push 0/imm32/write + 6673 89/<- %ecx 4/r32/esp + 6674 # var word-slice/edx: slice + 6675 68/push 0/imm32/end + 6676 68/push 0/imm32/start + 6677 89/<- %edx 4/r32/esp + 6678 # var curr-function/edi: (addr handle function) + 6679 bf/copy-to-edi _Program-functions/imm32 + 6680 # var vars/ebx: (stack live-var 256) + 6681 81 5/subop/subtract %esp 0xc00/imm32 + 6682 68/push 0xc00/imm32/size + 6683 68/push 0/imm32/top + 6684 89/<- %ebx 4/r32/esp + 6685 { + 6686 $parse-mu:line-loop: + 6687 (clear-stream %ecx) + 6688 (read-line-buffered *(ebp+8) %ecx) + 6689 # if (line->write == 0) break + 6690 81 7/subop/compare *ecx 0/imm32 + 6691 0f 84/jump-if-= break/disp32 + 6692 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ + 6698 (next-mu-token %ecx %edx) + 6699 # if slice-empty?(word-slice) continue + 6700 (slice-empty? %edx) # => eax + 6701 3d/compare-eax-and 0/imm32/false + 6702 0f 85/jump-if-!= loop/disp32 + 6703 # if (*word-slice->start == "#") continue + 6704 # . eax = *word-slice->start + 6705 8b/-> *edx 0/r32/eax + 6706 8a/copy-byte *eax 0/r32/AL + 6707 81 4/subop/and %eax 0xff/imm32 + 6708 # . if (eax == '#') continue + 6709 3d/compare-eax-and 0x23/imm32/hash + 6710 0f 84/jump-if-= loop/disp32 + 6711 # if (slice-equal?(word-slice, "fn")) parse a function + 6712 { + 6713 $parse-mu:fn: + 6714 (slice-equal? %edx "fn") # => eax + 6715 3d/compare-eax-and 0/imm32/false + 6716 0f 84/jump-if-= break/disp32 + 6717 # var new-function/esi: (handle function) + 6718 68/push 0/imm32 + 6719 68/push 0/imm32 + 6720 89/<- %esi 4/r32/esp + 6721 # populate-mu-function(line, in, vars, new-function) + 6722 (allocate Heap *Function-size %esi) + 6723 # var new-function-addr/eax: (addr function) + 6724 (lookup *esi *(esi+4)) # => eax + 6725 # initialize vars + 6726 (clear-stack %ebx) + 6727 # + 6728 (populate-mu-function-header %ecx %eax %ebx *(ebp+0xc) *(ebp+0x10)) + 6729 (populate-mu-function-body *(ebp+8) %eax %ebx *(ebp+0xc) *(ebp+0x10)) + 6730 # *curr-function = new-function + 6731 8b/-> *esi 0/r32/eax + 6732 89/<- *edi 0/r32/eax + 6733 8b/-> *(esi+4) 0/r32/eax + 6734 89/<- *(edi+4) 0/r32/eax + 6735 # curr-function = &new-function->next + 6736 # . var tmp/eax: (addr function) = lookup(new-function) + 6737 (lookup *esi *(esi+4)) # => eax + 6738 # . curr-function = &tmp->next + 6739 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next + 6740 # reclaim new-function + 6741 81 0/subop/add %esp 8/imm32 + 6742 # + 6743 e9/jump $parse-mu:line-loop/disp32 + 6744 } + 6745 # if (slice-equal?(word-slice, "sig")) parse a function signature + 6746 # Function signatures are for providing types to SubX functions. + 6747 { + 6748 $parse-mu:sig: + 6749 (slice-equal? %edx "sig") # => eax + 6750 3d/compare-eax-and 0/imm32/false + 6751 0f 84/jump-if-= break/disp32 + 6752 # edi = curr-function + 6753 57/push-edi + 6754 8b/-> *(ebp-4) 7/r32/edi + 6755 # var new-function/esi: (handle function) + 6756 68/push 0/imm32 + 6757 68/push 0/imm32 + 6758 89/<- %esi 4/r32/esp + 6759 # populate-mu-function(line, in, vars, new-function) + 6760 (allocate Heap *Function-size %esi) + 6761 # var new-function-addr/eax: (addr function) + 6762 (lookup *esi *(esi+4)) # => eax + 6763 # + 6764 (populate-mu-function-signature %ecx %eax *(ebp+0xc) *(ebp+0x10)) + 6765 # *curr-signature = new-function + 6766 8b/-> *esi 0/r32/eax + 6767 89/<- *edi 0/r32/eax + 6768 8b/-> *(esi+4) 0/r32/eax + 6769 89/<- *(edi+4) 0/r32/eax + 6770 # curr-signature = &new-function->next + 6771 # . var tmp/eax: (addr function) = lookup(new-function) + 6772 (lookup *esi *(esi+4)) # => eax + 6773 # . curr-function = &tmp->next + 6774 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next + 6775 # reclaim new-function + 6776 81 0/subop/add %esp 8/imm32 + 6777 # save curr-function + 6778 89/<- *(ebp-4) 7/r32/edi + 6779 # restore edi + 6780 5f/pop-to-edi + 6781 # + 6782 e9/jump $parse-mu:line-loop/disp32 + 6783 } + 6784 # if (slice-equal?(word-slice, "type")) parse a type (struct/record) definition + 6785 { + 6786 $parse-mu:type: + 6787 (slice-equal? %edx "type") # => eax + 6788 3d/compare-eax-and 0/imm32 + 6789 0f 84/jump-if-= break/disp32 + 6790 (next-mu-token %ecx %edx) + 6791 # var type-id/eax: int + 6792 (pos-or-insert-slice Type-id %edx) # => eax + 6793 # spill + 6794 51/push-ecx + 6795 # var new-type/ecx: (handle typeinfo) + 6796 68/push 0/imm32 + 6797 68/push 0/imm32 + 6798 89/<- %ecx 4/r32/esp + 6799 (find-or-create-typeinfo %eax %ecx) + 6800 # + 6801 (lookup *ecx *(ecx+4)) # => eax + 6802 # TODO: ensure that 'line' has nothing else but '{' + 6803 #? (dump-typeinfos "=== aaa\n") + 6804 (populate-mu-type *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) # => eax + 6805 #? (dump-typeinfos "=== zzz\n") + 6806 # reclaim new-type + 6807 81 0/subop/add %esp 8/imm32 + 6808 # restore + 6809 59/pop-to-ecx + 6810 e9/jump $parse-mu:line-loop/disp32 + 6811 } + 6812 # otherwise abort + 6813 e9/jump $parse-mu:error1/disp32 + 6814 } # end line loop + 6815 $parse-mu:end: + 6816 # . reclaim locals + 6817 81 0/subop/add %esp 0x20c/imm32 # line + 6818 81 0/subop/add %esp 0xc08/imm32 # vars + 6819 81 0/subop/add %esp 8/imm32 + 6820 # . restore registers + 6821 5f/pop-to-edi + 6822 5e/pop-to-esi + 6823 5b/pop-to-ebx + 6824 5a/pop-to-edx + 6825 59/pop-to-ecx + 6826 58/pop-to-eax + 6827 # . reclaim local + 6828 81 0/subop/add %esp 4/imm32 + 6829 # . epilogue + 6830 89/<- %esp 5/r32/ebp + 6831 5d/pop-to-ebp + 6832 c3/return + 6833 + 6834 $parse-mu:error1: + 6835 # error("unexpected top-level command: " word-slice "\n") + 6836 (write-buffered *(ebp+0xc) "unexpected top-level command: ") + 6837 (write-slice-buffered *(ebp+0xc) %edx) + 6838 (write-buffered *(ebp+0xc) "\n") + 6839 (flush *(ebp+0xc)) + 6840 (stop *(ebp+0x10) 1) + 6841 # never gets here + 6842 + 6843 $parse-mu:error2: + 6844 # error(vars->top " vars not reclaimed after fn '" new-function->name "'\n") + 6845 (write-int32-hex-buffered *(ebp+0xc) *ebx) + 6846 (write-buffered *(ebp+0xc) " vars not reclaimed after fn '") + 6847 (write-slice-buffered *(ebp+0xc) *eax) # Function-name + 6848 (write-buffered *(ebp+0xc) "'\n") + 6849 (flush *(ebp+0xc)) + 6850 (stop *(ebp+0x10) 1) + 6851 # never gets here + 6852 + 6853 # scenarios considered: + 6854 # ✗ fn foo # no block + 6855 # ✓ fn foo { + 6856 # ✗ fn foo { { + 6857 # ✗ fn foo { } + 6858 # ✗ fn foo { } { + 6859 # ✗ fn foo x { + 6860 # ✗ fn foo x: { + 6861 # ✓ fn foo x: int { + 6862 # ✓ fn foo x: int { + 6863 # ✓ fn foo x: int -> y/eax: int { + 6864 # TODO: + 6865 # disallow outputs of type `(... addr ...)` + 6866 # disallow inputs of type `(... addr ... addr ...)` + 6867 populate-mu-function-header: # first-line: (addr stream byte), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) + 6868 # pseudocode: + 6869 # var word-slice: slice + 6870 # next-mu-token(first-line, word-slice) + 6871 # assert(word-slice not in '{' '}' '->') + 6872 # out->name = slice-to-string(word-slice) + 6873 # ## inouts + 6874 # while true + 6875 # word-slice = next-mu-token(first-line) + 6876 # if (word-slice == '{') goto done + 6877 # if (word-slice == '->') break + 6878 # assert(word-slice != '}') + 6879 # var v: (handle var) = parse-var-with-type(word-slice, first-line) + 6880 # assert(v->register == null) + 6881 # # v->block-depth is implicitly 0 + 6882 # out->inouts = append(v, out->inouts) + 6883 # push(vars, {v, false}) + 6884 # ## outputs + 6885 # while true + 6886 # word-slice = next-mu-token(first-line) + 6887 # if (word-slice == '{') break + 6888 # assert(word-slice not in '}' '->') + 6889 # var v: (handle var) = parse-var-with-type(word-slice, first-line) + 6890 # assert(v->register != null) + 6891 # out->outputs = append(v, out->outputs) + 6892 # done: + 6893 # + 6894 # . prologue + 6895 55/push-ebp + 6896 89/<- %ebp 4/r32/esp + 6897 # . save registers + 6898 50/push-eax + 6899 51/push-ecx + 6900 52/push-edx + 6901 53/push-ebx + 6902 57/push-edi + 6903 # edi = out + 6904 8b/-> *(ebp+0xc) 7/r32/edi + 6905 # var word-slice/ecx: slice + 6906 68/push 0/imm32/end + 6907 68/push 0/imm32/start + 6908 89/<- %ecx 4/r32/esp + 6909 # var v/ebx: (handle var) + 6910 68/push 0/imm32 + 6911 68/push 0/imm32 + 6912 89/<- %ebx 4/r32/esp + 6913 # read function name + 6914 (next-mu-token *(ebp+8) %ecx) + 6915 # error checking + 6916 # if (word-slice == '{') abort + 6917 (slice-equal? %ecx "{") # => eax + 6918 3d/compare-eax-and 0/imm32/false + 6919 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6920 # if (word-slice == '->') abort + 6921 (slice-equal? %ecx "->") # => eax + 6922 3d/compare-eax-and 0/imm32/false + 6923 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6924 # if (word-slice == '}') abort + 6925 (slice-equal? %ecx "}") # => eax + 6926 3d/compare-eax-and 0/imm32/false + 6927 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6928 # save function name + 6929 (slice-to-string Heap %ecx %edi) # Function-name + 6930 # save function inouts + 6931 { + 6932 $populate-mu-function-header:check-for-inout: + 6933 (next-mu-token *(ebp+8) %ecx) + 6934 # if (word-slice == '{') goto done + 6935 (slice-equal? %ecx "{") # => eax + 6936 3d/compare-eax-and 0/imm32/false + 6937 0f 85/jump-if-!= $populate-mu-function-header:done/disp32 + 6938 # if (word-slice == '->') break + 6939 (slice-equal? %ecx "->") # => eax + 6940 3d/compare-eax-and 0/imm32/false + 6941 0f 85/jump-if-!= break/disp32 + 6942 # if (word-slice == '}') abort + 6943 (slice-equal? %ecx "}") # => eax + 6944 3d/compare-eax-and 0/imm32/false + 6945 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6946 # v = parse-var-with-type(word-slice, first-line) + 6947 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) + 6948 # assert(v->register == null) + 6949 # . eax: (addr var) = lookup(v) + 6950 (lookup *ebx *(ebx+4)) # => eax + 6951 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 6952 0f 85/jump-if-!= $populate-mu-function-header:error2/disp32 + 6953 # v->block-depth is implicitly 0 + 6954 # + 6955 # out->inouts = append(v, out->inouts) + 6956 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts + 6957 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts + 6958 # push(vars, {v, false}) + 6959 (push *(ebp+0x10) *ebx) + 6960 (push *(ebp+0x10) *(ebx+4)) + 6961 (push *(ebp+0x10) 0) # false + 6962 # + 6963 e9/jump loop/disp32 + 6964 } + 6965 # save function outputs + 6966 { + 6967 $populate-mu-function-header:check-for-out: + 6968 (next-mu-token *(ebp+8) %ecx) + 6969 # if (word-slice == '{') break + 6970 (slice-equal? %ecx "{") # => eax + 6971 3d/compare-eax-and 0/imm32/false + 6972 0f 85/jump-if-!= break/disp32 + 6973 # if (word-slice == '->') abort + 6974 (slice-equal? %ecx "->") # => eax + 6975 3d/compare-eax-and 0/imm32/false + 6976 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6977 # if (word-slice == '}') abort + 6978 (slice-equal? %ecx "}") # => eax + 6979 3d/compare-eax-and 0/imm32/false + 6980 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 + 6981 # v = parse-var-with-type(word-slice, first-line) + 6982 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) + 6983 # assert(var->register != null) + 6984 # . eax: (addr var) = lookup(v) + 6985 (lookup *ebx *(ebx+4)) # => eax + 6986 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 6987 0f 84/jump-if-= $populate-mu-function-header:error3/disp32 + 6988 # out->outputs = append(v, out->outputs) + 6989 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs + 6990 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs + 6991 # + 6992 e9/jump loop/disp32 + 6993 } + 6994 $populate-mu-function-header:done: + 6995 (check-no-tokens-left *(ebp+8)) + 6996 $populate-mu-function-header:end: + 6997 # . reclaim locals + 6998 81 0/subop/add %esp 0x10/imm32 + 6999 # . restore registers + 7000 5f/pop-to-edi + 7001 5b/pop-to-ebx + 7002 5a/pop-to-edx + 7003 59/pop-to-ecx + 7004 58/pop-to-eax + 7005 # . epilogue + 7006 89/<- %esp 5/r32/ebp + 7007 5d/pop-to-ebp + 7008 c3/return + 7009 + 7010 $populate-mu-function-header:error1: + 7011 # error("function header not in form 'fn <name> {'") + 7012 (write-buffered *(ebp+0x14) "function header not in form 'fn <name> [inouts] [-> outputs] {' -- '") + 7013 (flush *(ebp+0x14)) + 7014 (rewind-stream *(ebp+8)) + 7015 (write-stream-data *(ebp+0x14) *(ebp+8)) + 7016 (write-buffered *(ebp+0x14) "'\n") + 7017 (flush *(ebp+0x14)) + 7018 (stop *(ebp+0x18) 1) + 7019 # never gets here + 7020 + 7021 $populate-mu-function-header:error2: + 7022 # error("fn " fn ": function inout '" var "' cannot be in a register") + 7023 (write-buffered *(ebp+0x14) "fn ") + 7024 50/push-eax + 7025 (lookup *edi *(edi+4)) # Function-name Function-name => eax + 7026 (write-buffered *(ebp+0x14) %eax) + 7027 58/pop-to-eax + 7028 (write-buffered *(ebp+0x14) ": function inout '") + 7029 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 7030 (write-buffered *(ebp+0x10) %eax) + 7031 (write-buffered *(ebp+0x14) "' cannot be in a register") + 7032 (flush *(ebp+0x14)) + 7033 (stop *(ebp+0x18) 1) + 7034 # never gets here + 7035 + 7036 $populate-mu-function-header:error3: + 7037 # error("fn " fn ": function output '" var "' must be in a register") + 7038 (write-buffered *(ebp+0x14) "fn ") + 7039 50/push-eax + 7040 (lookup *edi *(edi+4)) # Function-name Function-name => eax + 7041 (write-buffered *(ebp+0x14) %eax) + 7042 58/pop-to-eax + 7043 (write-buffered *(ebp+0x14) ": function output '") + 7044 (lookup *ebx *(ebx+4)) # => eax + 7045 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 7046 (write-buffered *(ebp+0x14) %eax) + 7047 (write-buffered *(ebp+0x14) "' must be in a register, in instruction '") + 7048 (rewind-stream *(ebp+8)) + 7049 (write-stream-data *(ebp+0x14) *(ebp+8)) + 7050 (write-buffered *(ebp+0x14) "'\n") + 7051 (flush *(ebp+0x14)) + 7052 (stop *(ebp+0x18) 1) + 7053 # never gets here + 7054 + 7055 # scenarios considered: + 7056 # ✓ fn foo + 7057 # ✗ fn foo { + 7058 # ✓ fn foo x + 7059 # ✓ fn foo x: int + 7060 # ✓ fn foo x: int -> y/eax: int + 7061 # TODO: + 7062 # disallow outputs of type `(... addr ...)` + 7063 # disallow inputs of type `(... addr ... addr ...)` + 7064 populate-mu-function-signature: # first-line: (addr stream byte), out: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 7065 # pseudocode: + 7066 # var word-slice: slice + 7067 # next-mu-token(first-line, word-slice) + 7068 # assert(word-slice not in '{' '}' '->') + 7069 # out->name = slice-to-string(word-slice) + 7070 # ## inouts + 7071 # while true + 7072 # word-slice = next-mu-token(first-line) + 7073 # if slice-empty?(word-slice) break + 7074 # if (word-slice == '->') break + 7075 # assert(word-slice not in '{' '}') + 7076 # var v: (handle var) = parse-var-with-type(word-slice, first-line) + 7077 # assert(v->register == null) + 7078 # # v->block-depth is implicitly 0 + 7079 # out->inouts = append(v, out->inouts) + 7080 # ## outputs + 7081 # while true + 7082 # word-slice = next-mu-token(first-line) + 7083 # if slice-empty?(word-slice) break + 7084 # assert(word-slice not in '{' '}' '->') + 7085 # var v: (handle var) = parse-var-with-type(word-slice, first-line) + 7086 # assert(v->register != null) + 7087 # out->outputs = append(v, out->outputs) + 7088 # + 7089 # . prologue + 7090 55/push-ebp + 7091 89/<- %ebp 4/r32/esp + 7092 # . save registers + 7093 50/push-eax + 7094 51/push-ecx + 7095 52/push-edx + 7096 53/push-ebx + 7097 57/push-edi + 7098 # edi = out + 7099 8b/-> *(ebp+0xc) 7/r32/edi + 7100 # var word-slice/ecx: slice + 7101 68/push 0/imm32/end + 7102 68/push 0/imm32/start + 7103 89/<- %ecx 4/r32/esp + 7104 # var v/ebx: (handle var) + 7105 68/push 0/imm32 + 7106 68/push 0/imm32 + 7107 89/<- %ebx 4/r32/esp + 7108 # read function name + 7109 (next-mu-token *(ebp+8) %ecx) + 7110 # error checking + 7111 # if (word-slice == '{') abort + 7112 (slice-equal? %ecx "{") # => eax + 7113 3d/compare-eax-and 0/imm32/false + 7114 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7115 # if (word-slice == '->') abort + 7116 (slice-equal? %ecx "->") # => eax + 7117 3d/compare-eax-and 0/imm32/false + 7118 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7119 # if (word-slice == '}') abort + 7120 (slice-equal? %ecx "}") # => eax + 7121 3d/compare-eax-and 0/imm32/false + 7122 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7123 # save function name + 7124 (slice-to-string Heap %ecx %edi) # Function-name + 7125 # save function inouts + 7126 { + 7127 $populate-mu-function-signature:check-for-inout: + 7128 (next-mu-token *(ebp+8) %ecx) + 7129 (slice-empty? %ecx) # => eax + 7130 3d/compare-eax-and 0/imm32/false + 7131 0f 85/jump-if-!= break/disp32 + 7132 # if (word-slice == '->') break + 7133 (slice-equal? %ecx "->") # => eax + 7134 3d/compare-eax-and 0/imm32/false + 7135 0f 85/jump-if-!= break/disp32 + 7136 # if (word-slice == '{') abort + 7137 (slice-equal? %ecx "{") # => eax + 7138 3d/compare-eax-and 0/imm32/false + 7139 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7140 # if (word-slice == '}') abort + 7141 (slice-equal? %ecx "}") # => eax + 7142 3d/compare-eax-and 0/imm32/false + 7143 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7144 # v = parse-var-with-type(word-slice, first-line) + 7145 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) + 7146 # assert(v->register == null) + 7147 # . eax: (addr var) = lookup(v) + 7148 (lookup *ebx *(ebx+4)) # => eax + 7149 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 7150 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32 + 7151 # v->block-depth is implicitly 0 + 7152 # + 7153 # out->inouts = append(v, out->inouts) + 7154 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts + 7155 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts + 7156 # + 7157 e9/jump loop/disp32 + 7158 } + 7159 # save function outputs + 7160 { + 7161 $populate-mu-function-signature:check-for-out: + 7162 (next-mu-token *(ebp+8) %ecx) + 7163 (slice-empty? %ecx) # => eax + 7164 3d/compare-eax-and 0/imm32/false + 7165 0f 85/jump-if-!= break/disp32 + 7166 # if (word-slice == '{') abort + 7167 (slice-equal? %ecx "{") # => eax + 7168 3d/compare-eax-and 0/imm32/false + 7169 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7170 # if (word-slice == '->') abort + 7171 (slice-equal? %ecx "->") # => eax + 7172 3d/compare-eax-and 0/imm32/false + 7173 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7174 # if (word-slice == '}') abort + 7175 (slice-equal? %ecx "}") # => eax + 7176 3d/compare-eax-and 0/imm32/false + 7177 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 + 7178 # v = parse-var-with-type(word-slice, first-line) + 7179 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) + 7180 # assert(var->register != null) + 7181 # . eax: (addr var) = lookup(v) + 7182 (lookup *ebx *(ebx+4)) # => eax + 7183 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 7184 0f 84/jump-if-= $populate-mu-function-signature:error3/disp32 + 7185 # out->outputs = append(v, out->outputs) + 7186 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs + 7187 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs + 7188 # + 7189 e9/jump loop/disp32 + 7190 } + 7191 $populate-mu-function-signature:done: + 7192 (check-no-tokens-left *(ebp+8)) + 7193 $populate-mu-function-signature:end: + 7194 # . reclaim locals + 7195 81 0/subop/add %esp 0x10/imm32 + 7196 # . restore registers + 7197 5f/pop-to-edi + 7198 5b/pop-to-ebx + 7199 5a/pop-to-edx + 7200 59/pop-to-ecx + 7201 58/pop-to-eax + 7202 # . epilogue + 7203 89/<- %esp 5/r32/ebp + 7204 5d/pop-to-ebp + 7205 c3/return + 7206 + 7207 $populate-mu-function-signature:error1: + 7208 # error("function signature not in form 'fn <name> {'") + 7209 (write-buffered *(ebp+0x10) "function signature not in form 'fn <name> [inouts] [-> outputs] {' -- '") + 7210 (flush *(ebp+0x10)) + 7211 (rewind-stream *(ebp+8)) + 7212 (write-stream-data *(ebp+0x10) *(ebp+8)) + 7213 (write-buffered *(ebp+0x10) "'\n") + 7214 (flush *(ebp+0x10)) + 7215 (stop *(ebp+0x14) 1) + 7216 # never gets here + 7217 + 7218 $populate-mu-function-signature:error2: + 7219 # error("fn " fn ": function inout '" var "' cannot be in a register") + 7220 (write-buffered *(ebp+0x10) "fn ") + 7221 50/push-eax + 7222 (lookup *edi *(edi+4)) # Function-name Function-name => eax + 7223 (write-buffered *(ebp+0x10) %eax) + 7224 58/pop-to-eax + 7225 (write-buffered *(ebp+0x10) ": function inout '") + 7226 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 7227 (write-buffered *(ebp+0x10) %eax) + 7228 (write-buffered *(ebp+0x10) "' cannot be in a register") + 7229 (flush *(ebp+0x10)) + 7230 (stop *(ebp+0x14) 1) + 7231 # never gets here + 7232 + 7233 $populate-mu-function-signature:error3: + 7234 # error("fn " fn ": function output '" var "' must be in a register") + 7235 (write-buffered *(ebp+0x10) "fn ") + 7236 50/push-eax + 7237 (lookup *edi *(edi+4)) # Function-name Function-name => eax + 7238 (write-buffered *(ebp+0x10) %eax) + 7239 58/pop-to-eax + 7240 (write-buffered *(ebp+0x10) ": function output '") + 7241 (lookup *ebx *(ebx+4)) # => eax + 7242 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 7243 (write-buffered *(ebp+0x10) %eax) + 7244 (write-buffered *(ebp+0x10) "' must be in a register, in instruction '") + 7245 (rewind-stream *(ebp+8)) + 7246 (write-stream-data *(ebp+0x10) *(ebp+8)) + 7247 (write-buffered *(ebp+0x10) "'\n") + 7248 (flush *(ebp+0x10)) + 7249 (stop *(ebp+0x14) 1) + 7250 # never gets here + 7251 + 7252 test-function-header-with-arg: + 7253 # . prologue + 7254 55/push-ebp + 7255 89/<- %ebp 4/r32/esp + 7256 # setup + 7257 (clear-stream _test-input-stream) + 7258 (write _test-input-stream "foo n: int {\n") + 7259 # var result/ecx: function + 7260 2b/subtract *Function-size 4/r32/esp + 7261 89/<- %ecx 4/r32/esp + 7262 (zero-out %ecx *Function-size) + 7263 # var vars/ebx: (stack live-var 16) + 7264 81 5/subop/subtract %esp 0xc0/imm32 + 7265 68/push 0xc0/imm32/size + 7266 68/push 0/imm32/top + 7267 89/<- %ebx 4/r32/esp + 7268 # convert + 7269 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) + 7270 # check result->name + 7271 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax + 7272 (check-strings-equal %eax "foo" "F - test-function-header-with-arg/name") + 7273 # var v/edx: (addr var) = result->inouts->value + 7274 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax + 7275 (lookup *eax *(eax+4)) # List-value List-value => eax + 7276 89/<- %edx 0/r32/eax + 7277 # check v->name + 7278 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 7279 (check-strings-equal %eax "n" "F - test-function-header-with-arg/inout:0") + 7280 # check v->type + 7281 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 7282 (check-ints-equal *eax 1 "F - test-function-header-with-arg/inout:0/type:0") # Type-tree-is-atom + 7283 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-arg/inout:0/type:1") # Type-tree-value + 7284 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-arg/inout:0/type:2") # Type-tree-right + 7285 # . epilogue + 7286 89/<- %esp 5/r32/ebp + 7287 5d/pop-to-ebp + 7288 c3/return + 7289 + 7290 test-function-header-with-multiple-args: + 7291 # . prologue + 7292 55/push-ebp + 7293 89/<- %ebp 4/r32/esp + 7294 # setup + 7295 (clear-stream _test-input-stream) + 7296 (write _test-input-stream "foo a: int, b: int c: int {\n") + 7297 # result/ecx: function + 7298 2b/subtract *Function-size 4/r32/esp + 7299 89/<- %ecx 4/r32/esp + 7300 (zero-out %ecx *Function-size) + 7301 # var vars/ebx: (stack live-var 16) + 7302 81 5/subop/subtract %esp 0xc0/imm32 + 7303 68/push 0xc0/imm32/size + 7304 68/push 0/imm32/top + 7305 89/<- %ebx 4/r32/esp + 7306 # convert + 7307 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) + 7308 # check result->name + 7309 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax + 7310 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args/name") + 7311 # var inouts/edx: (addr list var) = lookup(result->inouts) + 7312 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax + 7313 89/<- %edx 0/r32/eax + 7314 $test-function-header-with-multiple-args:inout0: + 7315 # var v/ebx: (addr var) = lookup(inouts->value) + 7316 (lookup *edx *(edx+4)) # List-value List-value => eax + 7317 89/<- %ebx 0/r32/eax + 7318 # check v->name + 7319 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7320 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args/inout:0") # Var-name + 7321 # check v->type + 7322 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7323 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:0/type:0") # Type-tree-is-atom + 7324 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:0/type:1") # Type-tree-value + 7325 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:0/type:2") # Type-tree-right + 7326 $test-function-header-with-multiple-args:inout1: + 7327 # inouts = lookup(inouts->next) + 7328 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax + 7329 89/<- %edx 0/r32/eax + 7330 # v = lookup(inouts->value) + 7331 (lookup *edx *(edx+4)) # List-value List-value => eax + 7332 89/<- %ebx 0/r32/eax + 7333 # check v->name + 7334 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7335 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args/inout:1") # Var-name + 7336 # check v->type + 7337 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7338 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:1/type:0") # Type-tree-is-atom + 7339 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:1/type:1") # Type-tree-value + 7340 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:1/type:2") # Type-tree-right + 7341 $test-function-header-with-multiple-args:inout2: + 7342 # inouts = lookup(inouts->next) + 7343 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax + 7344 89/<- %edx 0/r32/eax + 7345 # v = lookup(inouts->value) + 7346 (lookup *edx *(edx+4)) # List-value List-value => eax + 7347 89/<- %ebx 0/r32/eax + 7348 # check v->name + 7349 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7350 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args/inout:2") # Var-name + 7351 # check v->type + 7352 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7353 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:2/type:0") # Type-tree-is-atom + 7354 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:2/type:1") # Type-tree-value + 7355 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:2/type:2") # Type-tree-right + 7356 # . epilogue + 7357 89/<- %esp 5/r32/ebp + 7358 5d/pop-to-ebp + 7359 c3/return + 7360 + 7361 test-function-header-with-multiple-args-and-outputs: + 7362 # . prologue + 7363 55/push-ebp + 7364 89/<- %ebp 4/r32/esp + 7365 # setup + 7366 (clear-stream _test-input-stream) + 7367 (write _test-input-stream "foo a: int, b: int, c: int -> x/ecx: int y/edx: int {\n") + 7368 # result/ecx: function + 7369 2b/subtract *Function-size 4/r32/esp + 7370 89/<- %ecx 4/r32/esp + 7371 (zero-out %ecx *Function-size) + 7372 # var vars/ebx: (stack live-var 16) + 7373 81 5/subop/subtract %esp 0xc0/imm32 + 7374 68/push 0xc0/imm32/size + 7375 68/push 0/imm32/top + 7376 89/<- %ebx 4/r32/esp + 7377 # convert + 7378 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) + 7379 # check result->name + 7380 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax + 7381 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args-and-outputs/name") + 7382 # var inouts/edx: (addr list var) = lookup(result->inouts) + 7383 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax + 7384 89/<- %edx 0/r32/eax + 7385 $test-function-header-with-multiple-args-and-outputs:inout0: + 7386 # var v/ebx: (addr var) = lookup(inouts->value) + 7387 (lookup *edx *(edx+4)) # List-value List-value => eax + 7388 89/<- %ebx 0/r32/eax + 7389 # check v->name + 7390 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7391 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args-and-outputs/inout:0") + 7392 # check v->type + 7393 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7394 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:0") # Type-tree-is-atom + 7395 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:1") # Type-tree-value + 7396 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:2") # Type-tree-right + 7397 $test-function-header-with-multiple-args-and-outputs:inout1: + 7398 # inouts = lookup(inouts->next) + 7399 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax + 7400 89/<- %edx 0/r32/eax + 7401 # v = lookup(inouts->value) + 7402 (lookup *edx *(edx+4)) # List-value List-value => eax + 7403 89/<- %ebx 0/r32/eax + 7404 # check v->name + 7405 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7406 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args-and-outputs/inout:1") + 7407 # check v->type + 7408 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7409 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:0") # Type-tree-is-atom + 7410 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:1") # Type-tree-value + 7411 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:2") # Type-tree-right + 7412 $test-function-header-with-multiple-args-and-outputs:inout2: + 7413 # inouts = lookup(inouts->next) + 7414 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax + 7415 89/<- %edx 0/r32/eax + 7416 # v = lookup(inouts->value) + 7417 (lookup *edx *(edx+4)) # List-value List-value => eax + 7418 89/<- %ebx 0/r32/eax + 7419 # check v->name + 7420 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7421 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args-and-outputs/inout:2") + 7422 # check v->type + 7423 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7424 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:0") # Type-tree-is-atom + 7425 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:1") # Type-tree-value + 7426 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:2") # Type-tree-right + 7427 $test-function-header-with-multiple-args-and-outputs:out0: + 7428 # var outputs/edx: (addr list var) = lookup(result->outputs) + 7429 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax + 7430 89/<- %edx 0/r32/eax + 7431 # v = lookup(outputs->value) + 7432 (lookup *edx *(edx+4)) # List-value List-value => eax + 7433 89/<- %ebx 0/r32/eax + 7434 # check v->name + 7435 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7436 (check-strings-equal %eax "x" "F - test-function-header-with-multiple-args-and-outputs/output:0") + 7437 # check v->register + 7438 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 7439 (check-strings-equal %eax "ecx" "F - test-function-header-with-multiple-args-and-outputs/output:0/register") + 7440 # check v->type + 7441 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7442 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:0") # Type-tree-is-atom + 7443 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:1") # Type-tree-value + 7444 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:2") # Type-tree-right + 7445 $test-function-header-with-multiple-args-and-outputs:out1: + 7446 # outputs = lookup(outputs->next) + 7447 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax + 7448 89/<- %edx 0/r32/eax + 7449 # v = lookup(inouts->value) + 7450 (lookup *edx *(edx+4)) # List-value List-value => eax + 7451 89/<- %ebx 0/r32/eax + 7452 # check v->name + 7453 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 7454 (check-strings-equal %eax "y" "F - test-function-header-with-multiple-args-and-outputs/output:1") + 7455 # check v->register + 7456 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 7457 (check-strings-equal %eax "edx" "F - test-function-header-with-multiple-args-and-outputs/output:1/register") + 7458 # check v->type + 7459 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax + 7460 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:0") # Type-tree-is-atom + 7461 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:1") # Type-tree-value + 7462 (check-ints-equal *(eax+0c) 0 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:2") # Type-tree-right + 7463 # . epilogue + 7464 89/<- %esp 5/r32/ebp + 7465 5d/pop-to-ebp + 7466 c3/return + 7467 + 7468 # format for variables with types + 7469 # x: int + 7470 # x: int, + 7471 # x/eax: int + 7472 # x/eax: int, + 7473 # ignores at most one trailing comma + 7474 # WARNING: modifies name + 7475 parse-var-with-type: # name: (addr slice), first-line: (addr stream byte), out: (addr handle var), err: (addr buffered-file), ed: (addr exit-descriptor) 7476 # pseudocode: - 7477 # var s: slice = next-mu-token(in) - 7478 # assert s != "" - 7479 # assert s != "->" - 7480 # assert s != "{" - 7481 # assert s != "}" - 7482 # if s == ")" - 7483 # return - 7484 # out = allocate(Type-tree) - 7485 # if s != "(" - 7486 # HACK: if s is an int, parse and return it - 7487 # out->is-atom? = true - 7488 # if (s[0] == "_") - 7489 # out->value = type-parameter - 7490 # out->parameter-name = slice-to-string(ad, s) - 7491 # else - 7492 # out->value = pos-or-insert-slice(Type-id, s) - 7493 # return - 7494 # out->left = parse-type(ad, in) - 7495 # out->right = parse-type-tree(ad, in) - 7496 # - 7497 # . prologue - 7498 55/push-ebp - 7499 89/<- %ebp 4/r32/esp - 7500 # . save registers - 7501 50/push-eax - 7502 51/push-ecx - 7503 52/push-edx - 7504 # clear out - 7505 (zero-out *(ebp+0x10) *Handle-size) - 7506 # var s/ecx: slice - 7507 68/push 0/imm32 - 7508 68/push 0/imm32 - 7509 89/<- %ecx 4/r32/esp - 7510 # s = next-mu-token(in) - 7511 (next-mu-token *(ebp+0xc) %ecx) - 7512 #? (write-buffered Stderr "tok: ") - 7513 #? (write-slice-buffered Stderr %ecx) - 7514 #? (write-buffered Stderr "$\n") - 7515 #? (flush Stderr) - 7516 # assert s != "" - 7517 (slice-equal? %ecx "") # => eax - 7518 3d/compare-eax-and 0/imm32/false - 7519 0f 85/jump-if-!= $parse-type:abort/disp32 - 7520 # assert s != "{" - 7521 (slice-equal? %ecx "{") # => eax - 7522 3d/compare-eax-and 0/imm32/false - 7523 0f 85/jump-if-!= $parse-type:abort/disp32 - 7524 # assert s != "}" - 7525 (slice-equal? %ecx "}") # => eax - 7526 3d/compare-eax-and 0/imm32/false - 7527 0f 85/jump-if-!= $parse-type:abort/disp32 - 7528 # assert s != "->" - 7529 (slice-equal? %ecx "->") # => eax - 7530 3d/compare-eax-and 0/imm32/false - 7531 0f 85/jump-if-!= $parse-type:abort/disp32 - 7532 # if (s == ")") return - 7533 (slice-equal? %ecx ")") # => eax - 7534 3d/compare-eax-and 0/imm32/false - 7535 0f 85/jump-if-!= $parse-type:end/disp32 - 7536 # out = new tree - 7537 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) - 7538 # var out-addr/edx: (addr type-tree) = lookup(*out) - 7539 8b/-> *(ebp+0x10) 2/r32/edx - 7540 (lookup *edx *(edx+4)) # => eax - 7541 89/<- %edx 0/r32/eax - 7542 { - 7543 # if (s != "(") break - 7544 (slice-equal? %ecx "(") # => eax - 7545 3d/compare-eax-and 0/imm32/false - 7546 0f 85/jump-if-!= break/disp32 - 7547 # if s is a number, store it in the type's size field - 7548 { - 7549 $parse-type:check-for-int: - 7550 # var tmp/eax: byte = *s->slice - 7551 8b/-> *ecx 0/r32/eax - 7552 8a/copy-byte *eax 0/r32/AL - 7553 81 4/subop/and %eax 0xff/imm32 - 7554 # TODO: raise an error on `var x: (array int a)` - 7555 (is-decimal-digit? %eax) # => eax - 7556 3d/compare-eax-and 0/imm32/false - 7557 74/jump-if-= break/disp8 - 7558 # - 7559 (is-hex-int? %ecx) # => eax - 7560 3d/compare-eax-and 0/imm32/false - 7561 74/jump-if-= break/disp8 - 7562 $parse-type:int: - 7563 (check-mu-hex-int %ecx *(ebp+0x14) *(ebp+0x18)) - 7564 (parse-hex-int-from-slice %ecx) # => eax - 7565 c7 0/subop/copy *(edx+4) 9/imm32/type-id-array-capacity # Type-tree-value - 7566 89/<- *(edx+8) 0/r32/eax # Type-tree-value-size - 7567 e9/jump $parse-type:end/disp32 - 7568 } - 7569 $parse-type:atom: - 7570 # out->is-atom? = true - 7571 c7 0/subop/copy *edx 1/imm32/true # Type-tree-is-atom - 7572 { - 7573 $parse-type:check-for-type-parameter: - 7574 # var tmp/eax: byte = *s->slice - 7575 8b/-> *ecx 0/r32/eax - 7576 8a/copy-byte *eax 0/r32/AL - 7577 81 4/subop/and %eax 0xff/imm32 - 7578 # if (tmp != '_') break - 7579 3d/compare-eax-and 0x5f/imm32/_ - 7580 75/jump-if-!= break/disp8 - 7581 $parse-type:type-parameter: - 7582 # out->value = type-parameter - 7583 c7 0/subop/copy *(edx+4) 0xa/imm32/type-parameter # Type-tree-value - 7584 # out->parameter-name = slice-to-string(ad, s) - 7585 8d/copy-address *(edx+8) 0/r32/eax # Type-tree-parameter-name - 7586 (slice-to-string *(ebp+8) %ecx %eax) - 7587 e9/jump $parse-type:end/disp32 - 7588 } - 7589 $parse-type:non-type-parameter: - 7590 # out->value = pos-or-insert-slice(Type-id, s) - 7591 (pos-or-insert-slice Type-id %ecx) # => eax - 7592 89/<- *(edx+4) 0/r32/eax # Type-tree-value - 7593 e9/jump $parse-type:end/disp32 - 7594 } - 7595 $parse-type:non-atom: - 7596 # otherwise s == "(" - 7597 # out->left = parse-type(ad, in) - 7598 8d/copy-address *(edx+4) 0/r32/eax # Type-tree-left - 7599 (parse-type *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) - 7600 # out->right = parse-type-tree(ad, in) - 7601 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right - 7602 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) - 7603 $parse-type:end: - 7604 # . reclaim locals - 7605 81 0/subop/add %esp 8/imm32 - 7606 # . restore registers - 7607 5a/pop-to-edx - 7608 59/pop-to-ecx - 7609 58/pop-to-eax - 7610 # . epilogue - 7611 89/<- %esp 5/r32/ebp - 7612 5d/pop-to-ebp - 7613 c3/return - 7614 - 7615 $parse-type:abort: - 7616 # error("unexpected token when parsing type: '" s "'\n") - 7617 (write-buffered *(ebp+0x14) "unexpected token when parsing type: '") - 7618 (write-slice-buffered *(ebp+0x14) %ecx) - 7619 (write-buffered *(ebp+0x14) "'\n") - 7620 (flush *(ebp+0x14)) - 7621 (stop *(ebp+0x18) 1) - 7622 # never gets here - 7623 - 7624 parse-type-tree: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) - 7625 # pseudocode: - 7626 # var tmp: (handle type-tree) = parse-type(ad, in) - 7627 # if tmp == 0 - 7628 # return 0 - 7629 # out = allocate(Type-tree) - 7630 # out->left = tmp - 7631 # out->right = parse-type-tree(ad, in) - 7632 # - 7633 # . prologue - 7634 55/push-ebp - 7635 89/<- %ebp 4/r32/esp - 7636 # . save registers - 7637 50/push-eax - 7638 51/push-ecx - 7639 52/push-edx - 7640 # - 7641 (zero-out *(ebp+0x10) *Handle-size) - 7642 # var tmp/ecx: (handle type-tree) - 7643 68/push 0/imm32 - 7644 68/push 0/imm32 - 7645 89/<- %ecx 4/r32/esp - 7646 # tmp = parse-type(ad, in) - 7647 (parse-type *(ebp+8) *(ebp+0xc) %ecx *(ebp+0x14) *(ebp+0x18)) - 7648 # if (tmp == 0) return - 7649 81 7/subop/compare *ecx 0/imm32 - 7650 74/jump-if-= $parse-type-tree:end/disp8 - 7651 # out = new tree - 7652 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) - 7653 # var out-addr/edx: (addr tree) = lookup(*out) - 7654 8b/-> *(ebp+0x10) 2/r32/edx - 7655 (lookup *edx *(edx+4)) # => eax - 7656 89/<- %edx 0/r32/eax - 7657 # out->left = tmp - 7658 8b/-> *ecx 0/r32/eax - 7659 89/<- *(edx+4) 0/r32/eax # Type-tree-left - 7660 8b/-> *(ecx+4) 0/r32/eax - 7661 89/<- *(edx+8) 0/r32/eax # Type-tree-left - 7662 # out->right = parse-type-tree(ad, in) - 7663 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right - 7664 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) - 7665 $parse-type-tree:end: - 7666 # . reclaim locals - 7667 81 0/subop/add %esp 8/imm32 - 7668 # . restore registers - 7669 5a/pop-to-edx - 7670 59/pop-to-ecx - 7671 58/pop-to-eax - 7672 # . epilogue - 7673 89/<- %esp 5/r32/ebp - 7674 5d/pop-to-ebp - 7675 c3/return - 7676 - 7677 next-mu-token: # in: (addr stream byte), out: (addr slice) - 7678 # pseudocode: - 7679 # start: - 7680 # skip-chars-matching-whitespace(in) - 7681 # if in->read >= in->write # end of in - 7682 # out = {0, 0} - 7683 # return - 7684 # out->start = &in->data[in->read] - 7685 # var curr-byte/eax: byte = in->data[in->read] - 7686 # if curr->byte == ',' # comment token - 7687 # ++in->read - 7688 # goto start - 7689 # if curr-byte == '#' # comment - 7690 # goto done # treat as eof - 7691 # if curr-byte == '"' # string literal - 7692 # skip-string(in) - 7693 # goto done # no metadata - 7694 # if curr-byte == '(' - 7695 # ++in->read - 7696 # goto done - 7697 # if curr-byte == ')' - 7698 # ++in->read - 7699 # goto done - 7700 # # read a word - 7701 # while true - 7702 # if in->read >= in->write - 7703 # break - 7704 # curr-byte = in->data[in->read] - 7705 # if curr-byte == ' ' - 7706 # break - 7707 # if curr-byte == '\r' - 7708 # break - 7709 # if curr-byte == '\n' - 7710 # break - 7711 # if curr-byte == '(' - 7712 # break - 7713 # if curr-byte == ')' - 7714 # break - 7715 # if curr-byte == ',' - 7716 # break - 7717 # ++in->read - 7718 # done: - 7719 # out->end = &in->data[in->read] - 7720 # - 7721 # . prologue - 7722 55/push-ebp - 7723 89/<- %ebp 4/r32/esp - 7724 # . save registers - 7725 50/push-eax - 7726 51/push-ecx - 7727 56/push-esi - 7728 57/push-edi - 7729 # esi = in - 7730 8b/-> *(ebp+8) 6/r32/esi - 7731 # edi = out - 7732 8b/-> *(ebp+0xc) 7/r32/edi - 7733 $next-mu-token:start: - 7734 (skip-chars-matching-whitespace %esi) - 7735 $next-mu-token:check0: - 7736 # if (in->read >= in->write) return out = {0, 0} - 7737 # . ecx = in->read - 7738 8b/-> *(esi+4) 1/r32/ecx - 7739 # . if (ecx >= in->write) return out = {0, 0} - 7740 3b/compare<- *esi 1/r32/ecx - 7741 c7 0/subop/copy *edi 0/imm32 - 7742 c7 0/subop/copy *(edi+4) 0/imm32 - 7743 0f 8d/jump-if->= $next-mu-token:end/disp32 - 7744 # out->start = &in->data[in->read] - 7745 8d/copy-address *(esi+ecx+0xc) 0/r32/eax - 7746 89/<- *edi 0/r32/eax - 7747 # var curr-byte/eax: byte = in->data[in->read] - 7748 31/xor-with %eax 0/r32/eax - 7749 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 7750 { - 7751 $next-mu-token:check-for-comma: - 7752 # if (curr-byte != ',') break - 7753 3d/compare-eax-and 0x2c/imm32/comma - 7754 75/jump-if-!= break/disp8 - 7755 # ++in->read - 7756 ff 0/subop/increment *(esi+4) - 7757 # restart - 7758 e9/jump $next-mu-token:start/disp32 - 7759 } - 7760 { - 7761 $next-mu-token:check-for-comment: - 7762 # if (curr-byte != '#') break - 7763 3d/compare-eax-and 0x23/imm32/pound - 7764 75/jump-if-!= break/disp8 - 7765 # return eof - 7766 e9/jump $next-mu-token:done/disp32 - 7767 } - 7768 { - 7769 $next-mu-token:check-for-string-literal: - 7770 # if (curr-byte != '"') break - 7771 3d/compare-eax-and 0x22/imm32/dquote - 7772 75/jump-if-!= break/disp8 - 7773 (skip-string %esi) - 7774 # return - 7775 e9/jump $next-mu-token:done/disp32 - 7776 } - 7777 { - 7778 $next-mu-token:check-for-open-paren: - 7779 # if (curr-byte != '(') break - 7780 3d/compare-eax-and 0x28/imm32/open-paren - 7781 75/jump-if-!= break/disp8 - 7782 # ++in->read - 7783 ff 0/subop/increment *(esi+4) - 7784 # return - 7785 e9/jump $next-mu-token:done/disp32 - 7786 } - 7787 { - 7788 $next-mu-token:check-for-close-paren: - 7789 # if (curr-byte != ')') break - 7790 3d/compare-eax-and 0x29/imm32/close-paren - 7791 75/jump-if-!= break/disp8 - 7792 # ++in->read - 7793 ff 0/subop/increment *(esi+4) - 7794 # return - 7795 e9/jump $next-mu-token:done/disp32 - 7796 } - 7797 { - 7798 $next-mu-token:regular-word-without-metadata: - 7799 # if (in->read >= in->write) break - 7800 # . ecx = in->read - 7801 8b/-> *(esi+4) 1/r32/ecx - 7802 # . if (ecx >= in->write) break - 7803 3b/compare<- *esi 1/r32/ecx - 7804 7d/jump-if->= break/disp8 - 7805 # var c/eax: byte = in->data[in->read] - 7806 31/xor-with %eax 0/r32/eax - 7807 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 7808 # if (c == ' ') break - 7809 3d/compare-eax-and 0x20/imm32/space - 7810 74/jump-if-= break/disp8 - 7811 # if (c == '\r') break - 7812 3d/compare-eax-and 0xd/imm32/carriage-return - 7813 74/jump-if-= break/disp8 - 7814 # if (c == '\n') break - 7815 3d/compare-eax-and 0xa/imm32/newline - 7816 74/jump-if-= break/disp8 - 7817 # if (c == '(') break - 7818 3d/compare-eax-and 0x28/imm32/open-paren - 7819 0f 84/jump-if-= break/disp32 - 7820 # if (c == ')') break - 7821 3d/compare-eax-and 0x29/imm32/close-paren - 7822 0f 84/jump-if-= break/disp32 - 7823 # if (c == ',') break - 7824 3d/compare-eax-and 0x2c/imm32/comma - 7825 0f 84/jump-if-= break/disp32 - 7826 # ++in->read - 7827 ff 0/subop/increment *(esi+4) - 7828 # - 7829 e9/jump loop/disp32 - 7830 } - 7831 $next-mu-token:done: - 7832 # out->end = &in->data[in->read] - 7833 8b/-> *(esi+4) 1/r32/ecx - 7834 8d/copy-address *(esi+ecx+0xc) 0/r32/eax - 7835 89/<- *(edi+4) 0/r32/eax - 7836 $next-mu-token:end: - 7837 # . restore registers - 7838 5f/pop-to-edi - 7839 5e/pop-to-esi - 7840 59/pop-to-ecx - 7841 58/pop-to-eax - 7842 # . epilogue - 7843 89/<- %esp 5/r32/ebp - 7844 5d/pop-to-ebp - 7845 c3/return - 7846 - 7847 pos-or-insert-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int - 7848 # . prologue - 7849 55/push-ebp - 7850 89/<- %ebp 4/r32/esp - 7851 # if (pos-slice(arr, s) != -1) return it - 7852 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax - 7853 3d/compare-eax-and -1/imm32 - 7854 75/jump-if-!= $pos-or-insert-slice:end/disp8 - 7855 $pos-or-insert-slice:insert: - 7856 # var s2/eax: (handle array byte) - 7857 68/push 0/imm32 - 7858 68/push 0/imm32 - 7859 89/<- %eax 4/r32/esp - 7860 (slice-to-string Heap *(ebp+0xc) %eax) - 7861 # throw away alloc-id - 7862 (lookup *eax *(eax+4)) # => eax - 7863 (write-int *(ebp+8) %eax) - 7864 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax - 7865 $pos-or-insert-slice:end: - 7866 # . reclaim locals - 7867 81 0/subop/add %esp 8/imm32 - 7868 # . epilogue - 7869 89/<- %esp 5/r32/ebp - 7870 5d/pop-to-ebp - 7871 c3/return - 7872 - 7873 # return the index in an array of strings matching 's', -1 if not found - 7874 # index is denominated in elements, not bytes - 7875 pos-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int - 7876 # . prologue - 7877 55/push-ebp - 7878 89/<- %ebp 4/r32/esp - 7879 # . save registers - 7880 51/push-ecx - 7881 52/push-edx - 7882 53/push-ebx - 7883 56/push-esi - 7884 #? (write-buffered Stderr "pos-slice: ") - 7885 #? (write-slice-buffered Stderr *(ebp+0xc)) - 7886 #? (write-buffered Stderr "\n") - 7887 #? (flush Stderr) - 7888 # esi = arr - 7889 8b/-> *(ebp+8) 6/r32/esi - 7890 # var index/ecx: int = 0 - 7891 b9/copy-to-ecx 0/imm32 - 7892 # var curr/edx: (addr (addr array byte)) = arr->data - 7893 8d/copy-address *(esi+0xc) 2/r32/edx - 7894 # var max/ebx: (addr (addr array byte)) = &arr->data[arr->write] - 7895 8b/-> *esi 3/r32/ebx - 7896 8d/copy-address *(esi+ebx+0xc) 3/r32/ebx - 7897 { - 7898 #? (write-buffered Stderr " ") - 7899 #? (write-int32-hex-buffered Stderr %ecx) - 7900 #? (write-buffered Stderr "\n") - 7901 #? (flush Stderr) - 7902 # if (curr >= max) return -1 - 7903 39/compare %edx 3/r32/ebx - 7904 b8/copy-to-eax -1/imm32 - 7905 73/jump-if-addr>= $pos-slice:end/disp8 - 7906 # if (slice-equal?(s, *curr)) break - 7907 (slice-equal? *(ebp+0xc) *edx) # => eax - 7908 3d/compare-eax-and 0/imm32/false - 7909 75/jump-if-!= break/disp8 - 7910 # ++index - 7911 41/increment-ecx - 7912 # curr += 4 - 7913 81 0/subop/add %edx 4/imm32 - 7914 # - 7915 eb/jump loop/disp8 - 7916 } - 7917 # return index - 7918 89/<- %eax 1/r32/ecx - 7919 $pos-slice:end: - 7920 #? (write-buffered Stderr "=> ") - 7921 #? (write-int32-hex-buffered Stderr %eax) - 7922 #? (write-buffered Stderr "\n") - 7923 # . restore registers - 7924 5e/pop-to-esi - 7925 5b/pop-to-ebx - 7926 5a/pop-to-edx - 7927 59/pop-to-ecx - 7928 # . epilogue - 7929 89/<- %esp 5/r32/ebp - 7930 5d/pop-to-ebp - 7931 c3/return - 7932 - 7933 test-parse-var-with-type: - 7934 # . prologue - 7935 55/push-ebp - 7936 89/<- %ebp 4/r32/esp - 7937 # (eax..ecx) = "x:" - 7938 b8/copy-to-eax "x:"/imm32 - 7939 8b/-> *eax 1/r32/ecx - 7940 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 7941 05/add-to-eax 4/imm32 - 7942 # var slice/ecx: slice = {eax, ecx} - 7943 51/push-ecx - 7944 50/push-eax - 7945 89/<- %ecx 4/r32/esp - 7946 # _test-input-stream contains "int" - 7947 (clear-stream _test-input-stream) - 7948 (write _test-input-stream "int") - 7949 # var v/edx: (handle var) + 7477 # var s: slice + 7478 # if (!slice-ends-with(name, ":")) + 7479 # abort + 7480 # --name->end to skip ':' + 7481 # next-token-from-slice(name->start, name->end, '/', s) + 7482 # new-var-from-slice(s, out) + 7483 # ## register + 7484 # next-token-from-slice(s->end, name->end, '/', s) + 7485 # if (!slice-empty?(s)) + 7486 # out->register = slice-to-string(s) + 7487 # ## type + 7488 # var type: (handle type-tree) = parse-type(first-line) + 7489 # out->type = type + 7490 # + 7491 # . prologue + 7492 55/push-ebp + 7493 89/<- %ebp 4/r32/esp + 7494 # . save registers + 7495 50/push-eax + 7496 51/push-ecx + 7497 52/push-edx + 7498 53/push-ebx + 7499 56/push-esi + 7500 57/push-edi + 7501 # esi = name + 7502 8b/-> *(ebp+8) 6/r32/esi + 7503 # if (!slice-ends-with?(name, ":")) abort + 7504 8b/-> *(esi+4) 1/r32/ecx # Slice-end + 7505 49/decrement-ecx + 7506 8a/copy-byte *ecx 1/r32/CL + 7507 81 4/subop/and %ecx 0xff/imm32 + 7508 81 7/subop/compare %ecx 0x3a/imm32/colon + 7509 0f 85/jump-if-!= $parse-var-with-type:abort/disp32 + 7510 # --name->end to skip ':' + 7511 ff 1/subop/decrement *(esi+4) + 7512 # var s/ecx: slice + 7513 68/push 0/imm32/end + 7514 68/push 0/imm32/start + 7515 89/<- %ecx 4/r32/esp + 7516 $parse-var-with-type:parse-name: + 7517 (next-token-from-slice *esi *(esi+4) 0x2f %ecx) # Slice-start, Slice-end, '/' + 7518 $parse-var-with-type:create-var: + 7519 # new-var-from-slice(s, out) + 7520 (new-var-from-slice Heap %ecx *(ebp+0x10)) + 7521 # save out->register + 7522 $parse-var-with-type:save-register: + 7523 # . var out-addr/edi: (addr var) = lookup(*out) + 7524 8b/-> *(ebp+0x10) 7/r32/edi + 7525 (lookup *edi *(edi+4)) # => eax + 7526 89/<- %edi 0/r32/eax + 7527 # . s = next-token(...) + 7528 (next-token-from-slice *(ecx+4) *(esi+4) 0x2f %ecx) # s->end, name->end, '/' + 7529 # . if (!slice-empty?(s)) out->register = slice-to-string(s) + 7530 { + 7531 $parse-var-with-type:write-register: + 7532 (slice-empty? %ecx) # => eax + 7533 3d/compare-eax-and 0/imm32/false + 7534 75/jump-if-!= break/disp8 + 7535 # out->register = slice-to-string(s) + 7536 8d/copy-address *(edi+0x18) 0/r32/eax # Var-register + 7537 (slice-to-string Heap %ecx %eax) + 7538 } + 7539 $parse-var-with-type:save-type: + 7540 8d/copy-address *(edi+8) 0/r32/eax # Var-type + 7541 (parse-type Heap *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) + 7542 $parse-var-with-type:end: + 7543 # . reclaim locals + 7544 81 0/subop/add %esp 8/imm32 + 7545 # . restore registers + 7546 5f/pop-to-edi + 7547 5e/pop-to-esi + 7548 5b/pop-to-ebx + 7549 5a/pop-to-edx + 7550 59/pop-to-ecx + 7551 58/pop-to-eax + 7552 # . epilogue + 7553 89/<- %esp 5/r32/ebp + 7554 5d/pop-to-ebp + 7555 c3/return + 7556 + 7557 $parse-var-with-type:abort: + 7558 # error("var should have form 'name: type' in '" line "'\n") + 7559 (write-buffered *(ebp+0x14) "var should have form 'name: type' in '") + 7560 (flush *(ebp+0x14)) + 7561 (rewind-stream *(ebp+0xc)) + 7562 (write-stream-data *(ebp+0x14) *(ebp+0xc)) + 7563 (write-buffered *(ebp+0x14) "'\n") + 7564 (flush *(ebp+0x14)) + 7565 (stop *(ebp+0x18) 1) + 7566 # never gets here + 7567 + 7568 parse-type: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) + 7569 # pseudocode: + 7570 # var s: slice = next-mu-token(in) + 7571 # assert s != "" + 7572 # assert s != "->" + 7573 # assert s != "{" + 7574 # assert s != "}" + 7575 # if s == ")" + 7576 # return + 7577 # out = allocate(Type-tree) + 7578 # if s != "(" + 7579 # HACK: if s is an int, parse and return it + 7580 # out->is-atom? = true + 7581 # if (s[0] == "_") + 7582 # out->value = type-parameter + 7583 # out->parameter-name = slice-to-string(ad, s) + 7584 # else + 7585 # out->value = pos-or-insert-slice(Type-id, s) + 7586 # return + 7587 # out->left = parse-type(ad, in) + 7588 # out->right = parse-type-tree(ad, in) + 7589 # + 7590 # . prologue + 7591 55/push-ebp + 7592 89/<- %ebp 4/r32/esp + 7593 # . save registers + 7594 50/push-eax + 7595 51/push-ecx + 7596 52/push-edx + 7597 # clear out + 7598 (zero-out *(ebp+0x10) *Handle-size) + 7599 # var s/ecx: slice + 7600 68/push 0/imm32 + 7601 68/push 0/imm32 + 7602 89/<- %ecx 4/r32/esp + 7603 # s = next-mu-token(in) + 7604 (next-mu-token *(ebp+0xc) %ecx) + 7605 #? (write-buffered Stderr "tok: ") + 7606 #? (write-slice-buffered Stderr %ecx) + 7607 #? (write-buffered Stderr "$\n") + 7608 #? (flush Stderr) + 7609 # assert s != "" + 7610 (slice-equal? %ecx "") # => eax + 7611 3d/compare-eax-and 0/imm32/false + 7612 0f 85/jump-if-!= $parse-type:abort/disp32 + 7613 # assert s != "{" + 7614 (slice-equal? %ecx "{") # => eax + 7615 3d/compare-eax-and 0/imm32/false + 7616 0f 85/jump-if-!= $parse-type:abort/disp32 + 7617 # assert s != "}" + 7618 (slice-equal? %ecx "}") # => eax + 7619 3d/compare-eax-and 0/imm32/false + 7620 0f 85/jump-if-!= $parse-type:abort/disp32 + 7621 # assert s != "->" + 7622 (slice-equal? %ecx "->") # => eax + 7623 3d/compare-eax-and 0/imm32/false + 7624 0f 85/jump-if-!= $parse-type:abort/disp32 + 7625 # if (s == ")") return + 7626 (slice-equal? %ecx ")") # => eax + 7627 3d/compare-eax-and 0/imm32/false + 7628 0f 85/jump-if-!= $parse-type:end/disp32 + 7629 # out = new tree + 7630 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) + 7631 # var out-addr/edx: (addr type-tree) = lookup(*out) + 7632 8b/-> *(ebp+0x10) 2/r32/edx + 7633 (lookup *edx *(edx+4)) # => eax + 7634 89/<- %edx 0/r32/eax + 7635 { + 7636 # if (s != "(") break + 7637 (slice-equal? %ecx "(") # => eax + 7638 3d/compare-eax-and 0/imm32/false + 7639 0f 85/jump-if-!= break/disp32 + 7640 # if s is a number, store it in the type's size field + 7641 { + 7642 $parse-type:check-for-int: + 7643 # var tmp/eax: byte = *s->slice + 7644 8b/-> *ecx 0/r32/eax + 7645 8a/copy-byte *eax 0/r32/AL + 7646 81 4/subop/and %eax 0xff/imm32 + 7647 # TODO: raise an error on `var x: (array int a)` + 7648 (is-decimal-digit? %eax) # => eax + 7649 3d/compare-eax-and 0/imm32/false + 7650 74/jump-if-= break/disp8 + 7651 # + 7652 (is-hex-int? %ecx) # => eax + 7653 3d/compare-eax-and 0/imm32/false + 7654 74/jump-if-= break/disp8 + 7655 $parse-type:int: + 7656 (check-mu-hex-int %ecx *(ebp+0x14) *(ebp+0x18)) + 7657 (parse-hex-int-from-slice %ecx) # => eax + 7658 c7 0/subop/copy *(edx+4) 9/imm32/type-id-array-capacity # Type-tree-value + 7659 89/<- *(edx+8) 0/r32/eax # Type-tree-value-size + 7660 e9/jump $parse-type:end/disp32 + 7661 } + 7662 $parse-type:atom: + 7663 # out->is-atom? = true + 7664 c7 0/subop/copy *edx 1/imm32/true # Type-tree-is-atom + 7665 { + 7666 $parse-type:check-for-type-parameter: + 7667 # var tmp/eax: byte = *s->slice + 7668 8b/-> *ecx 0/r32/eax + 7669 8a/copy-byte *eax 0/r32/AL + 7670 81 4/subop/and %eax 0xff/imm32 + 7671 # if (tmp != '_') break + 7672 3d/compare-eax-and 0x5f/imm32/_ + 7673 75/jump-if-!= break/disp8 + 7674 $parse-type:type-parameter: + 7675 # out->value = type-parameter + 7676 c7 0/subop/copy *(edx+4) 0xa/imm32/type-parameter # Type-tree-value + 7677 # out->parameter-name = slice-to-string(ad, s) + 7678 8d/copy-address *(edx+8) 0/r32/eax # Type-tree-parameter-name + 7679 (slice-to-string *(ebp+8) %ecx %eax) + 7680 e9/jump $parse-type:end/disp32 + 7681 } + 7682 $parse-type:non-type-parameter: + 7683 # out->value = pos-or-insert-slice(Type-id, s) + 7684 (pos-or-insert-slice Type-id %ecx) # => eax + 7685 89/<- *(edx+4) 0/r32/eax # Type-tree-value + 7686 e9/jump $parse-type:end/disp32 + 7687 } + 7688 $parse-type:non-atom: + 7689 # otherwise s == "(" + 7690 # out->left = parse-type(ad, in) + 7691 8d/copy-address *(edx+4) 0/r32/eax # Type-tree-left + 7692 (parse-type *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) + 7693 # out->right = parse-type-tree(ad, in) + 7694 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right + 7695 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) + 7696 $parse-type:end: + 7697 # . reclaim locals + 7698 81 0/subop/add %esp 8/imm32 + 7699 # . restore registers + 7700 5a/pop-to-edx + 7701 59/pop-to-ecx + 7702 58/pop-to-eax + 7703 # . epilogue + 7704 89/<- %esp 5/r32/ebp + 7705 5d/pop-to-ebp + 7706 c3/return + 7707 + 7708 $parse-type:abort: + 7709 # error("unexpected token when parsing type: '" s "'\n") + 7710 (write-buffered *(ebp+0x14) "unexpected token when parsing type: '") + 7711 (write-slice-buffered *(ebp+0x14) %ecx) + 7712 (write-buffered *(ebp+0x14) "'\n") + 7713 (flush *(ebp+0x14)) + 7714 (stop *(ebp+0x18) 1) + 7715 # never gets here + 7716 + 7717 parse-type-tree: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) + 7718 # pseudocode: + 7719 # var tmp: (handle type-tree) = parse-type(ad, in) + 7720 # if tmp == 0 + 7721 # return 0 + 7722 # out = allocate(Type-tree) + 7723 # out->left = tmp + 7724 # out->right = parse-type-tree(ad, in) + 7725 # + 7726 # . prologue + 7727 55/push-ebp + 7728 89/<- %ebp 4/r32/esp + 7729 # . save registers + 7730 50/push-eax + 7731 51/push-ecx + 7732 52/push-edx + 7733 # + 7734 (zero-out *(ebp+0x10) *Handle-size) + 7735 # var tmp/ecx: (handle type-tree) + 7736 68/push 0/imm32 + 7737 68/push 0/imm32 + 7738 89/<- %ecx 4/r32/esp + 7739 # tmp = parse-type(ad, in) + 7740 (parse-type *(ebp+8) *(ebp+0xc) %ecx *(ebp+0x14) *(ebp+0x18)) + 7741 # if (tmp == 0) return + 7742 81 7/subop/compare *ecx 0/imm32 + 7743 74/jump-if-= $parse-type-tree:end/disp8 + 7744 # out = new tree + 7745 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) + 7746 # var out-addr/edx: (addr tree) = lookup(*out) + 7747 8b/-> *(ebp+0x10) 2/r32/edx + 7748 (lookup *edx *(edx+4)) # => eax + 7749 89/<- %edx 0/r32/eax + 7750 # out->left = tmp + 7751 8b/-> *ecx 0/r32/eax + 7752 89/<- *(edx+4) 0/r32/eax # Type-tree-left + 7753 8b/-> *(ecx+4) 0/r32/eax + 7754 89/<- *(edx+8) 0/r32/eax # Type-tree-left + 7755 # out->right = parse-type-tree(ad, in) + 7756 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right + 7757 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) + 7758 $parse-type-tree:end: + 7759 # . reclaim locals + 7760 81 0/subop/add %esp 8/imm32 + 7761 # . restore registers + 7762 5a/pop-to-edx + 7763 59/pop-to-ecx + 7764 58/pop-to-eax + 7765 # . epilogue + 7766 89/<- %esp 5/r32/ebp + 7767 5d/pop-to-ebp + 7768 c3/return + 7769 + 7770 next-mu-token: # in: (addr stream byte), out: (addr slice) + 7771 # pseudocode: + 7772 # start: + 7773 # skip-chars-matching-whitespace(in) + 7774 # if in->read >= in->write # end of in + 7775 # out = {0, 0} + 7776 # return + 7777 # out->start = &in->data[in->read] + 7778 # var curr-byte/eax: byte = in->data[in->read] + 7779 # if curr->byte == ',' # comment token + 7780 # ++in->read + 7781 # goto start + 7782 # if curr-byte == '#' # comment + 7783 # goto done # treat as eof + 7784 # if curr-byte == '"' # string literal + 7785 # skip-string(in) + 7786 # goto done # no metadata + 7787 # if curr-byte == '(' + 7788 # ++in->read + 7789 # goto done + 7790 # if curr-byte == ')' + 7791 # ++in->read + 7792 # goto done + 7793 # # read a word + 7794 # while true + 7795 # if in->read >= in->write + 7796 # break + 7797 # curr-byte = in->data[in->read] + 7798 # if curr-byte == ' ' + 7799 # break + 7800 # if curr-byte == '\r' + 7801 # break + 7802 # if curr-byte == '\n' + 7803 # break + 7804 # if curr-byte == '(' + 7805 # break + 7806 # if curr-byte == ')' + 7807 # break + 7808 # if curr-byte == ',' + 7809 # break + 7810 # ++in->read + 7811 # done: + 7812 # out->end = &in->data[in->read] + 7813 # + 7814 # . prologue + 7815 55/push-ebp + 7816 89/<- %ebp 4/r32/esp + 7817 # . save registers + 7818 50/push-eax + 7819 51/push-ecx + 7820 56/push-esi + 7821 57/push-edi + 7822 # esi = in + 7823 8b/-> *(ebp+8) 6/r32/esi + 7824 # edi = out + 7825 8b/-> *(ebp+0xc) 7/r32/edi + 7826 $next-mu-token:start: + 7827 (skip-chars-matching-whitespace %esi) + 7828 $next-mu-token:check0: + 7829 # if (in->read >= in->write) return out = {0, 0} + 7830 # . ecx = in->read + 7831 8b/-> *(esi+4) 1/r32/ecx + 7832 # . if (ecx >= in->write) return out = {0, 0} + 7833 3b/compare<- *esi 1/r32/ecx + 7834 c7 0/subop/copy *edi 0/imm32 + 7835 c7 0/subop/copy *(edi+4) 0/imm32 + 7836 0f 8d/jump-if->= $next-mu-token:end/disp32 + 7837 # out->start = &in->data[in->read] + 7838 8d/copy-address *(esi+ecx+0xc) 0/r32/eax + 7839 89/<- *edi 0/r32/eax + 7840 # var curr-byte/eax: byte = in->data[in->read] + 7841 31/xor-with %eax 0/r32/eax + 7842 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 7843 { + 7844 $next-mu-token:check-for-comma: + 7845 # if (curr-byte != ',') break + 7846 3d/compare-eax-and 0x2c/imm32/comma + 7847 75/jump-if-!= break/disp8 + 7848 # ++in->read + 7849 ff 0/subop/increment *(esi+4) + 7850 # restart + 7851 e9/jump $next-mu-token:start/disp32 + 7852 } + 7853 { + 7854 $next-mu-token:check-for-comment: + 7855 # if (curr-byte != '#') break + 7856 3d/compare-eax-and 0x23/imm32/pound + 7857 75/jump-if-!= break/disp8 + 7858 # return eof + 7859 e9/jump $next-mu-token:done/disp32 + 7860 } + 7861 { + 7862 $next-mu-token:check-for-string-literal: + 7863 # if (curr-byte != '"') break + 7864 3d/compare-eax-and 0x22/imm32/dquote + 7865 75/jump-if-!= break/disp8 + 7866 (skip-string %esi) + 7867 # return + 7868 e9/jump $next-mu-token:done/disp32 + 7869 } + 7870 { + 7871 $next-mu-token:check-for-open-paren: + 7872 # if (curr-byte != '(') break + 7873 3d/compare-eax-and 0x28/imm32/open-paren + 7874 75/jump-if-!= break/disp8 + 7875 # ++in->read + 7876 ff 0/subop/increment *(esi+4) + 7877 # return + 7878 e9/jump $next-mu-token:done/disp32 + 7879 } + 7880 { + 7881 $next-mu-token:check-for-close-paren: + 7882 # if (curr-byte != ')') break + 7883 3d/compare-eax-and 0x29/imm32/close-paren + 7884 75/jump-if-!= break/disp8 + 7885 # ++in->read + 7886 ff 0/subop/increment *(esi+4) + 7887 # return + 7888 e9/jump $next-mu-token:done/disp32 + 7889 } + 7890 { + 7891 $next-mu-token:regular-word-without-metadata: + 7892 # if (in->read >= in->write) break + 7893 # . ecx = in->read + 7894 8b/-> *(esi+4) 1/r32/ecx + 7895 # . if (ecx >= in->write) break + 7896 3b/compare<- *esi 1/r32/ecx + 7897 7d/jump-if->= break/disp8 + 7898 # var c/eax: byte = in->data[in->read] + 7899 31/xor-with %eax 0/r32/eax + 7900 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 7901 # if (c == ' ') break + 7902 3d/compare-eax-and 0x20/imm32/space + 7903 74/jump-if-= break/disp8 + 7904 # if (c == '\r') break + 7905 3d/compare-eax-and 0xd/imm32/carriage-return + 7906 74/jump-if-= break/disp8 + 7907 # if (c == '\n') break + 7908 3d/compare-eax-and 0xa/imm32/newline + 7909 74/jump-if-= break/disp8 + 7910 # if (c == '(') break + 7911 3d/compare-eax-and 0x28/imm32/open-paren + 7912 0f 84/jump-if-= break/disp32 + 7913 # if (c == ')') break + 7914 3d/compare-eax-and 0x29/imm32/close-paren + 7915 0f 84/jump-if-= break/disp32 + 7916 # if (c == ',') break + 7917 3d/compare-eax-and 0x2c/imm32/comma + 7918 0f 84/jump-if-= break/disp32 + 7919 # ++in->read + 7920 ff 0/subop/increment *(esi+4) + 7921 # + 7922 e9/jump loop/disp32 + 7923 } + 7924 $next-mu-token:done: + 7925 # out->end = &in->data[in->read] + 7926 8b/-> *(esi+4) 1/r32/ecx + 7927 8d/copy-address *(esi+ecx+0xc) 0/r32/eax + 7928 89/<- *(edi+4) 0/r32/eax + 7929 $next-mu-token:end: + 7930 # . restore registers + 7931 5f/pop-to-edi + 7932 5e/pop-to-esi + 7933 59/pop-to-ecx + 7934 58/pop-to-eax + 7935 # . epilogue + 7936 89/<- %esp 5/r32/ebp + 7937 5d/pop-to-ebp + 7938 c3/return + 7939 + 7940 pos-or-insert-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int + 7941 # . prologue + 7942 55/push-ebp + 7943 89/<- %ebp 4/r32/esp + 7944 # if (pos-slice(arr, s) != -1) return it + 7945 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax + 7946 3d/compare-eax-and -1/imm32 + 7947 75/jump-if-!= $pos-or-insert-slice:end/disp8 + 7948 $pos-or-insert-slice:insert: + 7949 # var s2/eax: (handle array byte) 7950 68/push 0/imm32 7951 68/push 0/imm32 - 7952 89/<- %edx 4/r32/esp - 7953 # - 7954 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) - 7955 # var v-addr/edx: (addr var) = lookup(v) - 7956 (lookup *edx *(edx+4)) # => eax - 7957 89/<- %edx 0/r32/eax - 7958 # check v-addr->name - 7959 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 7960 (check-strings-equal %eax "x" "F - test-parse-var-with-type/name") - 7961 # check v-addr->type - 7962 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 7963 (check-ints-equal *eax 1 "F - test-parse-var-with-type/type:0") # Type-tree-is-atom - 7964 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type/type:1") # Type-tree-value - 7965 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type/type:2") # Type-tree-right - 7966 # . epilogue - 7967 89/<- %esp 5/r32/ebp - 7968 5d/pop-to-ebp - 7969 c3/return - 7970 - 7971 test-parse-var-with-type-and-register: - 7972 # . prologue - 7973 55/push-ebp - 7974 89/<- %ebp 4/r32/esp - 7975 # (eax..ecx) = "x/eax:" - 7976 b8/copy-to-eax "x/eax:"/imm32 - 7977 8b/-> *eax 1/r32/ecx - 7978 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 7979 05/add-to-eax 4/imm32 - 7980 # var slice/ecx: slice = {eax, ecx} - 7981 51/push-ecx - 7982 50/push-eax - 7983 89/<- %ecx 4/r32/esp - 7984 # _test-input-stream contains "int" - 7985 (clear-stream _test-input-stream) - 7986 (write _test-input-stream "int") - 7987 # var v/edx: (handle var) - 7988 68/push 0/imm32 - 7989 68/push 0/imm32 - 7990 89/<- %edx 4/r32/esp - 7991 # - 7992 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) - 7993 # var v-addr/edx: (addr var) = lookup(v) - 7994 (lookup *edx *(edx+4)) # => eax - 7995 89/<- %edx 0/r32/eax - 7996 # check v-addr->name - 7997 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 7998 (check-strings-equal %eax "x" "F - test-parse-var-with-type-and-register/name") - 7999 # check v-addr->register - 8000 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 8001 (check-strings-equal %eax "eax" "F - test-parse-var-with-type-and-register/register") - 8002 # check v-addr->type - 8003 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 8004 (check-ints-equal *eax 1 "F - test-parse-var-with-type-and-register/type:0") # Type-tree-is-atom - 8005 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type-and-register/type:1") # Type-tree-left - 8006 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type-and-register/type:2") # Type-tree-right - 8007 # . epilogue - 8008 89/<- %esp 5/r32/ebp - 8009 5d/pop-to-ebp - 8010 c3/return - 8011 - 8012 test-parse-var-with-trailing-characters: - 8013 # . prologue - 8014 55/push-ebp - 8015 89/<- %ebp 4/r32/esp - 8016 # (eax..ecx) = "x:" - 8017 b8/copy-to-eax "x:"/imm32 - 8018 8b/-> *eax 1/r32/ecx - 8019 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8020 05/add-to-eax 4/imm32 - 8021 # var slice/ecx: slice = {eax, ecx} - 8022 51/push-ecx - 8023 50/push-eax - 8024 89/<- %ecx 4/r32/esp - 8025 # _test-input-stream contains "int," - 8026 (clear-stream _test-input-stream) - 8027 (write _test-input-stream "int,") - 8028 # var v/edx: (handle var) - 8029 68/push 0/imm32 - 8030 68/push 0/imm32 - 8031 89/<- %edx 4/r32/esp - 8032 # - 8033 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) - 8034 # var v-addr/edx: (addr var) = lookup(v) - 8035 (lookup *edx *(edx+4)) # => eax - 8036 89/<- %edx 0/r32/eax - 8037 # check v-addr->name - 8038 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 8039 (check-strings-equal %eax "x" "F - test-parse-var-with-trailing-characters/name") - 8040 # check v-addr->register - 8041 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-trailing-characters/register") # Var-register - 8042 # check v-addr->type - 8043 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 8044 (check-ints-equal *eax 1 "F - test-parse-var-with-trailing-characters/type:0") # Type-tree-is-atom - 8045 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-left - 8046 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-right - 8047 # . epilogue - 8048 89/<- %esp 5/r32/ebp - 8049 5d/pop-to-ebp - 8050 c3/return - 8051 - 8052 test-parse-var-with-register-and-trailing-characters: - 8053 # . prologue - 8054 55/push-ebp - 8055 89/<- %ebp 4/r32/esp - 8056 # (eax..ecx) = "x/eax:" - 8057 b8/copy-to-eax "x/eax:"/imm32 - 8058 8b/-> *eax 1/r32/ecx - 8059 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8060 05/add-to-eax 4/imm32 - 8061 # var slice/ecx: slice = {eax, ecx} - 8062 51/push-ecx - 8063 50/push-eax - 8064 89/<- %ecx 4/r32/esp - 8065 # _test-input-stream contains "int," - 8066 (clear-stream _test-input-stream) - 8067 (write _test-input-stream "int,") - 8068 # var v/edx: (handle var) - 8069 68/push 0/imm32 - 8070 68/push 0/imm32 - 8071 89/<- %edx 4/r32/esp - 8072 # - 8073 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) - 8074 # var v-addr/edx: (addr var) = lookup(v) - 8075 (lookup *edx *(edx+4)) # => eax - 8076 89/<- %edx 0/r32/eax - 8077 # check v-addr->name - 8078 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 8079 (check-strings-equal %eax "x" "F - test-parse-var-with-register-and-trailing-characters/name") - 8080 # check v-addr->register - 8081 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 8082 (check-strings-equal %eax "eax" "F - test-parse-var-with-register-and-trailing-characters/register") - 8083 # check v-addr->type - 8084 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 8085 (check-ints-equal *eax 1 "F - test-parse-var-with-register-and-trailing-characters/type:0") # Type-tree-is-atom - 8086 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-register-and-trailing-characters/type:1") # Type-tree-left - 8087 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-register-and-trailing-characters/type:2") # Type-tree-right - 8088 # . epilogue - 8089 89/<- %esp 5/r32/ebp - 8090 5d/pop-to-ebp - 8091 c3/return - 8092 - 8093 test-parse-var-with-compound-type: - 8094 # . prologue - 8095 55/push-ebp - 8096 89/<- %ebp 4/r32/esp - 8097 # (eax..ecx) = "x:" - 8098 b8/copy-to-eax "x:"/imm32 - 8099 8b/-> *eax 1/r32/ecx - 8100 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8101 05/add-to-eax 4/imm32 - 8102 # var slice/ecx: slice = {eax, ecx} - 8103 51/push-ecx - 8104 50/push-eax - 8105 89/<- %ecx 4/r32/esp - 8106 # _test-input-stream contains "(addr int)" - 8107 (clear-stream _test-input-stream) - 8108 (write _test-input-stream "(addr int)") - 8109 # var v/edx: (handle var) - 8110 68/push 0/imm32 - 8111 68/push 0/imm32 - 8112 89/<- %edx 4/r32/esp - 8113 # - 8114 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) - 8115 # var v-addr/edx: (addr var) = lookup(v) - 8116 (lookup *edx *(edx+4)) # => eax - 8117 89/<- %edx 0/r32/eax - 8118 # check v-addr->name - 8119 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 8120 (check-strings-equal %eax "x" "F - test-parse-var-with-compound-type/name") - 8121 # check v-addr->register - 8122 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-compound-type/register") # Var-register - 8123 # - check v-addr->type - 8124 # var type/edx: (addr type-tree) = var->type - 8125 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 8126 89/<- %edx 0/r32/eax - 8127 # type is a non-atom - 8128 (check-ints-equal *edx 0 "F - test-parse-var-with-compound-type/type:0") # Type-tree-is-atom - 8129 # type->left == atom(addr) - 8130 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax - 8131 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:1") # Type-tree-is-atom - 8132 (check-ints-equal *(eax+4) 2 "F - test-parse-var-with-compound-type/type:2") # Type-tree-value - 8133 # type->right->left == atom(int) - 8134 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax - 8135 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax - 8136 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:3") # Type-tree-is-atom - 8137 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-compound-type/type:4") # Type-tree-value - 8138 # type->right->right == null - 8139 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-compound-type/type:5") # Type-tree-right + 7952 89/<- %eax 4/r32/esp + 7953 (slice-to-string Heap *(ebp+0xc) %eax) + 7954 # throw away alloc-id + 7955 (lookup *eax *(eax+4)) # => eax + 7956 (write-int *(ebp+8) %eax) + 7957 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax + 7958 $pos-or-insert-slice:end: + 7959 # . reclaim locals + 7960 81 0/subop/add %esp 8/imm32 + 7961 # . epilogue + 7962 89/<- %esp 5/r32/ebp + 7963 5d/pop-to-ebp + 7964 c3/return + 7965 + 7966 # return the index in an array of strings matching 's', -1 if not found + 7967 # index is denominated in elements, not bytes + 7968 pos-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int + 7969 # . prologue + 7970 55/push-ebp + 7971 89/<- %ebp 4/r32/esp + 7972 # . save registers + 7973 51/push-ecx + 7974 52/push-edx + 7975 53/push-ebx + 7976 56/push-esi + 7977 #? (write-buffered Stderr "pos-slice: ") + 7978 #? (write-slice-buffered Stderr *(ebp+0xc)) + 7979 #? (write-buffered Stderr "\n") + 7980 #? (flush Stderr) + 7981 # esi = arr + 7982 8b/-> *(ebp+8) 6/r32/esi + 7983 # var index/ecx: int = 0 + 7984 b9/copy-to-ecx 0/imm32 + 7985 # var curr/edx: (addr (addr array byte)) = arr->data + 7986 8d/copy-address *(esi+0xc) 2/r32/edx + 7987 # var max/ebx: (addr (addr array byte)) = &arr->data[arr->write] + 7988 8b/-> *esi 3/r32/ebx + 7989 8d/copy-address *(esi+ebx+0xc) 3/r32/ebx + 7990 { + 7991 #? (write-buffered Stderr " ") + 7992 #? (write-int32-hex-buffered Stderr %ecx) + 7993 #? (write-buffered Stderr "\n") + 7994 #? (flush Stderr) + 7995 # if (curr >= max) return -1 + 7996 39/compare %edx 3/r32/ebx + 7997 b8/copy-to-eax -1/imm32 + 7998 73/jump-if-addr>= $pos-slice:end/disp8 + 7999 # if (slice-equal?(s, *curr)) break + 8000 (slice-equal? *(ebp+0xc) *edx) # => eax + 8001 3d/compare-eax-and 0/imm32/false + 8002 75/jump-if-!= break/disp8 + 8003 # ++index + 8004 41/increment-ecx + 8005 # curr += 4 + 8006 81 0/subop/add %edx 4/imm32 + 8007 # + 8008 eb/jump loop/disp8 + 8009 } + 8010 # return index + 8011 89/<- %eax 1/r32/ecx + 8012 $pos-slice:end: + 8013 #? (write-buffered Stderr "=> ") + 8014 #? (write-int32-hex-buffered Stderr %eax) + 8015 #? (write-buffered Stderr "\n") + 8016 # . restore registers + 8017 5e/pop-to-esi + 8018 5b/pop-to-ebx + 8019 5a/pop-to-edx + 8020 59/pop-to-ecx + 8021 # . epilogue + 8022 89/<- %esp 5/r32/ebp + 8023 5d/pop-to-ebp + 8024 c3/return + 8025 + 8026 test-parse-var-with-type: + 8027 # . prologue + 8028 55/push-ebp + 8029 89/<- %ebp 4/r32/esp + 8030 # (eax..ecx) = "x:" + 8031 b8/copy-to-eax "x:"/imm32 + 8032 8b/-> *eax 1/r32/ecx + 8033 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8034 05/add-to-eax 4/imm32 + 8035 # var slice/ecx: slice = {eax, ecx} + 8036 51/push-ecx + 8037 50/push-eax + 8038 89/<- %ecx 4/r32/esp + 8039 # _test-input-stream contains "int" + 8040 (clear-stream _test-input-stream) + 8041 (write _test-input-stream "int") + 8042 # var v/edx: (handle var) + 8043 68/push 0/imm32 + 8044 68/push 0/imm32 + 8045 89/<- %edx 4/r32/esp + 8046 # + 8047 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) + 8048 # var v-addr/edx: (addr var) = lookup(v) + 8049 (lookup *edx *(edx+4)) # => eax + 8050 89/<- %edx 0/r32/eax + 8051 # check v-addr->name + 8052 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 8053 (check-strings-equal %eax "x" "F - test-parse-var-with-type/name") + 8054 # check v-addr->type + 8055 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 8056 (check-ints-equal *eax 1 "F - test-parse-var-with-type/type:0") # Type-tree-is-atom + 8057 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type/type:1") # Type-tree-value + 8058 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type/type:2") # Type-tree-right + 8059 # . epilogue + 8060 89/<- %esp 5/r32/ebp + 8061 5d/pop-to-ebp + 8062 c3/return + 8063 + 8064 test-parse-var-with-type-and-register: + 8065 # . prologue + 8066 55/push-ebp + 8067 89/<- %ebp 4/r32/esp + 8068 # (eax..ecx) = "x/eax:" + 8069 b8/copy-to-eax "x/eax:"/imm32 + 8070 8b/-> *eax 1/r32/ecx + 8071 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8072 05/add-to-eax 4/imm32 + 8073 # var slice/ecx: slice = {eax, ecx} + 8074 51/push-ecx + 8075 50/push-eax + 8076 89/<- %ecx 4/r32/esp + 8077 # _test-input-stream contains "int" + 8078 (clear-stream _test-input-stream) + 8079 (write _test-input-stream "int") + 8080 # var v/edx: (handle var) + 8081 68/push 0/imm32 + 8082 68/push 0/imm32 + 8083 89/<- %edx 4/r32/esp + 8084 # + 8085 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) + 8086 # var v-addr/edx: (addr var) = lookup(v) + 8087 (lookup *edx *(edx+4)) # => eax + 8088 89/<- %edx 0/r32/eax + 8089 # check v-addr->name + 8090 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 8091 (check-strings-equal %eax "x" "F - test-parse-var-with-type-and-register/name") + 8092 # check v-addr->register + 8093 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 8094 (check-strings-equal %eax "eax" "F - test-parse-var-with-type-and-register/register") + 8095 # check v-addr->type + 8096 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 8097 (check-ints-equal *eax 1 "F - test-parse-var-with-type-and-register/type:0") # Type-tree-is-atom + 8098 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type-and-register/type:1") # Type-tree-left + 8099 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type-and-register/type:2") # Type-tree-right + 8100 # . epilogue + 8101 89/<- %esp 5/r32/ebp + 8102 5d/pop-to-ebp + 8103 c3/return + 8104 + 8105 test-parse-var-with-trailing-characters: + 8106 # . prologue + 8107 55/push-ebp + 8108 89/<- %ebp 4/r32/esp + 8109 # (eax..ecx) = "x:" + 8110 b8/copy-to-eax "x:"/imm32 + 8111 8b/-> *eax 1/r32/ecx + 8112 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8113 05/add-to-eax 4/imm32 + 8114 # var slice/ecx: slice = {eax, ecx} + 8115 51/push-ecx + 8116 50/push-eax + 8117 89/<- %ecx 4/r32/esp + 8118 # _test-input-stream contains "int," + 8119 (clear-stream _test-input-stream) + 8120 (write _test-input-stream "int,") + 8121 # var v/edx: (handle var) + 8122 68/push 0/imm32 + 8123 68/push 0/imm32 + 8124 89/<- %edx 4/r32/esp + 8125 # + 8126 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) + 8127 # var v-addr/edx: (addr var) = lookup(v) + 8128 (lookup *edx *(edx+4)) # => eax + 8129 89/<- %edx 0/r32/eax + 8130 # check v-addr->name + 8131 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 8132 (check-strings-equal %eax "x" "F - test-parse-var-with-trailing-characters/name") + 8133 # check v-addr->register + 8134 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-trailing-characters/register") # Var-register + 8135 # check v-addr->type + 8136 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 8137 (check-ints-equal *eax 1 "F - test-parse-var-with-trailing-characters/type:0") # Type-tree-is-atom + 8138 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-left + 8139 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-right 8140 # . epilogue 8141 89/<- %esp 5/r32/ebp 8142 5d/pop-to-ebp 8143 c3/return 8144 - 8145 # identifier starts with a letter or '$' or '_' - 8146 # no constraints at the moment on later letters - 8147 # all we really want to do so far is exclude '{', '}' and '->' - 8148 is-identifier?: # in: (addr slice) -> result/eax: boolean - 8149 # . prologue - 8150 55/push-ebp - 8151 89/<- %ebp 4/r32/esp - 8152 # if (slice-empty?(in)) return false - 8153 (slice-empty? *(ebp+8)) # => eax - 8154 3d/compare-eax-and 0/imm32/false - 8155 75/jump-if-!= $is-identifier?:false/disp8 - 8156 # var c/eax: byte = *in->start - 8157 8b/-> *(ebp+8) 0/r32/eax - 8158 8b/-> *eax 0/r32/eax - 8159 8a/copy-byte *eax 0/r32/AL - 8160 81 4/subop/and %eax 0xff/imm32 - 8161 # if (c == '$') return true - 8162 3d/compare-eax-and 0x24/imm32/$ - 8163 74/jump-if-= $is-identifier?:true/disp8 - 8164 # if (c == '_') return true - 8165 3d/compare-eax-and 0x5f/imm32/_ - 8166 74/jump-if-= $is-identifier?:true/disp8 - 8167 # drop case - 8168 25/and-eax-with 0x5f/imm32 - 8169 # if (c < 'A') return false - 8170 3d/compare-eax-and 0x41/imm32/A - 8171 7c/jump-if-< $is-identifier?:false/disp8 - 8172 # if (c > 'Z') return false - 8173 3d/compare-eax-and 0x5a/imm32/Z - 8174 7f/jump-if-> $is-identifier?:false/disp8 - 8175 # otherwise return true - 8176 $is-identifier?:true: - 8177 b8/copy-to-eax 1/imm32/true - 8178 eb/jump $is-identifier?:end/disp8 - 8179 $is-identifier?:false: - 8180 b8/copy-to-eax 0/imm32/false - 8181 $is-identifier?:end: - 8182 # . epilogue - 8183 89/<- %esp 5/r32/ebp - 8184 5d/pop-to-ebp - 8185 c3/return - 8186 - 8187 test-is-identifier-dollar: - 8188 # . prologue - 8189 55/push-ebp - 8190 89/<- %ebp 4/r32/esp - 8191 # (eax..ecx) = "$a" - 8192 b8/copy-to-eax "$a"/imm32 - 8193 8b/-> *eax 1/r32/ecx - 8194 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8195 05/add-to-eax 4/imm32 - 8196 # var slice/ecx: slice = {eax, ecx} - 8197 51/push-ecx - 8198 50/push-eax - 8199 89/<- %ecx 4/r32/esp - 8200 # - 8201 (is-identifier? %ecx) - 8202 (check-ints-equal %eax 1 "F - test-is-identifier-dollar") - 8203 # . epilogue - 8204 89/<- %esp 5/r32/ebp - 8205 5d/pop-to-ebp - 8206 c3/return - 8207 - 8208 test-is-identifier-underscore: - 8209 # . prologue - 8210 55/push-ebp - 8211 89/<- %ebp 4/r32/esp - 8212 # (eax..ecx) = "_a" - 8213 b8/copy-to-eax "_a"/imm32 - 8214 8b/-> *eax 1/r32/ecx - 8215 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8216 05/add-to-eax 4/imm32 - 8217 # var slice/ecx: slice = {eax, ecx} - 8218 51/push-ecx - 8219 50/push-eax - 8220 89/<- %ecx 4/r32/esp - 8221 # - 8222 (is-identifier? %ecx) - 8223 (check-ints-equal %eax 1 "F - test-is-identifier-underscore") - 8224 # . epilogue - 8225 89/<- %esp 5/r32/ebp - 8226 5d/pop-to-ebp - 8227 c3/return - 8228 - 8229 test-is-identifier-a: - 8230 # . prologue - 8231 55/push-ebp - 8232 89/<- %ebp 4/r32/esp - 8233 # (eax..ecx) = "a$" - 8234 b8/copy-to-eax "a$"/imm32 - 8235 8b/-> *eax 1/r32/ecx - 8236 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8237 05/add-to-eax 4/imm32 - 8238 # var slice/ecx: slice = {eax, ecx} - 8239 51/push-ecx - 8240 50/push-eax - 8241 89/<- %ecx 4/r32/esp - 8242 # - 8243 (is-identifier? %ecx) - 8244 (check-ints-equal %eax 1 "F - test-is-identifier-a") - 8245 # . epilogue - 8246 89/<- %esp 5/r32/ebp - 8247 5d/pop-to-ebp - 8248 c3/return - 8249 - 8250 test-is-identifier-z: - 8251 # . prologue - 8252 55/push-ebp - 8253 89/<- %ebp 4/r32/esp - 8254 # (eax..ecx) = "z$" - 8255 b8/copy-to-eax "z$"/imm32 - 8256 8b/-> *eax 1/r32/ecx - 8257 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8258 05/add-to-eax 4/imm32 - 8259 # var slice/ecx: slice = {eax, ecx} - 8260 51/push-ecx - 8261 50/push-eax - 8262 89/<- %ecx 4/r32/esp - 8263 # - 8264 (is-identifier? %ecx) - 8265 (check-ints-equal %eax 1 "F - test-is-identifier-z") - 8266 # . epilogue - 8267 89/<- %esp 5/r32/ebp - 8268 5d/pop-to-ebp - 8269 c3/return - 8270 - 8271 test-is-identifier-A: - 8272 # . prologue - 8273 55/push-ebp - 8274 89/<- %ebp 4/r32/esp - 8275 # (eax..ecx) = "A$" - 8276 b8/copy-to-eax "A$"/imm32 - 8277 8b/-> *eax 1/r32/ecx - 8278 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8279 05/add-to-eax 4/imm32 - 8280 # var slice/ecx: slice = {eax, ecx} - 8281 51/push-ecx - 8282 50/push-eax - 8283 89/<- %ecx 4/r32/esp - 8284 # - 8285 (is-identifier? %ecx) - 8286 (check-ints-equal %eax 1 "F - test-is-identifier-A") - 8287 # . epilogue - 8288 89/<- %esp 5/r32/ebp - 8289 5d/pop-to-ebp - 8290 c3/return - 8291 - 8292 test-is-identifier-Z: - 8293 # . prologue - 8294 55/push-ebp - 8295 89/<- %ebp 4/r32/esp - 8296 # (eax..ecx) = "Z$" - 8297 b8/copy-to-eax "Z$"/imm32 - 8298 8b/-> *eax 1/r32/ecx - 8299 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8300 05/add-to-eax 4/imm32 - 8301 # var slice/ecx: slice = {eax, ecx} - 8302 51/push-ecx - 8303 50/push-eax - 8304 89/<- %ecx 4/r32/esp - 8305 # - 8306 (is-identifier? %ecx) - 8307 (check-ints-equal %eax 1 "F - test-is-identifier-Z") - 8308 # . epilogue - 8309 89/<- %esp 5/r32/ebp - 8310 5d/pop-to-ebp - 8311 c3/return - 8312 - 8313 test-is-identifier-at: - 8314 # character before 'A' is invalid - 8315 # . prologue - 8316 55/push-ebp - 8317 89/<- %ebp 4/r32/esp - 8318 # (eax..ecx) = "@a" - 8319 b8/copy-to-eax "@a"/imm32 - 8320 8b/-> *eax 1/r32/ecx - 8321 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8322 05/add-to-eax 4/imm32 - 8323 # var slice/ecx: slice = {eax, ecx} - 8324 51/push-ecx - 8325 50/push-eax - 8326 89/<- %ecx 4/r32/esp - 8327 # - 8328 (is-identifier? %ecx) - 8329 (check-ints-equal %eax 0 "F - test-is-identifier-@") - 8330 # . epilogue - 8331 89/<- %esp 5/r32/ebp - 8332 5d/pop-to-ebp - 8333 c3/return - 8334 - 8335 test-is-identifier-square-bracket: - 8336 # character after 'Z' is invalid - 8337 # . prologue - 8338 55/push-ebp - 8339 89/<- %ebp 4/r32/esp - 8340 # (eax..ecx) = "[a" - 8341 b8/copy-to-eax "[a"/imm32 - 8342 8b/-> *eax 1/r32/ecx - 8343 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8344 05/add-to-eax 4/imm32 - 8345 # var slice/ecx: slice = {eax, ecx} - 8346 51/push-ecx - 8347 50/push-eax - 8348 89/<- %ecx 4/r32/esp - 8349 # - 8350 (is-identifier? %ecx) - 8351 (check-ints-equal %eax 0 "F - test-is-identifier-@") - 8352 # . epilogue - 8353 89/<- %esp 5/r32/ebp - 8354 5d/pop-to-ebp - 8355 c3/return - 8356 - 8357 test-is-identifier-backtick: - 8358 # character before 'a' is invalid - 8359 # . prologue - 8360 55/push-ebp - 8361 89/<- %ebp 4/r32/esp - 8362 # (eax..ecx) = "`a" - 8363 b8/copy-to-eax "`a"/imm32 - 8364 8b/-> *eax 1/r32/ecx - 8365 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8366 05/add-to-eax 4/imm32 - 8367 # var slice/ecx: slice = {eax, ecx} - 8368 51/push-ecx - 8369 50/push-eax - 8370 89/<- %ecx 4/r32/esp - 8371 # - 8372 (is-identifier? %ecx) - 8373 (check-ints-equal %eax 0 "F - test-is-identifier-backtick") - 8374 # . epilogue - 8375 89/<- %esp 5/r32/ebp - 8376 5d/pop-to-ebp - 8377 c3/return - 8378 - 8379 test-is-identifier-curly-brace-open: - 8380 # character after 'z' is invalid; also used for blocks - 8381 # . prologue - 8382 55/push-ebp - 8383 89/<- %ebp 4/r32/esp - 8384 # (eax..ecx) = "{a" - 8385 b8/copy-to-eax "{a"/imm32 - 8386 8b/-> *eax 1/r32/ecx - 8387 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8388 05/add-to-eax 4/imm32 - 8389 # var slice/ecx: slice = {eax, ecx} - 8390 51/push-ecx - 8391 50/push-eax - 8392 89/<- %ecx 4/r32/esp - 8393 # - 8394 (is-identifier? %ecx) - 8395 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-open") - 8396 # . epilogue - 8397 89/<- %esp 5/r32/ebp - 8398 5d/pop-to-ebp - 8399 c3/return - 8400 - 8401 test-is-identifier-curly-brace-close: - 8402 # . prologue - 8403 55/push-ebp - 8404 89/<- %ebp 4/r32/esp - 8405 # (eax..ecx) = "}a" - 8406 b8/copy-to-eax "}a"/imm32 - 8407 8b/-> *eax 1/r32/ecx - 8408 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8409 05/add-to-eax 4/imm32 - 8410 # var slice/ecx: slice = {eax, ecx} - 8411 51/push-ecx - 8412 50/push-eax - 8413 89/<- %ecx 4/r32/esp - 8414 # - 8415 (is-identifier? %ecx) - 8416 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-close") - 8417 # . epilogue - 8418 89/<- %esp 5/r32/ebp - 8419 5d/pop-to-ebp - 8420 c3/return - 8421 - 8422 test-is-identifier-hyphen: - 8423 # disallow leading '-' since '->' has special meaning - 8424 # . prologue - 8425 55/push-ebp - 8426 89/<- %ebp 4/r32/esp - 8427 # (eax..ecx) = "-a" - 8428 b8/copy-to-eax "-a"/imm32 - 8429 8b/-> *eax 1/r32/ecx - 8430 8d/copy-address *(eax+ecx+4) 1/r32/ecx - 8431 05/add-to-eax 4/imm32 - 8432 # var slice/ecx: slice = {eax, ecx} - 8433 51/push-ecx - 8434 50/push-eax - 8435 89/<- %ecx 4/r32/esp - 8436 # - 8437 (is-identifier? %ecx) - 8438 (check-ints-equal %eax 0 "F - test-is-identifier-hyphen") - 8439 # . epilogue - 8440 89/<- %esp 5/r32/ebp - 8441 5d/pop-to-ebp - 8442 c3/return - 8443 - 8444 populate-mu-function-body: # in: (addr buffered-file), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) - 8445 # . prologue - 8446 55/push-ebp - 8447 89/<- %ebp 4/r32/esp - 8448 # . save registers - 8449 50/push-eax - 8450 56/push-esi - 8451 57/push-edi - 8452 # esi = in - 8453 8b/-> *(ebp+8) 6/r32/esi - 8454 # edi = out - 8455 8b/-> *(ebp+0xc) 7/r32/edi - 8456 # initialize some global state - 8457 c7 0/subop/copy *Curr-block-depth 1/imm32 - 8458 # parse-mu-block(in, vars, out, out->body) - 8459 8d/copy-address *(edi+0x18) 0/r32/eax # Function-body - 8460 (parse-mu-block %esi *(ebp+0x10) %edi %eax *(ebp+0x14) *(ebp+0x18)) - 8461 $populate-mu-function-body:end: - 8462 # . restore registers - 8463 5f/pop-to-edi - 8464 5e/pop-to-esi - 8465 58/pop-to-eax - 8466 # . epilogue - 8467 89/<- %esp 5/r32/ebp - 8468 5d/pop-to-ebp - 8469 c3/return - 8470 - 8471 # parses a block, assuming that the leading '{' has already been read by the caller - 8472 parse-mu-block: # in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle block), err: (addr buffered-file), ed: (addr exit-descriptor) - 8473 # pseudocode: - 8474 # var line: (stream byte 512) - 8475 # var word-slice: slice - 8476 # allocate(Heap, Stmt-size, out) - 8477 # var out-addr: (addr block) = lookup(*out) - 8478 # out-addr->tag = 0/block - 8479 # out-addr->var = some unique name - 8480 # push(vars, {out-addr->var, false}) - 8481 # while true # line loop - 8482 # clear-stream(line) - 8483 # read-line-buffered(in, line) - 8484 # if (line->write == 0) break # end of file - 8485 # word-slice = next-mu-token(line) - 8486 # if slice-empty?(word-slice) # end of line - 8487 # continue - 8488 # else if slice-starts-with?(word-slice, "#") - 8489 # continue - 8490 # else if slice-equal?(word-slice, "{") - 8491 # assert(no-tokens-in(line)) - 8492 # block = parse-mu-block(in, vars, fn) - 8493 # append-to-block(out-addr, block) - 8494 # else if slice-equal?(word-slice, "}") - 8495 # break - 8496 # else if slice-ends-with?(word-slice, ":") - 8497 # # TODO: error-check the rest of 'line' - 8498 # --word-slice->end to skip ':' - 8499 # named-block = parse-mu-named-block(word-slice, in, vars, fn) - 8500 # append-to-block(out-addr, named-block) - 8501 # else if slice-equal?(word-slice, "var") - 8502 # var-def = parse-mu-var-def(line, vars, fn) - 8503 # append-to-block(out-addr, var-def) - 8504 # else - 8505 # stmt = parse-mu-stmt(line, vars, fn) - 8506 # append-to-block(out-addr, stmt) - 8507 # pop(vars) - 8508 # - 8509 # . prologue - 8510 55/push-ebp - 8511 89/<- %ebp 4/r32/esp - 8512 # . save registers - 8513 50/push-eax - 8514 51/push-ecx - 8515 52/push-edx - 8516 53/push-ebx - 8517 57/push-edi - 8518 # var line/ecx: (stream byte 512) - 8519 81 5/subop/subtract %esp 0x200/imm32 - 8520 68/push 0x200/imm32/size - 8521 68/push 0/imm32/read - 8522 68/push 0/imm32/write - 8523 89/<- %ecx 4/r32/esp - 8524 # var word-slice/edx: slice - 8525 68/push 0/imm32/end - 8526 68/push 0/imm32/start - 8527 89/<- %edx 4/r32/esp - 8528 # allocate into out - 8529 (allocate Heap *Stmt-size *(ebp+0x14)) - 8530 # var out-addr/edi: (addr block) = lookup(*out) - 8531 8b/-> *(ebp+0x14) 7/r32/edi - 8532 (lookup *edi *(edi+4)) # => eax - 8533 89/<- %edi 0/r32/eax - 8534 # out-addr->tag is 0 (block) by default - 8535 # set out-addr->var - 8536 8d/copy-address *(edi+0xc) 0/r32/eax # Block-var - 8537 (new-block-name *(ebp+0x10) %eax) - 8538 # push(vars, out-addr->var) - 8539 (push *(ebp+0xc) *(edi+0xc)) # Block-var - 8540 (push *(ebp+0xc) *(edi+0x10)) # Block-var - 8541 (push *(ebp+0xc) 0) # false - 8542 # increment *Curr-block-depth - 8543 ff 0/subop/increment *Curr-block-depth - 8544 { - 8545 $parse-mu-block:line-loop: - 8546 # line = read-line-buffered(in) - 8547 (clear-stream %ecx) - 8548 (read-line-buffered *(ebp+8) %ecx) - 8549 #? (write-buffered Stderr "line: ") - 8550 #? (write-stream-data Stderr %ecx) - 8551 #? #? (write-buffered Stderr Newline) # line has its own newline - 8552 #? (flush Stderr) - 8553 #? (rewind-stream %ecx) - 8554 # if (line->write == 0) break - 8555 81 7/subop/compare *ecx 0/imm32 - 8556 0f 84/jump-if-= break/disp32 - 8557 #? (write-buffered Stderr "vars:\n") - 8558 #? (dump-vars *(ebp+0xc)) - 8559 # word-slice = next-mu-token(line) - 8560 (next-mu-token %ecx %edx) - 8561 #? (write-buffered Stderr "word: ") - 8562 #? (write-slice-buffered Stderr %edx) - 8563 #? (write-buffered Stderr Newline) - 8564 #? (flush Stderr) - 8565 # if slice-empty?(word-slice) continue - 8566 (slice-empty? %edx) - 8567 3d/compare-eax-and 0/imm32/false - 8568 0f 85/jump-if-!= loop/disp32 - 8569 # if (slice-starts-with?(word-slice, '#') continue - 8570 # . eax = *word-slice->start - 8571 8b/-> *edx 0/r32/eax - 8572 8a/copy-byte *eax 0/r32/AL - 8573 81 4/subop/and %eax 0xff/imm32 - 8574 # . if (eax == '#') continue - 8575 3d/compare-eax-and 0x23/imm32/hash - 8576 0f 84/jump-if-= loop/disp32 - 8577 # if slice-equal?(word-slice, "{") - 8578 { - 8579 $parse-mu-block:check-for-block: - 8580 (slice-equal? %edx "{") - 8581 3d/compare-eax-and 0/imm32/false - 8582 74/jump-if-= break/disp8 - 8583 (check-no-tokens-left %ecx) - 8584 # parse new block and append - 8585 # . var tmp/eax: (handle block) - 8586 68/push 0/imm32 - 8587 68/push 0/imm32 - 8588 89/<- %eax 4/r32/esp - 8589 # . - 8590 (parse-mu-block *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) - 8591 (append-to-block Heap %edi *eax *(eax+4)) - 8592 # . reclaim tmp - 8593 81 0/subop/add %esp 8/imm32 - 8594 # . - 8595 e9/jump $parse-mu-block:line-loop/disp32 - 8596 } - 8597 # if slice-equal?(word-slice, "}") break - 8598 $parse-mu-block:check-for-end: - 8599 (slice-equal? %edx "}") - 8600 3d/compare-eax-and 0/imm32/false - 8601 0f 85/jump-if-!= break/disp32 - 8602 # if slice-ends-with?(word-slice, ":") parse named block and append - 8603 { - 8604 $parse-mu-block:check-for-named-block: - 8605 # . eax = *(word-slice->end-1) - 8606 8b/-> *(edx+4) 0/r32/eax - 8607 48/decrement-eax - 8608 8a/copy-byte *eax 0/r32/AL - 8609 81 4/subop/and %eax 0xff/imm32 - 8610 # . if (eax != ':') break - 8611 3d/compare-eax-and 0x3a/imm32/colon - 8612 0f 85/jump-if-!= break/disp32 - 8613 # TODO: error-check the rest of 'line' - 8614 # - 8615 # skip ':' - 8616 ff 1/subop/decrement *(edx+4) # Slice-end - 8617 # var tmp/eax: (handle block) - 8618 68/push 0/imm32 - 8619 68/push 0/imm32 - 8620 89/<- %eax 4/r32/esp - 8621 # - 8622 (parse-mu-named-block %edx *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) - 8623 (append-to-block Heap %edi *eax *(eax+4)) - 8624 # reclaim tmp - 8625 81 0/subop/add %esp 8/imm32 - 8626 # - 8627 e9/jump $parse-mu-block:line-loop/disp32 - 8628 } - 8629 # if slice-equal?(word-slice, "var") - 8630 { - 8631 $parse-mu-block:check-for-var: - 8632 (slice-equal? %edx "var") - 8633 3d/compare-eax-and 0/imm32/false - 8634 74/jump-if-= break/disp8 - 8635 # var tmp/eax: (handle block) - 8636 68/push 0/imm32 - 8637 68/push 0/imm32 - 8638 89/<- %eax 4/r32/esp - 8639 # - 8640 (parse-mu-var-def %ecx *(ebp+0xc) %eax *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) - 8641 (append-to-block Heap %edi *eax *(eax+4)) - 8642 # reclaim tmp - 8643 81 0/subop/add %esp 8/imm32 - 8644 # - 8645 e9/jump $parse-mu-block:line-loop/disp32 - 8646 } - 8647 $parse-mu-block:regular-stmt: - 8648 # otherwise - 8649 # var tmp/eax: (handle block) - 8650 68/push 0/imm32 - 8651 68/push 0/imm32 - 8652 89/<- %eax 4/r32/esp - 8653 # - 8654 (parse-mu-stmt %ecx *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) - 8655 (append-to-block Heap %edi *eax *(eax+4)) - 8656 # reclaim tmp - 8657 81 0/subop/add %esp 8/imm32 - 8658 # - 8659 e9/jump loop/disp32 - 8660 } # end line loop - 8661 (clean-up-blocks *(ebp+0xc) *Curr-block-depth *(ebp+0x10)) - 8662 # decrement *Curr-block-depth - 8663 ff 1/subop/decrement *Curr-block-depth - 8664 # pop(vars) - 8665 (pop *(ebp+0xc)) # => eax - 8666 (pop *(ebp+0xc)) # => eax - 8667 (pop *(ebp+0xc)) # => eax - 8668 $parse-mu-block:end: - 8669 # . reclaim locals - 8670 81 0/subop/add %esp 0x214/imm32 - 8671 # . restore registers - 8672 5f/pop-to-edi - 8673 5b/pop-to-ebx - 8674 5a/pop-to-edx - 8675 59/pop-to-ecx - 8676 58/pop-to-eax - 8677 # . epilogue - 8678 89/<- %esp 5/r32/ebp - 8679 5d/pop-to-ebp - 8680 c3/return - 8681 - 8682 $parse-mu-block:abort: - 8683 # error("'{' or '}' should be on its own line, but got '") - 8684 (write-buffered *(ebp+0x18) "'{' or '}' should be on its own line, but got '") - 8685 (rewind-stream %ecx) - 8686 (write-stream-data *(ebp+0x18) %ecx) - 8687 (write-buffered *(ebp+0x18) "'\n") - 8688 (flush *(ebp+0x18)) - 8689 (stop *(ebp+0x1c) 1) - 8690 # never gets here - 8691 - 8692 new-block-name: # fn: (addr function), out: (addr handle var) - 8693 # . prologue - 8694 55/push-ebp - 8695 89/<- %ebp 4/r32/esp - 8696 # . save registers - 8697 50/push-eax - 8698 51/push-ecx - 8699 52/push-edx - 8700 # var n/ecx: int = len(fn->name) + 10 for an int + 2 for '$:' - 8701 8b/-> *(ebp+8) 0/r32/eax - 8702 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 8703 8b/-> *eax 0/r32/eax # String-size - 8704 05/add-to-eax 0xd/imm32 # 10 + 2 for '$:' - 8705 89/<- %ecx 0/r32/eax - 8706 # var name/edx: (stream byte n) - 8707 29/subtract-from %esp 1/r32/ecx - 8708 ff 6/subop/push %ecx - 8709 68/push 0/imm32/read - 8710 68/push 0/imm32/write - 8711 89/<- %edx 4/r32/esp - 8712 (clear-stream %edx) - 8713 # eax = fn->name - 8714 8b/-> *(ebp+8) 0/r32/eax - 8715 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 8716 # construct result using Next-block-index (and increment it) - 8717 (write %edx "$") - 8718 (write %edx %eax) - 8719 (write %edx ":") - 8720 (write-int32-hex %edx *Next-block-index) - 8721 ff 0/subop/increment *Next-block-index - 8722 # var s/eax: slice = {name->data, name->data + name->write} (clobbering edx) - 8723 # . eax = name->write - 8724 8b/-> *edx 0/r32/eax - 8725 # . edx = name->data - 8726 8d/copy-address *(edx+0xc) 2/r32/edx - 8727 # . eax = name->write + name->data - 8728 01/add-to %eax 2/r32/edx - 8729 # . push {edx, eax} - 8730 ff 6/subop/push %eax - 8731 ff 6/subop/push %edx - 8732 89/<- %eax 4/r32/esp - 8733 # out = new literal(s) - 8734 (new-literal Heap %eax *(ebp+0xc)) - 8735 #? 8b/-> *(ebp+0xc) 0/r32/eax - 8736 #? (write-buffered Stderr "type allocid in caller after new-literal: ") - 8737 #? (write-int32-hex-buffered Stderr *(eax+8)) - 8738 #? (write-buffered Stderr " for var ") - 8739 #? (write-int32-hex-buffered Stderr %eax) - 8740 #? (write-buffered Stderr Newline) - 8741 #? (flush Stderr) - 8742 $new-block-name:end: - 8743 # . reclaim locals - 8744 81 0/subop/add %ecx 0xc/imm32 # name.{read/write/len} - 8745 81 0/subop/add %ecx 8/imm32 # slice - 8746 01/add-to %esp 1/r32/ecx - 8747 # . restore registers - 8748 5a/pop-to-edx - 8749 59/pop-to-ecx - 8750 58/pop-to-eax - 8751 # . epilogue - 8752 89/<- %esp 5/r32/ebp - 8753 5d/pop-to-ebp - 8754 c3/return - 8755 - 8756 check-no-tokens-left: # line: (addr stream byte) - 8757 # . prologue - 8758 55/push-ebp - 8759 89/<- %ebp 4/r32/esp - 8760 # . save registers - 8761 50/push-eax - 8762 51/push-ecx - 8763 # var s/ecx: slice - 8764 68/push 0/imm32/end - 8765 68/push 0/imm32/start - 8766 89/<- %ecx 4/r32/esp - 8767 # - 8768 (next-mu-token *(ebp+8) %ecx) - 8769 # if slice-empty?(s) return - 8770 (slice-empty? %ecx) - 8771 3d/compare-eax-and 0/imm32/false - 8772 75/jump-if-!= $check-no-tokens-left:end/disp8 - 8773 # if (slice-starts-with?(s, '#') return - 8774 # . eax = *s->start - 8775 8b/-> *edx 0/r32/eax - 8776 8a/copy-byte *eax 0/r32/AL - 8777 81 4/subop/and %eax 0xff/imm32 - 8778 # . if (eax == '#') continue - 8779 3d/compare-eax-and 0x23/imm32/hash - 8780 74/jump-if-= $check-no-tokens-left:end/disp8 - 8781 # abort - 8782 (write-buffered Stderr "'{' or '}' should be on its own line, but got '") - 8783 (rewind-stream %ecx) - 8784 (write-stream 2 %ecx) - 8785 (write-buffered Stderr "'\n") - 8786 (flush Stderr) - 8787 # . syscall(exit, 1) - 8788 bb/copy-to-ebx 1/imm32 - 8789 e8/call syscall_exit/disp32 - 8790 # never gets here - 8791 $check-no-tokens-left:end: - 8792 # . reclaim locals - 8793 81 0/subop/add %esp 8/imm32 - 8794 # . restore registers - 8795 59/pop-to-ecx - 8796 58/pop-to-eax - 8797 # . epilogue - 8798 89/<- %esp 5/r32/ebp - 8799 5d/pop-to-ebp - 8800 c3/return - 8801 - 8802 parse-mu-named-block: # name: (addr slice), in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) - 8803 # pseudocode: - 8804 # var v: (handle var) - 8805 # new-literal(name, v) - 8806 # push(vars, {v, false}) - 8807 # parse-mu-block(in, vars, fn, out) - 8808 # pop(vars) - 8809 # out->tag = block - 8810 # out->var = v - 8811 # - 8812 # . prologue - 8813 55/push-ebp - 8814 89/<- %ebp 4/r32/esp - 8815 # . save registers - 8816 50/push-eax - 8817 51/push-ecx - 8818 57/push-edi - 8819 # var v/ecx: (handle var) - 8820 68/push 0/imm32 - 8821 68/push 0/imm32 - 8822 89/<- %ecx 4/r32/esp - 8823 # - 8824 (new-literal Heap *(ebp+8) %ecx) - 8825 # push(vars, v) - 8826 (push *(ebp+0x10) *ecx) - 8827 (push *(ebp+0x10) *(ecx+4)) - 8828 (push *(ebp+0x10) 0) # false - 8829 # - 8830 (parse-mu-block *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c) *(ebp+0x20)) - 8831 # pop v off vars - 8832 (pop *(ebp+0x10)) # => eax - 8833 (pop *(ebp+0x10)) # => eax - 8834 (pop *(ebp+0x10)) # => eax - 8835 # var out-addr/edi: (addr stmt) = lookup(*out) - 8836 8b/-> *(ebp+0x18) 7/r32/edi - 8837 (lookup *edi *(edi+4)) # => eax - 8838 89/<- %edi 0/r32/eax - 8839 # out-addr->tag = named-block - 8840 c7 0/subop/copy *edi 0/imm32/block # Stmt-tag - 8841 # out-addr->var = v - 8842 8b/-> *ecx 0/r32/eax - 8843 89/<- *(edi+0xc) 0/r32/eax # Block-var - 8844 8b/-> *(ecx+4) 0/r32/eax - 8845 89/<- *(edi+0x10) 0/r32/eax # Block-var - 8846 $parse-mu-named-block:end: - 8847 # . reclaim locals - 8848 81 0/subop/add %esp 8/imm32 - 8849 # . restore registers - 8850 5f/pop-to-edi - 8851 59/pop-to-ecx - 8852 58/pop-to-eax - 8853 # . epilogue - 8854 89/<- %esp 5/r32/ebp - 8855 5d/pop-to-ebp - 8856 c3/return - 8857 - 8858 parse-mu-var-def: # line: (addr stream byte), vars: (addr stack live-var), out: (addr handle stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 8859 # . prologue - 8860 55/push-ebp - 8861 89/<- %ebp 4/r32/esp - 8862 # . save registers - 8863 50/push-eax - 8864 51/push-ecx - 8865 52/push-edx - 8866 53/push-ebx - 8867 57/push-edi - 8868 # edi = out - 8869 8b/-> *(ebp+0x10) 7/r32/edi - 8870 # var word-slice/ecx: slice - 8871 68/push 0/imm32/end - 8872 68/push 0/imm32/start - 8873 89/<- %ecx 4/r32/esp - 8874 # var v/edx: (handle var) - 8875 68/push 0/imm32 - 8876 68/push 0/imm32 - 8877 89/<- %edx 4/r32/esp - 8878 # v = parse-var-with-type(next-mu-token(line)) - 8879 (next-mu-token *(ebp+8) %ecx) - 8880 (parse-var-with-type %ecx *(ebp+8) %edx *(ebp+0x18) *(ebp+0x1c)) - 8881 # var v-addr/eax: (addr var) - 8882 (lookup *edx *(edx+4)) # => eax - 8883 # v->block-depth = *Curr-block-depth - 8884 8b/-> *Curr-block-depth 3/r32/ebx - 8885 89/<- *(eax+0x10) 3/r32/ebx # Var-block-depth - 8886 # either v has no register and there's no more to this line - 8887 8b/-> *(eax+0x18) 0/r32/eax # Var-register - 8888 3d/compare-eax-and 0/imm32 - 8889 { - 8890 75/jump-if-!= break/disp8 - 8891 # TODO: disallow vars of type 'byte' on the stack - 8892 # ensure that there's nothing else on this line - 8893 (next-mu-token *(ebp+8) %ecx) - 8894 (slice-empty? %ecx) # => eax - 8895 3d/compare-eax-and 0/imm32/false - 8896 0f 84/jump-if-= $parse-mu-var-def:error2/disp32 - 8897 # - 8898 (new-var-def Heap *edx *(edx+4) %edi) - 8899 e9/jump $parse-mu-var-def:update-vars/disp32 - 8900 } - 8901 # or v has a register and there's more to this line - 8902 { - 8903 0f 84/jump-if-= break/disp32 - 8904 # TODO: disallow vars of type 'byte' in registers 'esi' or 'edi' - 8905 # TODO: vars of type 'byte' should only be initialized by clearing to 0 - 8906 # ensure that the next word is '<-' - 8907 (next-mu-token *(ebp+8) %ecx) - 8908 (slice-equal? %ecx "<-") # => eax - 8909 3d/compare-eax-and 0/imm32/false - 8910 0f 84/jump-if-= $parse-mu-var-def:error1/disp32 - 8911 # - 8912 (new-reg-var-def Heap *edx *(edx+4) %edi) - 8913 (lookup *edi *(edi+4)) # => eax - 8914 (add-operation-and-inputs-to-stmt %eax *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) - 8915 } - 8916 $parse-mu-var-def:update-vars: - 8917 # push 'v' at end of function - 8918 (push *(ebp+0xc) *edx) - 8919 (push *(ebp+0xc) *(edx+4)) - 8920 (push *(ebp+0xc) 0) # Live-var-register-spilled is unused during parsing - 8921 $parse-mu-var-def:end: - 8922 # . reclaim locals - 8923 81 0/subop/add %esp 0x10/imm32 - 8924 # . restore registers - 8925 5f/pop-to-edi - 8926 5b/pop-to-ebx - 8927 5a/pop-to-edx - 8928 59/pop-to-ecx - 8929 58/pop-to-eax - 8930 # . epilogue - 8931 89/<- %esp 5/r32/ebp - 8932 5d/pop-to-ebp - 8933 c3/return - 8934 - 8935 $parse-mu-var-def:error1: - 8936 (rewind-stream *(ebp+8)) - 8937 # error("register variable requires a valid instruction to initialize but got '" line "'\n") - 8938 (write-buffered *(ebp+0x18) "register variable requires a valid instruction to initialize but got '") - 8939 (flush *(ebp+0x18)) - 8940 (write-stream-data *(ebp+0x18) *(ebp+8)) - 8941 (write-buffered *(ebp+0x18) "'\n") - 8942 (flush *(ebp+0x18)) - 8943 (stop *(ebp+0x1c) 1) - 8944 # never gets here - 8945 - 8946 $parse-mu-var-def:error2: - 8947 (rewind-stream *(ebp+8)) - 8948 # error("fn " fn ": var " var ": variables on the stack can't take an initializer\n") - 8949 (write-buffered *(ebp+0x18) "fn ") - 8950 8b/-> *(ebp+0x14) 0/r32/eax - 8951 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 8952 (write-buffered *(ebp+0x18) %eax) - 8953 (write-buffered *(ebp+0x18) ": var ") - 8954 # var v-addr/eax: (addr var) = lookup(v) - 8955 (lookup *edx *(edx+4)) # => eax - 8956 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 8957 (write-buffered *(ebp+0x18) %eax) - 8958 (write-buffered *(ebp+0x18) ": variables on the stack can't take an initializer\n") - 8959 (flush *(ebp+0x18)) - 8960 (stop *(ebp+0x1c) 1) - 8961 # never gets here - 8962 - 8963 test-parse-mu-var-def: - 8964 # 'var n: int' - 8965 # . prologue - 8966 55/push-ebp - 8967 89/<- %ebp 4/r32/esp - 8968 # setup - 8969 (clear-stream _test-input-stream) - 8970 (write _test-input-stream "n: int\n") # caller has consumed the 'var' - 8971 c7 0/subop/copy *Curr-block-depth 1/imm32 - 8972 # var out/esi: (handle stmt) - 8973 68/push 0/imm32 - 8974 68/push 0/imm32 - 8975 89/<- %esi 4/r32/esp - 8976 # var vars/ecx: (stack (addr var) 16) - 8977 81 5/subop/subtract %esp 0xc0/imm32 - 8978 68/push 0xc0/imm32/size - 8979 68/push 0/imm32/top - 8980 89/<- %ecx 4/r32/esp - 8981 (clear-stack %ecx) - 8982 # convert - 8983 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) - 8984 # var out-addr/esi: (addr stmt) - 8985 (lookup *esi *(esi+4)) # => eax - 8986 89/<- %esi 0/r32/eax - 8987 # - 8988 (check-ints-equal *esi 2 "F - test-parse-mu-var-def/tag") # Stmt-tag is var-def - 8989 # var v/ecx: (addr var) = lookup(out->var) - 8990 (lookup *(esi+4) *(esi+8)) # Vardef-var Vardef-var => eax - 8991 89/<- %ecx 0/r32/eax - 8992 # v->name - 8993 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax - 8994 (check-strings-equal %eax "n" "F - test-parse-mu-var-def/var-name") - 8995 # v->register - 8996 (check-ints-equal *(ecx+0x18) 0 "F - test-parse-mu-var-def/var-register") # Var-register - 8997 # v->block-depth - 8998 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-var-def/output-block-depth") # Var-block-depth - 8999 # v->type == int - 9000 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax - 9001 (check-ints-equal *eax 1 "F - test-parse-mu-var-def/var-type:0") # Type-tree-is-atom - 9002 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-var-def/var-type:1") # Type-tree-value - 9003 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-var-def/var-type:2") # Type-tree-right - 9004 # . epilogue - 9005 89/<- %esp 5/r32/ebp - 9006 5d/pop-to-ebp - 9007 c3/return - 9008 - 9009 test-parse-mu-reg-var-def: - 9010 # 'var n/eax: int <- copy 0' - 9011 # . prologue - 9012 55/push-ebp - 9013 89/<- %ebp 4/r32/esp - 9014 # setup - 9015 (clear-stream _test-input-stream) - 9016 (write _test-input-stream "n/eax: int <- copy 0\n") # caller has consumed the 'var' - 9017 c7 0/subop/copy *Curr-block-depth 1/imm32 - 9018 # var out/esi: (handle stmt) - 9019 68/push 0/imm32 - 9020 68/push 0/imm32 - 9021 89/<- %esi 4/r32/esp - 9022 # var vars/ecx: (stack (addr var) 16) - 9023 81 5/subop/subtract %esp 0xc0/imm32 - 9024 68/push 0xc0/imm32/size - 9025 68/push 0/imm32/top - 9026 89/<- %ecx 4/r32/esp - 9027 (clear-stack %ecx) - 9028 # convert - 9029 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) - 9030 # var out-addr/esi: (addr stmt) - 9031 (lookup *esi *(esi+4)) # => eax - 9032 89/<- %esi 0/r32/eax - 9033 # - 9034 (check-ints-equal *esi 3 "F - test-parse-mu-reg-var-def/tag") # Stmt-tag is reg-var-def - 9035 # var v/ecx: (addr var) = lookup(out->outputs->value) - 9036 # . eax: (addr stmt-var) = lookup(out->outputs) - 9037 (lookup *(esi+0x14) *(esi+0x18)) # Regvardef-outputs Regvardef-outputs => eax - 9038 # . - 9039 (check-ints-equal *(eax+8) 0 "F - test-parse-mu-reg-var-def/single-output") # Stmt-var-next - 9040 # . eax: (addr var) = lookup(eax->value) - 9041 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9042 # . ecx = eax - 9043 89/<- %ecx 0/r32/eax - 9044 # v->name - 9045 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax - 9046 (check-strings-equal %eax "n" "F - test-parse-mu-reg-var-def/output-name") # Var-name - 9047 # v->register - 9048 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax - 9049 (check-strings-equal %eax "eax" "F - test-parse-mu-reg-var-def/output-register") - 9050 # v->block-depth - 9051 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-reg-var-def/output-block-depth") # Var-block-depth - 9052 # v->type == int - 9053 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax - 9054 (check-ints-equal *eax 1 "F - test-parse-mu-reg-var-def/output-type:0") # Type-tree-is-atom - 9055 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-reg-var-def/output-type:1") # Type-tree-value - 9056 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-reg-var-def/output-type:2") # Type-tree-right - 9057 # . epilogue - 9058 89/<- %esp 5/r32/ebp - 9059 5d/pop-to-ebp - 9060 c3/return - 9061 - 9062 parse-mu-stmt: # line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) - 9063 # Carefully push any outputs on the vars stack _after_ reading the inputs - 9064 # that may conflict with them. - 9065 # - 9066 # The only situation in which outputs are pushed here (when it's not a - 9067 # 'var' vardef stmt), and so can possibly conflict with inputs, is if the - 9068 # output is a function output. - 9069 # - 9070 # pseudocode: - 9071 # var name: slice - 9072 # allocate(Heap, Stmt-size, out) - 9073 # var out-addr: (addr stmt) = lookup(*out) - 9074 # out-addr->tag = stmt - 9075 # if stmt-has-outputs?(line) - 9076 # while true - 9077 # name = next-mu-token(line) - 9078 # if (name == '<-') break - 9079 # assert(is-identifier?(name)) - 9080 # var v: (handle var) = lookup-var-or-find-in-fn-outputs(name, vars, fn) - 9081 # out-addr->outputs = append(v, out-addr->outputs) - 9082 # add-operation-and-inputs-to-stmt(out-addr, line, vars) - 9083 # for output in stmt->outputs: - 9084 # maybe-define-var(output, vars) - 9085 # - 9086 # . prologue - 9087 55/push-ebp - 9088 89/<- %ebp 4/r32/esp - 9089 # . save registers - 9090 50/push-eax - 9091 51/push-ecx - 9092 52/push-edx - 9093 53/push-ebx - 9094 57/push-edi - 9095 # var name/ecx: slice - 9096 68/push 0/imm32/end - 9097 68/push 0/imm32/start - 9098 89/<- %ecx 4/r32/esp - 9099 # var is-deref?/edx: boolean = false - 9100 ba/copy-to-edx 0/imm32/false - 9101 # var v: (handle var) - 9102 68/push 0/imm32 - 9103 68/push 0/imm32 - 9104 89/<- %ebx 4/r32/esp - 9105 # - 9106 (allocate Heap *Stmt-size *(ebp+0x14)) - 9107 # var out-addr/edi: (addr stmt) = lookup(*out) - 9108 8b/-> *(ebp+0x14) 7/r32/edi - 9109 (lookup *edi *(edi+4)) # => eax - 9110 89/<- %edi 0/r32/eax - 9111 # out-addr->tag = 1/stmt - 9112 c7 0/subop/copy *edi 1/imm32/stmt1 # Stmt-tag - 9113 { - 9114 (stmt-has-outputs? *(ebp+8)) - 9115 3d/compare-eax-and 0/imm32/false - 9116 0f 84/jump-if-= break/disp32 - 9117 { - 9118 $parse-mu-stmt:read-outputs: - 9119 # name = next-mu-token(line) - 9120 (next-mu-token *(ebp+8) %ecx) - 9121 # if slice-empty?(word-slice) break - 9122 (slice-empty? %ecx) # => eax - 9123 3d/compare-eax-and 0/imm32/false - 9124 0f 85/jump-if-!= break/disp32 - 9125 # if (name == "<-") break - 9126 (slice-equal? %ecx "<-") # => eax - 9127 3d/compare-eax-and 0/imm32/false - 9128 0f 85/jump-if-!= break/disp32 - 9129 # is-deref? = false - 9130 ba/copy-to-edx 0/imm32/false - 9131 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? - 9132 8b/-> *ecx 0/r32/eax # Slice-start - 9133 8a/copy-byte *eax 0/r32/AL - 9134 81 4/subop/and %eax 0xff/imm32 - 9135 3d/compare-eax-and 0x2a/imm32/asterisk - 9136 { - 9137 75/jump-if-!= break/disp8 - 9138 ff 0/subop/increment *ecx - 9139 ba/copy-to-edx 1/imm32/true - 9140 } - 9141 # assert(is-identifier?(name)) - 9142 (is-identifier? %ecx) # => eax - 9143 3d/compare-eax-and 0/imm32/false - 9144 0f 84/jump-if-= $parse-mu-stmt:abort/disp32 - 9145 # - 9146 (lookup-var-or-find-in-fn-outputs %ecx *(ebp+0xc) *(ebp+0x10) %ebx *(ebp+0x18) *(ebp+0x1c)) - 9147 8d/copy-address *(edi+0x14) 0/r32/eax # Stmt1-outputs - 9148 (append-stmt-var Heap *ebx *(ebx+4) *(edi+0x14) *(edi+0x18) %edx %eax) # Stmt1-outputs - 9149 # - 9150 e9/jump loop/disp32 - 9151 } - 9152 } - 9153 (add-operation-and-inputs-to-stmt %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) - 9154 $parse-mu-stmt:define-outputs: - 9155 # var output/edi: (addr stmt-var) = lookup(out-addr->outputs) - 9156 (lookup *(edi+0x14) *(edi+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9157 89/<- %edi 0/r32/eax - 9158 { - 9159 $parse-mu-stmt:define-outputs-loop: - 9160 # if (output == null) break - 9161 81 7/subop/compare %edi 0/imm32 - 9162 74/jump-if-= break/disp8 - 9163 # - 9164 (maybe-define-var *edi *(edi+4) *(ebp+0xc)) # if output is a deref, then it's already been defined, - 9165 # and must be in vars. This call will be a no-op, but safe. - 9166 # output = output->next - 9167 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax - 9168 89/<- %edi 0/r32/eax - 9169 # - 9170 eb/jump loop/disp8 - 9171 } - 9172 $parse-mu-stmt:end: - 9173 # . reclaim locals - 9174 81 0/subop/add %esp 0x10/imm32 - 9175 # . restore registers - 9176 5f/pop-to-edi - 9177 5b/pop-to-ebx - 9178 5a/pop-to-edx - 9179 59/pop-to-ecx - 9180 58/pop-to-eax - 9181 # . epilogue - 9182 89/<- %esp 5/r32/ebp - 9183 5d/pop-to-ebp - 9184 c3/return - 9185 - 9186 $parse-mu-stmt:abort: - 9187 # error("invalid identifier '" name "'\n") - 9188 (write-buffered *(ebp+0x18) "invalid identifier '") - 9189 (write-slice-buffered *(ebp+0x18) %ecx) - 9190 (write-buffered *(ebp+0x18) "'\n") - 9191 (flush *(ebp+0x18)) - 9192 (stop *(ebp+0x1c) 1) - 9193 # never gets here - 9194 - 9195 add-operation-and-inputs-to-stmt: # stmt: (addr stmt), line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 9196 # pseudocode: - 9197 # stmt->name = slice-to-string(next-mu-token(line)) - 9198 # while true - 9199 # name = next-mu-token(line) - 9200 # v = lookup-var-or-literal(name) - 9201 # stmt->inouts = append(v, stmt->inouts) - 9202 # - 9203 # . prologue - 9204 55/push-ebp - 9205 89/<- %ebp 4/r32/esp - 9206 # . save registers - 9207 50/push-eax - 9208 51/push-ecx - 9209 52/push-edx - 9210 53/push-ebx - 9211 56/push-esi - 9212 57/push-edi - 9213 # edi = stmt - 9214 8b/-> *(ebp+8) 7/r32/edi - 9215 # var name/ecx: slice - 9216 68/push 0/imm32/end - 9217 68/push 0/imm32/start - 9218 89/<- %ecx 4/r32/esp - 9219 # var is-deref?/edx: boolean = false - 9220 ba/copy-to-edx 0/imm32/false - 9221 # var v/esi: (handle var) - 9222 68/push 0/imm32 - 9223 68/push 0/imm32 - 9224 89/<- %esi 4/r32/esp - 9225 $add-operation-and-inputs-to-stmt:read-operation: - 9226 (next-mu-token *(ebp+0xc) %ecx) - 9227 8d/copy-address *(edi+4) 0/r32/eax # Stmt1-operation or Regvardef-operationStmt1-operation or Regvardef-operation - 9228 (slice-to-string Heap %ecx %eax) - 9229 # var is-get?/ebx: boolean = (name == "get") - 9230 (slice-equal? %ecx "get") # => eax - 9231 89/<- %ebx 0/r32/eax - 9232 { - 9233 $add-operation-and-inputs-to-stmt:read-inouts: - 9234 # name = next-mu-token(line) - 9235 (next-mu-token *(ebp+0xc) %ecx) - 9236 # if slice-empty?(word-slice) break - 9237 (slice-empty? %ecx) # => eax - 9238 3d/compare-eax-and 0/imm32/false - 9239 0f 85/jump-if-!= break/disp32 - 9240 # if (name == "<-") abort - 9241 (slice-equal? %ecx "<-") - 9242 3d/compare-eax-and 0/imm32/false - 9243 0f 85/jump-if-!= $add-operation-and-inputs-to-stmt:abort/disp32 - 9244 # if (is-get? && second operand) lookup or create offset - 9245 { - 9246 81 7/subop/compare %ebx 0/imm32/false - 9247 74/jump-if-= break/disp8 - 9248 (lookup *(edi+0xc) *(edi+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9249 3d/compare-eax-and 0/imm32 - 9250 74/jump-if-= break/disp8 - 9251 (lookup-or-create-constant %eax %ecx %esi) - 9252 #? (lookup *esi *(esi+4)) - 9253 #? (write-buffered Stderr "creating new output var ") - 9254 #? (write-int32-hex-buffered Stderr %eax) - 9255 #? (write-buffered Stderr " for field called ") - 9256 #? (write-slice-buffered Stderr %ecx) - 9257 #? (write-buffered Stderr "; var name ") - 9258 #? (lookup *eax *(eax+4)) # Var-name - 9259 #? (write-buffered Stderr %eax) - 9260 #? (write-buffered Stderr Newline) - 9261 #? (flush Stderr) - 9262 e9/jump $add-operation-and-inputs-to-stmt:save-var/disp32 - 9263 } - 9264 # is-deref? = false - 9265 ba/copy-to-edx 0/imm32/false - 9266 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? - 9267 8b/-> *ecx 0/r32/eax # Slice-start - 9268 8a/copy-byte *eax 0/r32/AL - 9269 81 4/subop/and %eax 0xff/imm32 - 9270 3d/compare-eax-and 0x2a/imm32/asterisk - 9271 { - 9272 75/jump-if-!= break/disp8 - 9273 $add-operation-and-inputs-to-stmt:inout-is-deref: - 9274 ff 0/subop/increment *ecx - 9275 ba/copy-to-edx 1/imm32/true - 9276 } - 9277 (lookup-var-or-literal %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) - 9278 $add-operation-and-inputs-to-stmt:save-var: - 9279 8d/copy-address *(edi+0xc) 0/r32/eax - 9280 (append-stmt-var Heap *esi *(esi+4) *(edi+0xc) *(edi+0x10) %edx %eax) # Stmt1-inouts or Regvardef-inouts - 9281 # - 9282 e9/jump loop/disp32 - 9283 } - 9284 $add-operation-and-inputs-to-stmt:end: - 9285 # . reclaim locals - 9286 81 0/subop/add %esp 0x10/imm32 - 9287 # . restore registers - 9288 5f/pop-to-edi - 9289 5e/pop-to-esi - 9290 5b/pop-to-ebx - 9291 5a/pop-to-edx - 9292 59/pop-to-ecx - 9293 58/pop-to-eax - 9294 # . epilogue - 9295 89/<- %esp 5/r32/ebp - 9296 5d/pop-to-ebp - 9297 c3/return - 9298 - 9299 $add-operation-and-inputs-to-stmt:abort: - 9300 # error("fn ___: invalid identifier in '" line "'\n") - 9301 (write-buffered *(ebp+0x18) "fn ") - 9302 8b/-> *(ebp+0x14) 0/r32/eax - 9303 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 9304 (write-buffered *(ebp+0x18) %eax) - 9305 (rewind-stream *(ebp+0xc)) - 9306 (write-buffered *(ebp+0x18) ": invalid identifier in '") - 9307 (write-stream-data *(ebp+0x18) *(ebp+0xc)) - 9308 (write-buffered *(ebp+0x18) "'\n") - 9309 (flush *(ebp+0x18)) - 9310 (stop *(ebp+0x1c) 1) - 9311 # never gets here - 9312 - 9313 stmt-has-outputs?: # line: (addr stream byte) -> result/eax: boolean - 9314 # . prologue - 9315 55/push-ebp - 9316 89/<- %ebp 4/r32/esp - 9317 # . save registers - 9318 51/push-ecx - 9319 # var word-slice/ecx: slice - 9320 68/push 0/imm32/end - 9321 68/push 0/imm32/start - 9322 89/<- %ecx 4/r32/esp - 9323 # result = false - 9324 b8/copy-to-eax 0/imm32/false - 9325 (rewind-stream *(ebp+8)) - 9326 { - 9327 (next-mu-token *(ebp+8) %ecx) - 9328 # if slice-empty?(word-slice) break - 9329 (slice-empty? %ecx) - 9330 3d/compare-eax-and 0/imm32/false - 9331 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) + 8145 test-parse-var-with-register-and-trailing-characters: + 8146 # . prologue + 8147 55/push-ebp + 8148 89/<- %ebp 4/r32/esp + 8149 # (eax..ecx) = "x/eax:" + 8150 b8/copy-to-eax "x/eax:"/imm32 + 8151 8b/-> *eax 1/r32/ecx + 8152 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8153 05/add-to-eax 4/imm32 + 8154 # var slice/ecx: slice = {eax, ecx} + 8155 51/push-ecx + 8156 50/push-eax + 8157 89/<- %ecx 4/r32/esp + 8158 # _test-input-stream contains "int," + 8159 (clear-stream _test-input-stream) + 8160 (write _test-input-stream "int,") + 8161 # var v/edx: (handle var) + 8162 68/push 0/imm32 + 8163 68/push 0/imm32 + 8164 89/<- %edx 4/r32/esp + 8165 # + 8166 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) + 8167 # var v-addr/edx: (addr var) = lookup(v) + 8168 (lookup *edx *(edx+4)) # => eax + 8169 89/<- %edx 0/r32/eax + 8170 # check v-addr->name + 8171 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 8172 (check-strings-equal %eax "x" "F - test-parse-var-with-register-and-trailing-characters/name") + 8173 # check v-addr->register + 8174 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 8175 (check-strings-equal %eax "eax" "F - test-parse-var-with-register-and-trailing-characters/register") + 8176 # check v-addr->type + 8177 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 8178 (check-ints-equal *eax 1 "F - test-parse-var-with-register-and-trailing-characters/type:0") # Type-tree-is-atom + 8179 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-register-and-trailing-characters/type:1") # Type-tree-left + 8180 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-register-and-trailing-characters/type:2") # Type-tree-right + 8181 # . epilogue + 8182 89/<- %esp 5/r32/ebp + 8183 5d/pop-to-ebp + 8184 c3/return + 8185 + 8186 test-parse-var-with-compound-type: + 8187 # . prologue + 8188 55/push-ebp + 8189 89/<- %ebp 4/r32/esp + 8190 # (eax..ecx) = "x:" + 8191 b8/copy-to-eax "x:"/imm32 + 8192 8b/-> *eax 1/r32/ecx + 8193 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8194 05/add-to-eax 4/imm32 + 8195 # var slice/ecx: slice = {eax, ecx} + 8196 51/push-ecx + 8197 50/push-eax + 8198 89/<- %ecx 4/r32/esp + 8199 # _test-input-stream contains "(addr int)" + 8200 (clear-stream _test-input-stream) + 8201 (write _test-input-stream "(addr int)") + 8202 # var v/edx: (handle var) + 8203 68/push 0/imm32 + 8204 68/push 0/imm32 + 8205 89/<- %edx 4/r32/esp + 8206 # + 8207 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) + 8208 # var v-addr/edx: (addr var) = lookup(v) + 8209 (lookup *edx *(edx+4)) # => eax + 8210 89/<- %edx 0/r32/eax + 8211 # check v-addr->name + 8212 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 8213 (check-strings-equal %eax "x" "F - test-parse-var-with-compound-type/name") + 8214 # check v-addr->register + 8215 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-compound-type/register") # Var-register + 8216 # - check v-addr->type + 8217 # var type/edx: (addr type-tree) = var->type + 8218 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 8219 89/<- %edx 0/r32/eax + 8220 # type is a non-atom + 8221 (check-ints-equal *edx 0 "F - test-parse-var-with-compound-type/type:0") # Type-tree-is-atom + 8222 # type->left == atom(addr) + 8223 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax + 8224 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:1") # Type-tree-is-atom + 8225 (check-ints-equal *(eax+4) 2 "F - test-parse-var-with-compound-type/type:2") # Type-tree-value + 8226 # type->right->left == atom(int) + 8227 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax + 8228 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax + 8229 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:3") # Type-tree-is-atom + 8230 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-compound-type/type:4") # Type-tree-value + 8231 # type->right->right == null + 8232 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-compound-type/type:5") # Type-tree-right + 8233 # . epilogue + 8234 89/<- %esp 5/r32/ebp + 8235 5d/pop-to-ebp + 8236 c3/return + 8237 + 8238 # identifier starts with a letter or '$' or '_' + 8239 # no constraints at the moment on later letters + 8240 # all we really want to do so far is exclude '{', '}' and '->' + 8241 is-identifier?: # in: (addr slice) -> result/eax: boolean + 8242 # . prologue + 8243 55/push-ebp + 8244 89/<- %ebp 4/r32/esp + 8245 # if (slice-empty?(in)) return false + 8246 (slice-empty? *(ebp+8)) # => eax + 8247 3d/compare-eax-and 0/imm32/false + 8248 75/jump-if-!= $is-identifier?:false/disp8 + 8249 # var c/eax: byte = *in->start + 8250 8b/-> *(ebp+8) 0/r32/eax + 8251 8b/-> *eax 0/r32/eax + 8252 8a/copy-byte *eax 0/r32/AL + 8253 81 4/subop/and %eax 0xff/imm32 + 8254 # if (c == '$') return true + 8255 3d/compare-eax-and 0x24/imm32/$ + 8256 74/jump-if-= $is-identifier?:true/disp8 + 8257 # if (c == '_') return true + 8258 3d/compare-eax-and 0x5f/imm32/_ + 8259 74/jump-if-= $is-identifier?:true/disp8 + 8260 # drop case + 8261 25/and-eax-with 0x5f/imm32 + 8262 # if (c < 'A') return false + 8263 3d/compare-eax-and 0x41/imm32/A + 8264 7c/jump-if-< $is-identifier?:false/disp8 + 8265 # if (c > 'Z') return false + 8266 3d/compare-eax-and 0x5a/imm32/Z + 8267 7f/jump-if-> $is-identifier?:false/disp8 + 8268 # otherwise return true + 8269 $is-identifier?:true: + 8270 b8/copy-to-eax 1/imm32/true + 8271 eb/jump $is-identifier?:end/disp8 + 8272 $is-identifier?:false: + 8273 b8/copy-to-eax 0/imm32/false + 8274 $is-identifier?:end: + 8275 # . epilogue + 8276 89/<- %esp 5/r32/ebp + 8277 5d/pop-to-ebp + 8278 c3/return + 8279 + 8280 test-is-identifier-dollar: + 8281 # . prologue + 8282 55/push-ebp + 8283 89/<- %ebp 4/r32/esp + 8284 # (eax..ecx) = "$a" + 8285 b8/copy-to-eax "$a"/imm32 + 8286 8b/-> *eax 1/r32/ecx + 8287 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8288 05/add-to-eax 4/imm32 + 8289 # var slice/ecx: slice = {eax, ecx} + 8290 51/push-ecx + 8291 50/push-eax + 8292 89/<- %ecx 4/r32/esp + 8293 # + 8294 (is-identifier? %ecx) + 8295 (check-ints-equal %eax 1 "F - test-is-identifier-dollar") + 8296 # . epilogue + 8297 89/<- %esp 5/r32/ebp + 8298 5d/pop-to-ebp + 8299 c3/return + 8300 + 8301 test-is-identifier-underscore: + 8302 # . prologue + 8303 55/push-ebp + 8304 89/<- %ebp 4/r32/esp + 8305 # (eax..ecx) = "_a" + 8306 b8/copy-to-eax "_a"/imm32 + 8307 8b/-> *eax 1/r32/ecx + 8308 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8309 05/add-to-eax 4/imm32 + 8310 # var slice/ecx: slice = {eax, ecx} + 8311 51/push-ecx + 8312 50/push-eax + 8313 89/<- %ecx 4/r32/esp + 8314 # + 8315 (is-identifier? %ecx) + 8316 (check-ints-equal %eax 1 "F - test-is-identifier-underscore") + 8317 # . epilogue + 8318 89/<- %esp 5/r32/ebp + 8319 5d/pop-to-ebp + 8320 c3/return + 8321 + 8322 test-is-identifier-a: + 8323 # . prologue + 8324 55/push-ebp + 8325 89/<- %ebp 4/r32/esp + 8326 # (eax..ecx) = "a$" + 8327 b8/copy-to-eax "a$"/imm32 + 8328 8b/-> *eax 1/r32/ecx + 8329 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8330 05/add-to-eax 4/imm32 + 8331 # var slice/ecx: slice = {eax, ecx} + 8332 51/push-ecx + 8333 50/push-eax + 8334 89/<- %ecx 4/r32/esp + 8335 # + 8336 (is-identifier? %ecx) + 8337 (check-ints-equal %eax 1 "F - test-is-identifier-a") + 8338 # . epilogue + 8339 89/<- %esp 5/r32/ebp + 8340 5d/pop-to-ebp + 8341 c3/return + 8342 + 8343 test-is-identifier-z: + 8344 # . prologue + 8345 55/push-ebp + 8346 89/<- %ebp 4/r32/esp + 8347 # (eax..ecx) = "z$" + 8348 b8/copy-to-eax "z$"/imm32 + 8349 8b/-> *eax 1/r32/ecx + 8350 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8351 05/add-to-eax 4/imm32 + 8352 # var slice/ecx: slice = {eax, ecx} + 8353 51/push-ecx + 8354 50/push-eax + 8355 89/<- %ecx 4/r32/esp + 8356 # + 8357 (is-identifier? %ecx) + 8358 (check-ints-equal %eax 1 "F - test-is-identifier-z") + 8359 # . epilogue + 8360 89/<- %esp 5/r32/ebp + 8361 5d/pop-to-ebp + 8362 c3/return + 8363 + 8364 test-is-identifier-A: + 8365 # . prologue + 8366 55/push-ebp + 8367 89/<- %ebp 4/r32/esp + 8368 # (eax..ecx) = "A$" + 8369 b8/copy-to-eax "A$"/imm32 + 8370 8b/-> *eax 1/r32/ecx + 8371 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8372 05/add-to-eax 4/imm32 + 8373 # var slice/ecx: slice = {eax, ecx} + 8374 51/push-ecx + 8375 50/push-eax + 8376 89/<- %ecx 4/r32/esp + 8377 # + 8378 (is-identifier? %ecx) + 8379 (check-ints-equal %eax 1 "F - test-is-identifier-A") + 8380 # . epilogue + 8381 89/<- %esp 5/r32/ebp + 8382 5d/pop-to-ebp + 8383 c3/return + 8384 + 8385 test-is-identifier-Z: + 8386 # . prologue + 8387 55/push-ebp + 8388 89/<- %ebp 4/r32/esp + 8389 # (eax..ecx) = "Z$" + 8390 b8/copy-to-eax "Z$"/imm32 + 8391 8b/-> *eax 1/r32/ecx + 8392 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8393 05/add-to-eax 4/imm32 + 8394 # var slice/ecx: slice = {eax, ecx} + 8395 51/push-ecx + 8396 50/push-eax + 8397 89/<- %ecx 4/r32/esp + 8398 # + 8399 (is-identifier? %ecx) + 8400 (check-ints-equal %eax 1 "F - test-is-identifier-Z") + 8401 # . epilogue + 8402 89/<- %esp 5/r32/ebp + 8403 5d/pop-to-ebp + 8404 c3/return + 8405 + 8406 test-is-identifier-at: + 8407 # character before 'A' is invalid + 8408 # . prologue + 8409 55/push-ebp + 8410 89/<- %ebp 4/r32/esp + 8411 # (eax..ecx) = "@a" + 8412 b8/copy-to-eax "@a"/imm32 + 8413 8b/-> *eax 1/r32/ecx + 8414 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8415 05/add-to-eax 4/imm32 + 8416 # var slice/ecx: slice = {eax, ecx} + 8417 51/push-ecx + 8418 50/push-eax + 8419 89/<- %ecx 4/r32/esp + 8420 # + 8421 (is-identifier? %ecx) + 8422 (check-ints-equal %eax 0 "F - test-is-identifier-@") + 8423 # . epilogue + 8424 89/<- %esp 5/r32/ebp + 8425 5d/pop-to-ebp + 8426 c3/return + 8427 + 8428 test-is-identifier-square-bracket: + 8429 # character after 'Z' is invalid + 8430 # . prologue + 8431 55/push-ebp + 8432 89/<- %ebp 4/r32/esp + 8433 # (eax..ecx) = "[a" + 8434 b8/copy-to-eax "[a"/imm32 + 8435 8b/-> *eax 1/r32/ecx + 8436 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8437 05/add-to-eax 4/imm32 + 8438 # var slice/ecx: slice = {eax, ecx} + 8439 51/push-ecx + 8440 50/push-eax + 8441 89/<- %ecx 4/r32/esp + 8442 # + 8443 (is-identifier? %ecx) + 8444 (check-ints-equal %eax 0 "F - test-is-identifier-@") + 8445 # . epilogue + 8446 89/<- %esp 5/r32/ebp + 8447 5d/pop-to-ebp + 8448 c3/return + 8449 + 8450 test-is-identifier-backtick: + 8451 # character before 'a' is invalid + 8452 # . prologue + 8453 55/push-ebp + 8454 89/<- %ebp 4/r32/esp + 8455 # (eax..ecx) = "`a" + 8456 b8/copy-to-eax "`a"/imm32 + 8457 8b/-> *eax 1/r32/ecx + 8458 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8459 05/add-to-eax 4/imm32 + 8460 # var slice/ecx: slice = {eax, ecx} + 8461 51/push-ecx + 8462 50/push-eax + 8463 89/<- %ecx 4/r32/esp + 8464 # + 8465 (is-identifier? %ecx) + 8466 (check-ints-equal %eax 0 "F - test-is-identifier-backtick") + 8467 # . epilogue + 8468 89/<- %esp 5/r32/ebp + 8469 5d/pop-to-ebp + 8470 c3/return + 8471 + 8472 test-is-identifier-curly-brace-open: + 8473 # character after 'z' is invalid; also used for blocks + 8474 # . prologue + 8475 55/push-ebp + 8476 89/<- %ebp 4/r32/esp + 8477 # (eax..ecx) = "{a" + 8478 b8/copy-to-eax "{a"/imm32 + 8479 8b/-> *eax 1/r32/ecx + 8480 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8481 05/add-to-eax 4/imm32 + 8482 # var slice/ecx: slice = {eax, ecx} + 8483 51/push-ecx + 8484 50/push-eax + 8485 89/<- %ecx 4/r32/esp + 8486 # + 8487 (is-identifier? %ecx) + 8488 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-open") + 8489 # . epilogue + 8490 89/<- %esp 5/r32/ebp + 8491 5d/pop-to-ebp + 8492 c3/return + 8493 + 8494 test-is-identifier-curly-brace-close: + 8495 # . prologue + 8496 55/push-ebp + 8497 89/<- %ebp 4/r32/esp + 8498 # (eax..ecx) = "}a" + 8499 b8/copy-to-eax "}a"/imm32 + 8500 8b/-> *eax 1/r32/ecx + 8501 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8502 05/add-to-eax 4/imm32 + 8503 # var slice/ecx: slice = {eax, ecx} + 8504 51/push-ecx + 8505 50/push-eax + 8506 89/<- %ecx 4/r32/esp + 8507 # + 8508 (is-identifier? %ecx) + 8509 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-close") + 8510 # . epilogue + 8511 89/<- %esp 5/r32/ebp + 8512 5d/pop-to-ebp + 8513 c3/return + 8514 + 8515 test-is-identifier-hyphen: + 8516 # disallow leading '-' since '->' has special meaning + 8517 # . prologue + 8518 55/push-ebp + 8519 89/<- %ebp 4/r32/esp + 8520 # (eax..ecx) = "-a" + 8521 b8/copy-to-eax "-a"/imm32 + 8522 8b/-> *eax 1/r32/ecx + 8523 8d/copy-address *(eax+ecx+4) 1/r32/ecx + 8524 05/add-to-eax 4/imm32 + 8525 # var slice/ecx: slice = {eax, ecx} + 8526 51/push-ecx + 8527 50/push-eax + 8528 89/<- %ecx 4/r32/esp + 8529 # + 8530 (is-identifier? %ecx) + 8531 (check-ints-equal %eax 0 "F - test-is-identifier-hyphen") + 8532 # . epilogue + 8533 89/<- %esp 5/r32/ebp + 8534 5d/pop-to-ebp + 8535 c3/return + 8536 + 8537 populate-mu-function-body: # in: (addr buffered-file), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) + 8538 # . prologue + 8539 55/push-ebp + 8540 89/<- %ebp 4/r32/esp + 8541 # . save registers + 8542 50/push-eax + 8543 56/push-esi + 8544 57/push-edi + 8545 # esi = in + 8546 8b/-> *(ebp+8) 6/r32/esi + 8547 # edi = out + 8548 8b/-> *(ebp+0xc) 7/r32/edi + 8549 # initialize some global state + 8550 c7 0/subop/copy *Curr-block-depth 1/imm32 + 8551 # parse-mu-block(in, vars, out, out->body) + 8552 8d/copy-address *(edi+0x18) 0/r32/eax # Function-body + 8553 (parse-mu-block %esi *(ebp+0x10) %edi %eax *(ebp+0x14) *(ebp+0x18)) + 8554 $populate-mu-function-body:end: + 8555 # . restore registers + 8556 5f/pop-to-edi + 8557 5e/pop-to-esi + 8558 58/pop-to-eax + 8559 # . epilogue + 8560 89/<- %esp 5/r32/ebp + 8561 5d/pop-to-ebp + 8562 c3/return + 8563 + 8564 # parses a block, assuming that the leading '{' has already been read by the caller + 8565 parse-mu-block: # in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle block), err: (addr buffered-file), ed: (addr exit-descriptor) + 8566 # pseudocode: + 8567 # var line: (stream byte 512) + 8568 # var word-slice: slice + 8569 # allocate(Heap, Stmt-size, out) + 8570 # var out-addr: (addr block) = lookup(*out) + 8571 # out-addr->tag = 0/block + 8572 # out-addr->var = some unique name + 8573 # push(vars, {out-addr->var, false}) + 8574 # while true # line loop + 8575 # clear-stream(line) + 8576 # read-line-buffered(in, line) + 8577 # if (line->write == 0) break # end of file + 8578 # word-slice = next-mu-token(line) + 8579 # if slice-empty?(word-slice) # end of line + 8580 # continue + 8581 # else if slice-starts-with?(word-slice, "#") + 8582 # continue + 8583 # else if slice-equal?(word-slice, "{") + 8584 # assert(no-tokens-in(line)) + 8585 # block = parse-mu-block(in, vars, fn) + 8586 # append-to-block(out-addr, block) + 8587 # else if slice-equal?(word-slice, "}") + 8588 # break + 8589 # else if slice-ends-with?(word-slice, ":") + 8590 # # TODO: error-check the rest of 'line' + 8591 # --word-slice->end to skip ':' + 8592 # named-block = parse-mu-named-block(word-slice, in, vars, fn) + 8593 # append-to-block(out-addr, named-block) + 8594 # else if slice-equal?(word-slice, "var") + 8595 # var-def = parse-mu-var-def(line, vars, fn) + 8596 # append-to-block(out-addr, var-def) + 8597 # else + 8598 # stmt = parse-mu-stmt(line, vars, fn) + 8599 # append-to-block(out-addr, stmt) + 8600 # pop(vars) + 8601 # + 8602 # . prologue + 8603 55/push-ebp + 8604 89/<- %ebp 4/r32/esp + 8605 # . save registers + 8606 50/push-eax + 8607 51/push-ecx + 8608 52/push-edx + 8609 53/push-ebx + 8610 57/push-edi + 8611 # var line/ecx: (stream byte 512) + 8612 81 5/subop/subtract %esp 0x200/imm32 + 8613 68/push 0x200/imm32/size + 8614 68/push 0/imm32/read + 8615 68/push 0/imm32/write + 8616 89/<- %ecx 4/r32/esp + 8617 # var word-slice/edx: slice + 8618 68/push 0/imm32/end + 8619 68/push 0/imm32/start + 8620 89/<- %edx 4/r32/esp + 8621 # allocate into out + 8622 (allocate Heap *Stmt-size *(ebp+0x14)) + 8623 # var out-addr/edi: (addr block) = lookup(*out) + 8624 8b/-> *(ebp+0x14) 7/r32/edi + 8625 (lookup *edi *(edi+4)) # => eax + 8626 89/<- %edi 0/r32/eax + 8627 # out-addr->tag is 0 (block) by default + 8628 # set out-addr->var + 8629 8d/copy-address *(edi+0xc) 0/r32/eax # Block-var + 8630 (new-block-name *(ebp+0x10) %eax) + 8631 # push(vars, out-addr->var) + 8632 (push *(ebp+0xc) *(edi+0xc)) # Block-var + 8633 (push *(ebp+0xc) *(edi+0x10)) # Block-var + 8634 (push *(ebp+0xc) 0) # false + 8635 # increment *Curr-block-depth + 8636 ff 0/subop/increment *Curr-block-depth + 8637 { + 8638 $parse-mu-block:line-loop: + 8639 # line = read-line-buffered(in) + 8640 (clear-stream %ecx) + 8641 (read-line-buffered *(ebp+8) %ecx) + 8642 #? (write-buffered Stderr "line: ") + 8643 #? (write-stream-data Stderr %ecx) + 8644 #? #? (write-buffered Stderr Newline) # line has its own newline + 8645 #? (flush Stderr) + 8646 #? (rewind-stream %ecx) + 8647 # if (line->write == 0) break + 8648 81 7/subop/compare *ecx 0/imm32 + 8649 0f 84/jump-if-= break/disp32 + 8650 #? (write-buffered Stderr "vars:\n") + 8651 #? (dump-vars *(ebp+0xc)) + 8652 # word-slice = next-mu-token(line) + 8653 (next-mu-token %ecx %edx) + 8654 #? (write-buffered Stderr "word: ") + 8655 #? (write-slice-buffered Stderr %edx) + 8656 #? (write-buffered Stderr Newline) + 8657 #? (flush Stderr) + 8658 # if slice-empty?(word-slice) continue + 8659 (slice-empty? %edx) + 8660 3d/compare-eax-and 0/imm32/false + 8661 0f 85/jump-if-!= loop/disp32 + 8662 # if (slice-starts-with?(word-slice, '#') continue + 8663 # . eax = *word-slice->start + 8664 8b/-> *edx 0/r32/eax + 8665 8a/copy-byte *eax 0/r32/AL + 8666 81 4/subop/and %eax 0xff/imm32 + 8667 # . if (eax == '#') continue + 8668 3d/compare-eax-and 0x23/imm32/hash + 8669 0f 84/jump-if-= loop/disp32 + 8670 # if slice-equal?(word-slice, "{") + 8671 { + 8672 $parse-mu-block:check-for-block: + 8673 (slice-equal? %edx "{") + 8674 3d/compare-eax-and 0/imm32/false + 8675 74/jump-if-= break/disp8 + 8676 (check-no-tokens-left %ecx) + 8677 # parse new block and append + 8678 # . var tmp/eax: (handle block) + 8679 68/push 0/imm32 + 8680 68/push 0/imm32 + 8681 89/<- %eax 4/r32/esp + 8682 # . + 8683 (parse-mu-block *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) + 8684 (append-to-block Heap %edi *eax *(eax+4)) + 8685 # . reclaim tmp + 8686 81 0/subop/add %esp 8/imm32 + 8687 # . + 8688 e9/jump $parse-mu-block:line-loop/disp32 + 8689 } + 8690 # if slice-equal?(word-slice, "}") break + 8691 $parse-mu-block:check-for-end: + 8692 (slice-equal? %edx "}") + 8693 3d/compare-eax-and 0/imm32/false + 8694 0f 85/jump-if-!= break/disp32 + 8695 # if slice-ends-with?(word-slice, ":") parse named block and append + 8696 { + 8697 $parse-mu-block:check-for-named-block: + 8698 # . eax = *(word-slice->end-1) + 8699 8b/-> *(edx+4) 0/r32/eax + 8700 48/decrement-eax + 8701 8a/copy-byte *eax 0/r32/AL + 8702 81 4/subop/and %eax 0xff/imm32 + 8703 # . if (eax != ':') break + 8704 3d/compare-eax-and 0x3a/imm32/colon + 8705 0f 85/jump-if-!= break/disp32 + 8706 # TODO: error-check the rest of 'line' + 8707 # + 8708 # skip ':' + 8709 ff 1/subop/decrement *(edx+4) # Slice-end + 8710 # var tmp/eax: (handle block) + 8711 68/push 0/imm32 + 8712 68/push 0/imm32 + 8713 89/<- %eax 4/r32/esp + 8714 # + 8715 (parse-mu-named-block %edx *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) + 8716 (append-to-block Heap %edi *eax *(eax+4)) + 8717 # reclaim tmp + 8718 81 0/subop/add %esp 8/imm32 + 8719 # + 8720 e9/jump $parse-mu-block:line-loop/disp32 + 8721 } + 8722 # if slice-equal?(word-slice, "var") + 8723 { + 8724 $parse-mu-block:check-for-var: + 8725 (slice-equal? %edx "var") + 8726 3d/compare-eax-and 0/imm32/false + 8727 74/jump-if-= break/disp8 + 8728 # var tmp/eax: (handle block) + 8729 68/push 0/imm32 + 8730 68/push 0/imm32 + 8731 89/<- %eax 4/r32/esp + 8732 # + 8733 (parse-mu-var-def %ecx *(ebp+0xc) %eax *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) + 8734 (append-to-block Heap %edi *eax *(eax+4)) + 8735 # reclaim tmp + 8736 81 0/subop/add %esp 8/imm32 + 8737 # + 8738 e9/jump $parse-mu-block:line-loop/disp32 + 8739 } + 8740 $parse-mu-block:regular-stmt: + 8741 # otherwise + 8742 # var tmp/eax: (handle block) + 8743 68/push 0/imm32 + 8744 68/push 0/imm32 + 8745 89/<- %eax 4/r32/esp + 8746 # + 8747 (parse-mu-stmt %ecx *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) + 8748 (append-to-block Heap %edi *eax *(eax+4)) + 8749 # reclaim tmp + 8750 81 0/subop/add %esp 8/imm32 + 8751 # + 8752 e9/jump loop/disp32 + 8753 } # end line loop + 8754 (clean-up-blocks *(ebp+0xc) *Curr-block-depth *(ebp+0x10)) + 8755 # decrement *Curr-block-depth + 8756 ff 1/subop/decrement *Curr-block-depth + 8757 # pop(vars) + 8758 (pop *(ebp+0xc)) # => eax + 8759 (pop *(ebp+0xc)) # => eax + 8760 (pop *(ebp+0xc)) # => eax + 8761 $parse-mu-block:end: + 8762 # . reclaim locals + 8763 81 0/subop/add %esp 0x214/imm32 + 8764 # . restore registers + 8765 5f/pop-to-edi + 8766 5b/pop-to-ebx + 8767 5a/pop-to-edx + 8768 59/pop-to-ecx + 8769 58/pop-to-eax + 8770 # . epilogue + 8771 89/<- %esp 5/r32/ebp + 8772 5d/pop-to-ebp + 8773 c3/return + 8774 + 8775 $parse-mu-block:abort: + 8776 # error("'{' or '}' should be on its own line, but got '") + 8777 (write-buffered *(ebp+0x18) "'{' or '}' should be on its own line, but got '") + 8778 (rewind-stream %ecx) + 8779 (write-stream-data *(ebp+0x18) %ecx) + 8780 (write-buffered *(ebp+0x18) "'\n") + 8781 (flush *(ebp+0x18)) + 8782 (stop *(ebp+0x1c) 1) + 8783 # never gets here + 8784 + 8785 new-block-name: # fn: (addr function), out: (addr handle var) + 8786 # . prologue + 8787 55/push-ebp + 8788 89/<- %ebp 4/r32/esp + 8789 # . save registers + 8790 50/push-eax + 8791 51/push-ecx + 8792 52/push-edx + 8793 # var n/ecx: int = len(fn->name) + 10 for an int + 2 for '$:' + 8794 8b/-> *(ebp+8) 0/r32/eax + 8795 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 8796 8b/-> *eax 0/r32/eax # String-size + 8797 05/add-to-eax 0xd/imm32 # 10 + 2 for '$:' + 8798 89/<- %ecx 0/r32/eax + 8799 # var name/edx: (stream byte n) + 8800 29/subtract-from %esp 1/r32/ecx + 8801 ff 6/subop/push %ecx + 8802 68/push 0/imm32/read + 8803 68/push 0/imm32/write + 8804 89/<- %edx 4/r32/esp + 8805 (clear-stream %edx) + 8806 # eax = fn->name + 8807 8b/-> *(ebp+8) 0/r32/eax + 8808 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 8809 # construct result using Next-block-index (and increment it) + 8810 (write %edx "$") + 8811 (write %edx %eax) + 8812 (write %edx ":") + 8813 (write-int32-hex %edx *Next-block-index) + 8814 ff 0/subop/increment *Next-block-index + 8815 # var s/eax: slice = {name->data, name->data + name->write} (clobbering edx) + 8816 # . eax = name->write + 8817 8b/-> *edx 0/r32/eax + 8818 # . edx = name->data + 8819 8d/copy-address *(edx+0xc) 2/r32/edx + 8820 # . eax = name->write + name->data + 8821 01/add-to %eax 2/r32/edx + 8822 # . push {edx, eax} + 8823 ff 6/subop/push %eax + 8824 ff 6/subop/push %edx + 8825 89/<- %eax 4/r32/esp + 8826 # out = new literal(s) + 8827 (new-literal Heap %eax *(ebp+0xc)) + 8828 #? 8b/-> *(ebp+0xc) 0/r32/eax + 8829 #? (write-buffered Stderr "type allocid in caller after new-literal: ") + 8830 #? (write-int32-hex-buffered Stderr *(eax+8)) + 8831 #? (write-buffered Stderr " for var ") + 8832 #? (write-int32-hex-buffered Stderr %eax) + 8833 #? (write-buffered Stderr Newline) + 8834 #? (flush Stderr) + 8835 $new-block-name:end: + 8836 # . reclaim locals + 8837 81 0/subop/add %ecx 0xc/imm32 # name.{read/write/len} + 8838 81 0/subop/add %ecx 8/imm32 # slice + 8839 01/add-to %esp 1/r32/ecx + 8840 # . restore registers + 8841 5a/pop-to-edx + 8842 59/pop-to-ecx + 8843 58/pop-to-eax + 8844 # . epilogue + 8845 89/<- %esp 5/r32/ebp + 8846 5d/pop-to-ebp + 8847 c3/return + 8848 + 8849 check-no-tokens-left: # line: (addr stream byte) + 8850 # . prologue + 8851 55/push-ebp + 8852 89/<- %ebp 4/r32/esp + 8853 # . save registers + 8854 50/push-eax + 8855 51/push-ecx + 8856 # var s/ecx: slice + 8857 68/push 0/imm32/end + 8858 68/push 0/imm32/start + 8859 89/<- %ecx 4/r32/esp + 8860 # + 8861 (next-mu-token *(ebp+8) %ecx) + 8862 # if slice-empty?(s) return + 8863 (slice-empty? %ecx) + 8864 3d/compare-eax-and 0/imm32/false + 8865 75/jump-if-!= $check-no-tokens-left:end/disp8 + 8866 # if (slice-starts-with?(s, '#') return + 8867 # . eax = *s->start + 8868 8b/-> *edx 0/r32/eax + 8869 8a/copy-byte *eax 0/r32/AL + 8870 81 4/subop/and %eax 0xff/imm32 + 8871 # . if (eax == '#') continue + 8872 3d/compare-eax-and 0x23/imm32/hash + 8873 74/jump-if-= $check-no-tokens-left:end/disp8 + 8874 # abort + 8875 (write-buffered Stderr "'{' or '}' should be on its own line, but got '") + 8876 (rewind-stream %ecx) + 8877 (write-stream 2 %ecx) + 8878 (write-buffered Stderr "'\n") + 8879 (flush Stderr) + 8880 # . syscall(exit, 1) + 8881 bb/copy-to-ebx 1/imm32 + 8882 e8/call syscall_exit/disp32 + 8883 # never gets here + 8884 $check-no-tokens-left:end: + 8885 # . reclaim locals + 8886 81 0/subop/add %esp 8/imm32 + 8887 # . restore registers + 8888 59/pop-to-ecx + 8889 58/pop-to-eax + 8890 # . epilogue + 8891 89/<- %esp 5/r32/ebp + 8892 5d/pop-to-ebp + 8893 c3/return + 8894 + 8895 parse-mu-named-block: # name: (addr slice), in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) + 8896 # pseudocode: + 8897 # var v: (handle var) + 8898 # new-literal(name, v) + 8899 # push(vars, {v, false}) + 8900 # parse-mu-block(in, vars, fn, out) + 8901 # pop(vars) + 8902 # out->tag = block + 8903 # out->var = v + 8904 # + 8905 # . prologue + 8906 55/push-ebp + 8907 89/<- %ebp 4/r32/esp + 8908 # . save registers + 8909 50/push-eax + 8910 51/push-ecx + 8911 57/push-edi + 8912 # var v/ecx: (handle var) + 8913 68/push 0/imm32 + 8914 68/push 0/imm32 + 8915 89/<- %ecx 4/r32/esp + 8916 # + 8917 (new-literal Heap *(ebp+8) %ecx) + 8918 # push(vars, v) + 8919 (push *(ebp+0x10) *ecx) + 8920 (push *(ebp+0x10) *(ecx+4)) + 8921 (push *(ebp+0x10) 0) # false + 8922 # + 8923 (parse-mu-block *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c) *(ebp+0x20)) + 8924 # pop v off vars + 8925 (pop *(ebp+0x10)) # => eax + 8926 (pop *(ebp+0x10)) # => eax + 8927 (pop *(ebp+0x10)) # => eax + 8928 # var out-addr/edi: (addr stmt) = lookup(*out) + 8929 8b/-> *(ebp+0x18) 7/r32/edi + 8930 (lookup *edi *(edi+4)) # => eax + 8931 89/<- %edi 0/r32/eax + 8932 # out-addr->tag = named-block + 8933 c7 0/subop/copy *edi 0/imm32/block # Stmt-tag + 8934 # out-addr->var = v + 8935 8b/-> *ecx 0/r32/eax + 8936 89/<- *(edi+0xc) 0/r32/eax # Block-var + 8937 8b/-> *(ecx+4) 0/r32/eax + 8938 89/<- *(edi+0x10) 0/r32/eax # Block-var + 8939 $parse-mu-named-block:end: + 8940 # . reclaim locals + 8941 81 0/subop/add %esp 8/imm32 + 8942 # . restore registers + 8943 5f/pop-to-edi + 8944 59/pop-to-ecx + 8945 58/pop-to-eax + 8946 # . epilogue + 8947 89/<- %esp 5/r32/ebp + 8948 5d/pop-to-ebp + 8949 c3/return + 8950 + 8951 parse-mu-var-def: # line: (addr stream byte), vars: (addr stack live-var), out: (addr handle stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 8952 # . prologue + 8953 55/push-ebp + 8954 89/<- %ebp 4/r32/esp + 8955 # . save registers + 8956 50/push-eax + 8957 51/push-ecx + 8958 52/push-edx + 8959 53/push-ebx + 8960 57/push-edi + 8961 # edi = out + 8962 8b/-> *(ebp+0x10) 7/r32/edi + 8963 # var word-slice/ecx: slice + 8964 68/push 0/imm32/end + 8965 68/push 0/imm32/start + 8966 89/<- %ecx 4/r32/esp + 8967 # var v/edx: (handle var) + 8968 68/push 0/imm32 + 8969 68/push 0/imm32 + 8970 89/<- %edx 4/r32/esp + 8971 # v = parse-var-with-type(next-mu-token(line)) + 8972 (next-mu-token *(ebp+8) %ecx) + 8973 (parse-var-with-type %ecx *(ebp+8) %edx *(ebp+0x18) *(ebp+0x1c)) + 8974 # var v-addr/eax: (addr var) + 8975 (lookup *edx *(edx+4)) # => eax + 8976 # v->block-depth = *Curr-block-depth + 8977 8b/-> *Curr-block-depth 3/r32/ebx + 8978 89/<- *(eax+0x10) 3/r32/ebx # Var-block-depth + 8979 # either v has no register and there's no more to this line + 8980 8b/-> *(eax+0x18) 0/r32/eax # Var-register + 8981 3d/compare-eax-and 0/imm32 + 8982 { + 8983 75/jump-if-!= break/disp8 + 8984 # TODO: disallow vars of type 'byte' on the stack + 8985 # ensure that there's nothing else on this line + 8986 (next-mu-token *(ebp+8) %ecx) + 8987 (slice-empty? %ecx) # => eax + 8988 3d/compare-eax-and 0/imm32/false + 8989 0f 84/jump-if-= $parse-mu-var-def:error2/disp32 + 8990 # + 8991 (new-var-def Heap *edx *(edx+4) %edi) + 8992 e9/jump $parse-mu-var-def:update-vars/disp32 + 8993 } + 8994 # or v has a register and there's more to this line + 8995 { + 8996 0f 84/jump-if-= break/disp32 + 8997 # TODO: disallow vars of type 'byte' in registers 'esi' or 'edi' + 8998 # TODO: vars of type 'byte' should only be initialized by clearing to 0 + 8999 # ensure that the next word is '<-' + 9000 (next-mu-token *(ebp+8) %ecx) + 9001 (slice-equal? %ecx "<-") # => eax + 9002 3d/compare-eax-and 0/imm32/false + 9003 0f 84/jump-if-= $parse-mu-var-def:error1/disp32 + 9004 # + 9005 (new-reg-var-def Heap *edx *(edx+4) %edi) + 9006 (lookup *edi *(edi+4)) # => eax + 9007 (add-operation-and-inputs-to-stmt %eax *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) + 9008 } + 9009 $parse-mu-var-def:update-vars: + 9010 # push 'v' at end of function + 9011 (push *(ebp+0xc) *edx) + 9012 (push *(ebp+0xc) *(edx+4)) + 9013 (push *(ebp+0xc) 0) # Live-var-register-spilled is unused during parsing + 9014 $parse-mu-var-def:end: + 9015 # . reclaim locals + 9016 81 0/subop/add %esp 0x10/imm32 + 9017 # . restore registers + 9018 5f/pop-to-edi + 9019 5b/pop-to-ebx + 9020 5a/pop-to-edx + 9021 59/pop-to-ecx + 9022 58/pop-to-eax + 9023 # . epilogue + 9024 89/<- %esp 5/r32/ebp + 9025 5d/pop-to-ebp + 9026 c3/return + 9027 + 9028 $parse-mu-var-def:error1: + 9029 (rewind-stream *(ebp+8)) + 9030 # error("register variable requires a valid instruction to initialize but got '" line "'\n") + 9031 (write-buffered *(ebp+0x18) "register variable requires a valid instruction to initialize but got '") + 9032 (flush *(ebp+0x18)) + 9033 (write-stream-data *(ebp+0x18) *(ebp+8)) + 9034 (write-buffered *(ebp+0x18) "'\n") + 9035 (flush *(ebp+0x18)) + 9036 (stop *(ebp+0x1c) 1) + 9037 # never gets here + 9038 + 9039 $parse-mu-var-def:error2: + 9040 (rewind-stream *(ebp+8)) + 9041 # error("fn " fn ": var " var ": variables on the stack can't take an initializer\n") + 9042 (write-buffered *(ebp+0x18) "fn ") + 9043 8b/-> *(ebp+0x14) 0/r32/eax + 9044 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9045 (write-buffered *(ebp+0x18) %eax) + 9046 (write-buffered *(ebp+0x18) ": var ") + 9047 # var v-addr/eax: (addr var) = lookup(v) + 9048 (lookup *edx *(edx+4)) # => eax + 9049 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 9050 (write-buffered *(ebp+0x18) %eax) + 9051 (write-buffered *(ebp+0x18) ": variables on the stack can't take an initializer\n") + 9052 (flush *(ebp+0x18)) + 9053 (stop *(ebp+0x1c) 1) + 9054 # never gets here + 9055 + 9056 test-parse-mu-var-def: + 9057 # 'var n: int' + 9058 # . prologue + 9059 55/push-ebp + 9060 89/<- %ebp 4/r32/esp + 9061 # setup + 9062 (clear-stream _test-input-stream) + 9063 (write _test-input-stream "n: int\n") # caller has consumed the 'var' + 9064 c7 0/subop/copy *Curr-block-depth 1/imm32 + 9065 # var out/esi: (handle stmt) + 9066 68/push 0/imm32 + 9067 68/push 0/imm32 + 9068 89/<- %esi 4/r32/esp + 9069 # var vars/ecx: (stack (addr var) 16) + 9070 81 5/subop/subtract %esp 0xc0/imm32 + 9071 68/push 0xc0/imm32/size + 9072 68/push 0/imm32/top + 9073 89/<- %ecx 4/r32/esp + 9074 (clear-stack %ecx) + 9075 # convert + 9076 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) + 9077 # var out-addr/esi: (addr stmt) + 9078 (lookup *esi *(esi+4)) # => eax + 9079 89/<- %esi 0/r32/eax + 9080 # + 9081 (check-ints-equal *esi 2 "F - test-parse-mu-var-def/tag") # Stmt-tag is var-def + 9082 # var v/ecx: (addr var) = lookup(out->var) + 9083 (lookup *(esi+4) *(esi+8)) # Vardef-var Vardef-var => eax + 9084 89/<- %ecx 0/r32/eax + 9085 # v->name + 9086 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax + 9087 (check-strings-equal %eax "n" "F - test-parse-mu-var-def/var-name") + 9088 # v->register + 9089 (check-ints-equal *(ecx+0x18) 0 "F - test-parse-mu-var-def/var-register") # Var-register + 9090 # v->block-depth + 9091 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-var-def/output-block-depth") # Var-block-depth + 9092 # v->type == int + 9093 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax + 9094 (check-ints-equal *eax 1 "F - test-parse-mu-var-def/var-type:0") # Type-tree-is-atom + 9095 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-var-def/var-type:1") # Type-tree-value + 9096 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-var-def/var-type:2") # Type-tree-right + 9097 # . epilogue + 9098 89/<- %esp 5/r32/ebp + 9099 5d/pop-to-ebp + 9100 c3/return + 9101 + 9102 test-parse-mu-reg-var-def: + 9103 # 'var n/eax: int <- copy 0' + 9104 # . prologue + 9105 55/push-ebp + 9106 89/<- %ebp 4/r32/esp + 9107 # setup + 9108 (clear-stream _test-input-stream) + 9109 (write _test-input-stream "n/eax: int <- copy 0\n") # caller has consumed the 'var' + 9110 c7 0/subop/copy *Curr-block-depth 1/imm32 + 9111 # var out/esi: (handle stmt) + 9112 68/push 0/imm32 + 9113 68/push 0/imm32 + 9114 89/<- %esi 4/r32/esp + 9115 # var vars/ecx: (stack (addr var) 16) + 9116 81 5/subop/subtract %esp 0xc0/imm32 + 9117 68/push 0xc0/imm32/size + 9118 68/push 0/imm32/top + 9119 89/<- %ecx 4/r32/esp + 9120 (clear-stack %ecx) + 9121 # convert + 9122 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) + 9123 # var out-addr/esi: (addr stmt) + 9124 (lookup *esi *(esi+4)) # => eax + 9125 89/<- %esi 0/r32/eax + 9126 # + 9127 (check-ints-equal *esi 3 "F - test-parse-mu-reg-var-def/tag") # Stmt-tag is reg-var-def + 9128 # var v/ecx: (addr var) = lookup(out->outputs->value) + 9129 # . eax: (addr stmt-var) = lookup(out->outputs) + 9130 (lookup *(esi+0x14) *(esi+0x18)) # Regvardef-outputs Regvardef-outputs => eax + 9131 # . + 9132 (check-ints-equal *(eax+8) 0 "F - test-parse-mu-reg-var-def/single-output") # Stmt-var-next + 9133 # . eax: (addr var) = lookup(eax->value) + 9134 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9135 # . ecx = eax + 9136 89/<- %ecx 0/r32/eax + 9137 # v->name + 9138 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax + 9139 (check-strings-equal %eax "n" "F - test-parse-mu-reg-var-def/output-name") # Var-name + 9140 # v->register + 9141 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax + 9142 (check-strings-equal %eax "eax" "F - test-parse-mu-reg-var-def/output-register") + 9143 # v->block-depth + 9144 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-reg-var-def/output-block-depth") # Var-block-depth + 9145 # v->type == int + 9146 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax + 9147 (check-ints-equal *eax 1 "F - test-parse-mu-reg-var-def/output-type:0") # Type-tree-is-atom + 9148 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-reg-var-def/output-type:1") # Type-tree-value + 9149 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-reg-var-def/output-type:2") # Type-tree-right + 9150 # . epilogue + 9151 89/<- %esp 5/r32/ebp + 9152 5d/pop-to-ebp + 9153 c3/return + 9154 + 9155 parse-mu-stmt: # line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) + 9156 # Carefully push any outputs on the vars stack _after_ reading the inputs + 9157 # that may conflict with them. + 9158 # + 9159 # The only situation in which outputs are pushed here (when it's not a + 9160 # 'var' vardef stmt), and so can possibly conflict with inputs, is if the + 9161 # output is a function output. + 9162 # + 9163 # pseudocode: + 9164 # var name: slice + 9165 # allocate(Heap, Stmt-size, out) + 9166 # var out-addr: (addr stmt) = lookup(*out) + 9167 # out-addr->tag = stmt + 9168 # if stmt-has-outputs?(line) + 9169 # while true + 9170 # name = next-mu-token(line) + 9171 # if (name == '<-') break + 9172 # assert(is-identifier?(name)) + 9173 # var v: (handle var) = lookup-var-or-find-in-fn-outputs(name, vars, fn) + 9174 # out-addr->outputs = append(v, out-addr->outputs) + 9175 # add-operation-and-inputs-to-stmt(out-addr, line, vars) + 9176 # for output in stmt->outputs: + 9177 # maybe-define-var(output, vars) + 9178 # + 9179 # . prologue + 9180 55/push-ebp + 9181 89/<- %ebp 4/r32/esp + 9182 # . save registers + 9183 50/push-eax + 9184 51/push-ecx + 9185 52/push-edx + 9186 53/push-ebx + 9187 57/push-edi + 9188 # var name/ecx: slice + 9189 68/push 0/imm32/end + 9190 68/push 0/imm32/start + 9191 89/<- %ecx 4/r32/esp + 9192 # var is-deref?/edx: boolean = false + 9193 ba/copy-to-edx 0/imm32/false + 9194 # var v: (handle var) + 9195 68/push 0/imm32 + 9196 68/push 0/imm32 + 9197 89/<- %ebx 4/r32/esp + 9198 # + 9199 (allocate Heap *Stmt-size *(ebp+0x14)) + 9200 # var out-addr/edi: (addr stmt) = lookup(*out) + 9201 8b/-> *(ebp+0x14) 7/r32/edi + 9202 (lookup *edi *(edi+4)) # => eax + 9203 89/<- %edi 0/r32/eax + 9204 # out-addr->tag = 1/stmt + 9205 c7 0/subop/copy *edi 1/imm32/stmt1 # Stmt-tag + 9206 { + 9207 (stmt-has-outputs? *(ebp+8)) + 9208 3d/compare-eax-and 0/imm32/false + 9209 0f 84/jump-if-= break/disp32 + 9210 { + 9211 $parse-mu-stmt:read-outputs: + 9212 # name = next-mu-token(line) + 9213 (next-mu-token *(ebp+8) %ecx) + 9214 # if slice-empty?(word-slice) break + 9215 (slice-empty? %ecx) # => eax + 9216 3d/compare-eax-and 0/imm32/false + 9217 0f 85/jump-if-!= break/disp32 + 9218 # if (name == "<-") break + 9219 (slice-equal? %ecx "<-") # => eax + 9220 3d/compare-eax-and 0/imm32/false + 9221 0f 85/jump-if-!= break/disp32 + 9222 # is-deref? = false + 9223 ba/copy-to-edx 0/imm32/false + 9224 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? + 9225 8b/-> *ecx 0/r32/eax # Slice-start + 9226 8a/copy-byte *eax 0/r32/AL + 9227 81 4/subop/and %eax 0xff/imm32 + 9228 3d/compare-eax-and 0x2a/imm32/asterisk + 9229 { + 9230 75/jump-if-!= break/disp8 + 9231 ff 0/subop/increment *ecx + 9232 ba/copy-to-edx 1/imm32/true + 9233 } + 9234 # assert(is-identifier?(name)) + 9235 (is-identifier? %ecx) # => eax + 9236 3d/compare-eax-and 0/imm32/false + 9237 0f 84/jump-if-= $parse-mu-stmt:abort/disp32 + 9238 # + 9239 (lookup-var-or-find-in-fn-outputs %ecx *(ebp+0xc) *(ebp+0x10) %ebx *(ebp+0x18) *(ebp+0x1c)) + 9240 8d/copy-address *(edi+0x14) 0/r32/eax # Stmt1-outputs + 9241 (append-stmt-var Heap *ebx *(ebx+4) *(edi+0x14) *(edi+0x18) %edx %eax) # Stmt1-outputs + 9242 # + 9243 e9/jump loop/disp32 + 9244 } + 9245 } + 9246 (add-operation-and-inputs-to-stmt %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) + 9247 $parse-mu-stmt:define-outputs: + 9248 # var output/edi: (addr stmt-var) = lookup(out-addr->outputs) + 9249 (lookup *(edi+0x14) *(edi+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9250 89/<- %edi 0/r32/eax + 9251 { + 9252 $parse-mu-stmt:define-outputs-loop: + 9253 # if (output == null) break + 9254 81 7/subop/compare %edi 0/imm32 + 9255 74/jump-if-= break/disp8 + 9256 # + 9257 (maybe-define-var *edi *(edi+4) *(ebp+0xc)) # if output is a deref, then it's already been defined, + 9258 # and must be in vars. This call will be a no-op, but safe. + 9259 # output = output->next + 9260 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax + 9261 89/<- %edi 0/r32/eax + 9262 # + 9263 eb/jump loop/disp8 + 9264 } + 9265 $parse-mu-stmt:end: + 9266 # . reclaim locals + 9267 81 0/subop/add %esp 0x10/imm32 + 9268 # . restore registers + 9269 5f/pop-to-edi + 9270 5b/pop-to-ebx + 9271 5a/pop-to-edx + 9272 59/pop-to-ecx + 9273 58/pop-to-eax + 9274 # . epilogue + 9275 89/<- %esp 5/r32/ebp + 9276 5d/pop-to-ebp + 9277 c3/return + 9278 + 9279 $parse-mu-stmt:abort: + 9280 # error("invalid identifier '" name "'\n") + 9281 (write-buffered *(ebp+0x18) "invalid identifier '") + 9282 (write-slice-buffered *(ebp+0x18) %ecx) + 9283 (write-buffered *(ebp+0x18) "'\n") + 9284 (flush *(ebp+0x18)) + 9285 (stop *(ebp+0x1c) 1) + 9286 # never gets here + 9287 + 9288 add-operation-and-inputs-to-stmt: # stmt: (addr stmt), line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 9289 # pseudocode: + 9290 # stmt->name = slice-to-string(next-mu-token(line)) + 9291 # while true + 9292 # name = next-mu-token(line) + 9293 # v = lookup-var-or-literal(name) + 9294 # stmt->inouts = append(v, stmt->inouts) + 9295 # + 9296 # . prologue + 9297 55/push-ebp + 9298 89/<- %ebp 4/r32/esp + 9299 # . save registers + 9300 50/push-eax + 9301 51/push-ecx + 9302 52/push-edx + 9303 53/push-ebx + 9304 56/push-esi + 9305 57/push-edi + 9306 # edi = stmt + 9307 8b/-> *(ebp+8) 7/r32/edi + 9308 # var name/ecx: slice + 9309 68/push 0/imm32/end + 9310 68/push 0/imm32/start + 9311 89/<- %ecx 4/r32/esp + 9312 # var is-deref?/edx: boolean = false + 9313 ba/copy-to-edx 0/imm32/false + 9314 # var v/esi: (handle var) + 9315 68/push 0/imm32 + 9316 68/push 0/imm32 + 9317 89/<- %esi 4/r32/esp + 9318 $add-operation-and-inputs-to-stmt:read-operation: + 9319 (next-mu-token *(ebp+0xc) %ecx) + 9320 8d/copy-address *(edi+4) 0/r32/eax # Stmt1-operation or Regvardef-operationStmt1-operation or Regvardef-operation + 9321 (slice-to-string Heap %ecx %eax) + 9322 # var is-get?/ebx: boolean = (name == "get") + 9323 (slice-equal? %ecx "get") # => eax + 9324 89/<- %ebx 0/r32/eax + 9325 { + 9326 $add-operation-and-inputs-to-stmt:read-inouts: + 9327 # name = next-mu-token(line) + 9328 (next-mu-token *(ebp+0xc) %ecx) + 9329 # if slice-empty?(word-slice) break + 9330 (slice-empty? %ecx) # => eax + 9331 3d/compare-eax-and 0/imm32/false 9332 0f 85/jump-if-!= break/disp32 - 9333 # if slice-starts-with?(word-slice, '#') break - 9334 # . eax = *word-slice->start - 9335 8b/-> *ecx 0/r32/eax - 9336 8a/copy-byte *eax 0/r32/AL - 9337 81 4/subop/and %eax 0xff/imm32 - 9338 # . if (eax == '#') break - 9339 3d/compare-eax-and 0x23/imm32/hash - 9340 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) - 9341 0f 84/jump-if-= break/disp32 - 9342 # if slice-equal?(word-slice, '<-') return true - 9343 (slice-equal? %ecx "<-") - 9344 3d/compare-eax-and 0/imm32/false - 9345 74/jump-if-= loop/disp8 - 9346 b8/copy-to-eax 1/imm32/true - 9347 } - 9348 $stmt-has-outputs:end: - 9349 (rewind-stream *(ebp+8)) - 9350 # . reclaim locals - 9351 81 0/subop/add %esp 8/imm32 - 9352 # . restore registers - 9353 59/pop-to-ecx - 9354 # . epilogue - 9355 89/<- %esp 5/r32/ebp - 9356 5d/pop-to-ebp - 9357 c3/return - 9358 - 9359 # if 'name' starts with a digit, create a new literal var for it - 9360 # otherwise return first 'name' from the top (back) of 'vars' and abort if not found - 9361 lookup-var-or-literal: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 9362 # . prologue - 9363 55/push-ebp - 9364 89/<- %ebp 4/r32/esp - 9365 # . save registers - 9366 50/push-eax - 9367 51/push-ecx - 9368 56/push-esi - 9369 # esi = name - 9370 8b/-> *(ebp+8) 6/r32/esi - 9371 # if slice-empty?(name) abort - 9372 (slice-empty? %esi) # => eax - 9373 3d/compare-eax-and 0/imm32/false - 9374 0f 85/jump-if-!= $lookup-var-or-literal:abort/disp32 - 9375 # var c/ecx: byte = *name->start - 9376 8b/-> *esi 1/r32/ecx - 9377 8a/copy-byte *ecx 1/r32/CL - 9378 81 4/subop/and %ecx 0xff/imm32 - 9379 # if is-decimal-digit?(c) return new var(name) - 9380 { - 9381 (is-decimal-digit? %ecx) # => eax - 9382 3d/compare-eax-and 0/imm32/false - 9383 74/jump-if-= break/disp8 - 9384 $lookup-var-or-literal:literal: - 9385 (new-literal-integer Heap %esi *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) - 9386 eb/jump $lookup-var-or-literal:end/disp8 - 9387 } - 9388 # else if (c == '"') return new var(name) - 9389 { - 9390 81 7/subop/compare %ecx 0x22/imm32/dquote - 9391 75/jump-if-!= break/disp8 - 9392 $lookup-var-or-literal:literal-string: - 9393 (new-literal Heap %esi *(ebp+0x10)) - 9394 eb/jump $lookup-var-or-literal:end/disp8 - 9395 } - 9396 # otherwise return lookup-var(name, vars) - 9397 { - 9398 $lookup-var-or-literal:var: - 9399 (lookup-var %esi *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) - 9400 } - 9401 $lookup-var-or-literal:end: - 9402 # . restore registers - 9403 5e/pop-to-esi - 9404 59/pop-to-ecx - 9405 58/pop-to-eax - 9406 # . epilogue - 9407 89/<- %esp 5/r32/ebp - 9408 5d/pop-to-ebp - 9409 c3/return - 9410 - 9411 $lookup-var-or-literal:abort: - 9412 (write-buffered *(ebp+0x18) "fn ") - 9413 8b/-> *(ebp+0x14) 0/r32/eax - 9414 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 9415 (write-buffered *(ebp+0x18) %eax) - 9416 (write-buffered *(ebp+0x18) ": empty variable!") - 9417 (flush *(ebp+0x18)) - 9418 (stop *(ebp+0x1c) 1) - 9419 # never gets here - 9420 - 9421 # return first 'name' from the top (back) of 'vars' and abort if not found - 9422 lookup-var: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 9423 # . prologue - 9424 55/push-ebp - 9425 89/<- %ebp 4/r32/esp - 9426 # . save registers - 9427 50/push-eax - 9428 # - 9429 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) - 9430 # if (*out == 0) abort - 9431 8b/-> *(ebp+0x10) 0/r32/eax - 9432 81 7/subop/compare *eax 0/imm32 - 9433 74/jump-if-= $lookup-var:abort/disp8 - 9434 $lookup-var:end: - 9435 # . restore registers - 9436 58/pop-to-eax - 9437 # . epilogue - 9438 89/<- %esp 5/r32/ebp - 9439 5d/pop-to-ebp - 9440 c3/return - 9441 - 9442 $lookup-var:abort: - 9443 (write-buffered *(ebp+0x18) "fn ") - 9444 8b/-> *(ebp+0x14) 0/r32/eax - 9445 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 9446 (write-buffered *(ebp+0x18) %eax) - 9447 (write-buffered *(ebp+0x18) ": unknown variable '") - 9448 (write-slice-buffered *(ebp+0x18) *(ebp+8)) - 9449 (write-buffered *(ebp+0x18) "'\n") - 9450 (flush *(ebp+0x18)) - 9451 (stop *(ebp+0x1c) 1) - 9452 # never gets here - 9453 - 9454 # return first 'name' from the top (back) of 'vars', and 0/null if not found - 9455 # ensure that 'name' if in a register is the topmost variable in that register - 9456 lookup-var-helper: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) - 9457 # pseudocode: - 9458 # var curr: (addr handle var) = &vars->data[vars->top - 12] - 9459 # var min = vars->data - 9460 # while curr >= min - 9461 # var v: (handle var) = *curr - 9462 # if v->name == name - 9463 # return - 9464 # curr -= 12 - 9465 # - 9466 # . prologue - 9467 55/push-ebp - 9468 89/<- %ebp 4/r32/esp - 9469 # . save registers - 9470 50/push-eax - 9471 51/push-ecx - 9472 52/push-edx - 9473 53/push-ebx - 9474 56/push-esi - 9475 57/push-edi - 9476 # clear out - 9477 (zero-out *(ebp+0x10) *Handle-size) - 9478 # esi = vars - 9479 8b/-> *(ebp+0xc) 6/r32/esi - 9480 # ebx = vars->top - 9481 8b/-> *esi 3/r32/ebx - 9482 # if (vars->top > vars->size) abort - 9483 3b/compare<- *(esi+4) 0/r32/eax - 9484 0f 8f/jump-if-> $lookup-var-helper:error1/disp32 - 9485 # var min/edx: (addr handle var) = vars->data - 9486 8d/copy-address *(esi+8) 2/r32/edx - 9487 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] - 9488 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 - 9489 # var var-in-reg/edi: 8 addrs - 9490 68/push 0/imm32 - 9491 68/push 0/imm32 - 9492 68/push 0/imm32 - 9493 68/push 0/imm32 - 9494 68/push 0/imm32 - 9495 68/push 0/imm32 - 9496 68/push 0/imm32 - 9497 68/push 0/imm32 - 9498 89/<- %edi 4/r32/esp - 9499 { - 9500 $lookup-var-helper:loop: - 9501 # if (curr < min) return - 9502 39/compare %ebx 2/r32/edx - 9503 0f 82/jump-if-addr< break/disp32 - 9504 # var v/ecx: (addr var) = lookup(*curr) - 9505 (lookup *ebx *(ebx+4)) # => eax - 9506 89/<- %ecx 0/r32/eax - 9507 # var vn/eax: (addr array byte) = lookup(v->name) - 9508 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax - 9509 # if (vn == name) return curr - 9510 (slice-equal? *(ebp+8) %eax) # => eax - 9511 3d/compare-eax-and 0/imm32/false - 9512 { - 9513 74/jump-if-= break/disp8 - 9514 $lookup-var-helper:found: - 9515 # var vr/eax: (addr array byte) = lookup(v->register) - 9516 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax - 9517 3d/compare-eax-and 0/imm32 - 9518 { - 9519 74/jump-if-= break/disp8 - 9520 $lookup-var-helper:found-register: - 9521 # var reg/eax: int = get(Registers, vr) - 9522 (get Mu-registers %eax 0xc "Mu-registers") # => eax - 9523 8b/-> *eax 0/r32/eax - 9524 # if (var-in-reg[reg]) error - 9525 8b/-> *(edi+eax<<2) 0/r32/eax - 9526 3d/compare-eax-and 0/imm32 - 9527 0f 85/jump-if-!= $lookup-var-helper:error2/disp32 - 9528 } - 9529 $lookup-var-helper:return: - 9530 # esi = out - 9531 8b/-> *(ebp+0x10) 6/r32/esi - 9532 # *out = *curr - 9533 8b/-> *ebx 0/r32/eax - 9534 89/<- *esi 0/r32/eax - 9535 8b/-> *(ebx+4) 0/r32/eax - 9536 89/<- *(esi+4) 0/r32/eax - 9537 # return - 9538 eb/jump $lookup-var-helper:end/disp8 - 9539 } - 9540 # 'name' not yet found; update var-in-reg if v in register - 9541 # . var vr/eax: (addr array byte) = lookup(v->register) - 9542 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax - 9543 # . if (var == 0) continue - 9544 3d/compare-eax-and 0/imm32 - 9545 74/jump-if-= $lookup-var-helper:continue/disp8 - 9546 # . var reg/eax: int = get(Registers, vr) - 9547 (get Mu-registers %eax 0xc "Mu-registers") # => eax - 9548 8b/-> *eax 0/r32/eax - 9549 # . if (var-in-reg[reg] == 0) var-in-reg[reg] = v - 9550 81 7/subop/compare *(edi+eax<<2) 0/imm32 - 9551 75/jump-if-!= $lookup-var-helper:continue/disp8 - 9552 89/<- *(edi+eax<<2) 1/r32/ecx - 9553 $lookup-var-helper:continue: - 9554 # curr -= 12 - 9555 81 5/subop/subtract %ebx 0xc/imm32 - 9556 e9/jump loop/disp32 - 9557 } - 9558 $lookup-var-helper:end: - 9559 # . reclaim locals - 9560 81 0/subop/add %esp 0x20/imm32 - 9561 # . restore registers - 9562 5f/pop-to-edi - 9563 5e/pop-to-esi - 9564 5b/pop-to-ebx - 9565 5a/pop-to-edx - 9566 59/pop-to-ecx - 9567 58/pop-to-eax - 9568 # . epilogue - 9569 89/<- %esp 5/r32/ebp - 9570 5d/pop-to-ebp - 9571 c3/return - 9572 - 9573 $lookup-var-helper:error1: - 9574 (write-buffered *(ebp+0x18) "fn ") - 9575 8b/-> *(ebp+0x14) 0/r32/eax - 9576 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 9577 (write-buffered *(ebp+0x18) %eax) - 9578 (write-buffered *(ebp+0x18) ": malformed stack when looking up '") - 9579 (write-slice-buffered *(ebp+0x18) *(ebp+8)) - 9580 (write-buffered *(ebp+0x18) "'\n") - 9581 (flush *(ebp+0x18)) - 9582 (stop *(ebp+0x1c) 1) - 9583 # never gets here - 9584 - 9585 $lookup-var-helper:error2: - 9586 # eax contains the conflicting var at this point - 9587 (write-buffered *(ebp+0x18) "fn ") - 9588 50/push-eax - 9589 8b/-> *(ebp+0x14) 0/r32/eax - 9590 (lookup *eax *(eax+4)) # Function-name Function-name => eax - 9591 (write-buffered *(ebp+0x18) %eax) - 9592 58/pop-eax - 9593 (write-buffered *(ebp+0x18) ": register ") - 9594 50/push-eax - 9595 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9596 (write-buffered *(ebp+0x18) %eax) - 9597 58/pop-to-eax - 9598 (write-buffered *(ebp+0x18) " reads var '") - 9599 (write-slice-buffered *(ebp+0x18) *(ebp+8)) - 9600 (write-buffered *(ebp+0x18) "' after writing var '") - 9601 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9602 (write-buffered *(ebp+0x18) %eax) - 9603 (write-buffered *(ebp+0x18) "'\n") - 9604 (flush *(ebp+0x18)) - 9605 (stop *(ebp+0x1c) 1) - 9606 # never gets here - 9607 - 9608 dump-vars: # vars: (addr stack live-var) - 9609 # pseudocode: - 9610 # var curr: (addr handle var) = &vars->data[vars->top - 12] - 9611 # var min = vars->data - 9612 # while curr >= min - 9613 # var v: (handle var) = *curr - 9614 # print v - 9615 # curr -= 12 - 9616 # - 9617 # . prologue - 9618 55/push-ebp - 9619 89/<- %ebp 4/r32/esp - 9620 # . save registers - 9621 52/push-edx - 9622 53/push-ebx - 9623 56/push-esi - 9624 # esi = vars - 9625 8b/-> *(ebp+8) 6/r32/esi - 9626 # ebx = vars->top - 9627 8b/-> *esi 3/r32/ebx - 9628 # var min/edx: (addr handle var) = vars->data - 9629 8d/copy-address *(esi+8) 2/r32/edx - 9630 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] - 9631 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 - 9632 { - 9633 $dump-vars:loop: - 9634 # if (curr < min) return - 9635 39/compare %ebx 2/r32/edx - 9636 0f 82/jump-if-addr< break/disp32 - 9637 # - 9638 (write-buffered Stderr " var@") - 9639 (dump-var 2 %ebx) - 9640 # curr -= 12 - 9641 81 5/subop/subtract %ebx 0xc/imm32 - 9642 e9/jump loop/disp32 - 9643 } - 9644 $dump-vars:end: - 9645 # . restore registers - 9646 5e/pop-to-esi - 9647 5b/pop-to-ebx - 9648 5a/pop-to-edx - 9649 # . epilogue - 9650 89/<- %esp 5/r32/ebp - 9651 5d/pop-to-ebp - 9652 c3/return - 9653 - 9654 == data - 9655 # Like Registers, but no esp or ebp - 9656 Mu-registers: # (addr stream {(handle array byte), int}) - 9657 # a table is a stream - 9658 0x48/imm32/write - 9659 0/imm32/read - 9660 0x48/imm32/length - 9661 # data - 9662 # it is perfectly ok to use fake alloc-ids -- as long as you never try to reclaim them - 9663 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 - 9664 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 - 9665 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 - 9666 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 - 9667 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 - 9668 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 - 9669 - 9670 $Mu-register-eax: - 9671 0x11/imm32/alloc-id - 9672 3/imm32/size - 9673 0x65/e 0x61/a 0x78/x - 9674 - 9675 $Mu-register-ecx: - 9676 0x11/imm32/alloc-id - 9677 3/imm32/size - 9678 0x65/e 0x63/c 0x78/x - 9679 - 9680 $Mu-register-edx: - 9681 0x11/imm32/alloc-id - 9682 3/imm32/size - 9683 0x65/e 0x64/d 0x78/x - 9684 - 9685 $Mu-register-ebx: - 9686 0x11/imm32/alloc-id - 9687 3/imm32/size - 9688 0x65/e 0x62/b 0x78/x - 9689 - 9690 $Mu-register-esi: - 9691 0x11/imm32/alloc-id - 9692 3/imm32/size - 9693 0x65/e 0x73/s 0x69/i - 9694 - 9695 $Mu-register-edi: - 9696 0x11/imm32/alloc-id - 9697 3/imm32/size - 9698 0x65/e 0x64/d 0x69/i - 9699 - 9700 == code - 9701 - 9702 # return first 'name' from the top (back) of 'vars' and create a new var for a fn output if not found - 9703 lookup-var-or-find-in-fn-outputs: # name: (addr slice), vars: (addr stack live-var), fn: (addr function), out: (addr handle var), err: (addr buffered-file), ed: (addr exit-descriptor) - 9704 # . prologue - 9705 55/push-ebp - 9706 89/<- %ebp 4/r32/esp - 9707 # . save registers - 9708 50/push-eax + 9333 # if (name == "<-") abort + 9334 (slice-equal? %ecx "<-") + 9335 3d/compare-eax-and 0/imm32/false + 9336 0f 85/jump-if-!= $add-operation-and-inputs-to-stmt:abort/disp32 + 9337 # if (is-get? && second operand) lookup or create offset + 9338 { + 9339 81 7/subop/compare %ebx 0/imm32/false + 9340 74/jump-if-= break/disp8 + 9341 (lookup *(edi+0xc) *(edi+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9342 3d/compare-eax-and 0/imm32 + 9343 74/jump-if-= break/disp8 + 9344 (lookup-or-create-constant %eax %ecx %esi) + 9345 #? (lookup *esi *(esi+4)) + 9346 #? (write-buffered Stderr "creating new output var ") + 9347 #? (write-int32-hex-buffered Stderr %eax) + 9348 #? (write-buffered Stderr " for field called ") + 9349 #? (write-slice-buffered Stderr %ecx) + 9350 #? (write-buffered Stderr "; var name ") + 9351 #? (lookup *eax *(eax+4)) # Var-name + 9352 #? (write-buffered Stderr %eax) + 9353 #? (write-buffered Stderr Newline) + 9354 #? (flush Stderr) + 9355 e9/jump $add-operation-and-inputs-to-stmt:save-var/disp32 + 9356 } + 9357 # is-deref? = false + 9358 ba/copy-to-edx 0/imm32/false + 9359 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? + 9360 8b/-> *ecx 0/r32/eax # Slice-start + 9361 8a/copy-byte *eax 0/r32/AL + 9362 81 4/subop/and %eax 0xff/imm32 + 9363 3d/compare-eax-and 0x2a/imm32/asterisk + 9364 { + 9365 75/jump-if-!= break/disp8 + 9366 $add-operation-and-inputs-to-stmt:inout-is-deref: + 9367 ff 0/subop/increment *ecx + 9368 ba/copy-to-edx 1/imm32/true + 9369 } + 9370 (lookup-var-or-literal %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) + 9371 $add-operation-and-inputs-to-stmt:save-var: + 9372 8d/copy-address *(edi+0xc) 0/r32/eax + 9373 (append-stmt-var Heap *esi *(esi+4) *(edi+0xc) *(edi+0x10) %edx %eax) # Stmt1-inouts or Regvardef-inouts + 9374 # + 9375 e9/jump loop/disp32 + 9376 } + 9377 $add-operation-and-inputs-to-stmt:end: + 9378 # . reclaim locals + 9379 81 0/subop/add %esp 0x10/imm32 + 9380 # . restore registers + 9381 5f/pop-to-edi + 9382 5e/pop-to-esi + 9383 5b/pop-to-ebx + 9384 5a/pop-to-edx + 9385 59/pop-to-ecx + 9386 58/pop-to-eax + 9387 # . epilogue + 9388 89/<- %esp 5/r32/ebp + 9389 5d/pop-to-ebp + 9390 c3/return + 9391 + 9392 $add-operation-and-inputs-to-stmt:abort: + 9393 # error("fn ___: invalid identifier in '" line "'\n") + 9394 (write-buffered *(ebp+0x18) "fn ") + 9395 8b/-> *(ebp+0x14) 0/r32/eax + 9396 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9397 (write-buffered *(ebp+0x18) %eax) + 9398 (rewind-stream *(ebp+0xc)) + 9399 (write-buffered *(ebp+0x18) ": invalid identifier in '") + 9400 (write-stream-data *(ebp+0x18) *(ebp+0xc)) + 9401 (write-buffered *(ebp+0x18) "'\n") + 9402 (flush *(ebp+0x18)) + 9403 (stop *(ebp+0x1c) 1) + 9404 # never gets here + 9405 + 9406 stmt-has-outputs?: # line: (addr stream byte) -> result/eax: boolean + 9407 # . prologue + 9408 55/push-ebp + 9409 89/<- %ebp 4/r32/esp + 9410 # . save registers + 9411 51/push-ecx + 9412 # var word-slice/ecx: slice + 9413 68/push 0/imm32/end + 9414 68/push 0/imm32/start + 9415 89/<- %ecx 4/r32/esp + 9416 # result = false + 9417 b8/copy-to-eax 0/imm32/false + 9418 (rewind-stream *(ebp+8)) + 9419 { + 9420 (next-mu-token *(ebp+8) %ecx) + 9421 # if slice-empty?(word-slice) break + 9422 (slice-empty? %ecx) + 9423 3d/compare-eax-and 0/imm32/false + 9424 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) + 9425 0f 85/jump-if-!= break/disp32 + 9426 # if slice-starts-with?(word-slice, '#') break + 9427 # . eax = *word-slice->start + 9428 8b/-> *ecx 0/r32/eax + 9429 8a/copy-byte *eax 0/r32/AL + 9430 81 4/subop/and %eax 0xff/imm32 + 9431 # . if (eax == '#') break + 9432 3d/compare-eax-and 0x23/imm32/hash + 9433 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) + 9434 0f 84/jump-if-= break/disp32 + 9435 # if slice-equal?(word-slice, '<-') return true + 9436 (slice-equal? %ecx "<-") + 9437 3d/compare-eax-and 0/imm32/false + 9438 74/jump-if-= loop/disp8 + 9439 b8/copy-to-eax 1/imm32/true + 9440 } + 9441 $stmt-has-outputs:end: + 9442 (rewind-stream *(ebp+8)) + 9443 # . reclaim locals + 9444 81 0/subop/add %esp 8/imm32 + 9445 # . restore registers + 9446 59/pop-to-ecx + 9447 # . epilogue + 9448 89/<- %esp 5/r32/ebp + 9449 5d/pop-to-ebp + 9450 c3/return + 9451 + 9452 # if 'name' starts with a digit, create a new literal var for it + 9453 # otherwise return first 'name' from the top (back) of 'vars' and abort if not found + 9454 lookup-var-or-literal: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 9455 # . prologue + 9456 55/push-ebp + 9457 89/<- %ebp 4/r32/esp + 9458 # . save registers + 9459 50/push-eax + 9460 51/push-ecx + 9461 56/push-esi + 9462 # esi = name + 9463 8b/-> *(ebp+8) 6/r32/esi + 9464 # if slice-empty?(name) abort + 9465 (slice-empty? %esi) # => eax + 9466 3d/compare-eax-and 0/imm32/false + 9467 0f 85/jump-if-!= $lookup-var-or-literal:abort/disp32 + 9468 # var c/ecx: byte = *name->start + 9469 8b/-> *esi 1/r32/ecx + 9470 8a/copy-byte *ecx 1/r32/CL + 9471 81 4/subop/and %ecx 0xff/imm32 + 9472 # if is-decimal-digit?(c) return new var(name) + 9473 { + 9474 (is-decimal-digit? %ecx) # => eax + 9475 3d/compare-eax-and 0/imm32/false + 9476 74/jump-if-= break/disp8 + 9477 $lookup-var-or-literal:literal: + 9478 (new-literal-integer Heap %esi *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) + 9479 eb/jump $lookup-var-or-literal:end/disp8 + 9480 } + 9481 # else if (c == '"') return new var(name) + 9482 { + 9483 81 7/subop/compare %ecx 0x22/imm32/dquote + 9484 75/jump-if-!= break/disp8 + 9485 $lookup-var-or-literal:literal-string: + 9486 (new-literal Heap %esi *(ebp+0x10)) + 9487 eb/jump $lookup-var-or-literal:end/disp8 + 9488 } + 9489 # otherwise return lookup-var(name, vars) + 9490 { + 9491 $lookup-var-or-literal:var: + 9492 (lookup-var %esi *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) + 9493 } + 9494 $lookup-var-or-literal:end: + 9495 # . restore registers + 9496 5e/pop-to-esi + 9497 59/pop-to-ecx + 9498 58/pop-to-eax + 9499 # . epilogue + 9500 89/<- %esp 5/r32/ebp + 9501 5d/pop-to-ebp + 9502 c3/return + 9503 + 9504 $lookup-var-or-literal:abort: + 9505 (write-buffered *(ebp+0x18) "fn ") + 9506 8b/-> *(ebp+0x14) 0/r32/eax + 9507 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9508 (write-buffered *(ebp+0x18) %eax) + 9509 (write-buffered *(ebp+0x18) ": empty variable!") + 9510 (flush *(ebp+0x18)) + 9511 (stop *(ebp+0x1c) 1) + 9512 # never gets here + 9513 + 9514 # return first 'name' from the top (back) of 'vars' and abort if not found + 9515 lookup-var: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 9516 # . prologue + 9517 55/push-ebp + 9518 89/<- %ebp 4/r32/esp + 9519 # . save registers + 9520 50/push-eax + 9521 # + 9522 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) + 9523 # if (*out == 0) abort + 9524 8b/-> *(ebp+0x10) 0/r32/eax + 9525 81 7/subop/compare *eax 0/imm32 + 9526 74/jump-if-= $lookup-var:abort/disp8 + 9527 $lookup-var:end: + 9528 # . restore registers + 9529 58/pop-to-eax + 9530 # . epilogue + 9531 89/<- %esp 5/r32/ebp + 9532 5d/pop-to-ebp + 9533 c3/return + 9534 + 9535 $lookup-var:abort: + 9536 (write-buffered *(ebp+0x18) "fn ") + 9537 8b/-> *(ebp+0x14) 0/r32/eax + 9538 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9539 (write-buffered *(ebp+0x18) %eax) + 9540 (write-buffered *(ebp+0x18) ": unknown variable '") + 9541 (write-slice-buffered *(ebp+0x18) *(ebp+8)) + 9542 (write-buffered *(ebp+0x18) "'\n") + 9543 (flush *(ebp+0x18)) + 9544 (stop *(ebp+0x1c) 1) + 9545 # never gets here + 9546 + 9547 # return first 'name' from the top (back) of 'vars', and 0/null if not found + 9548 # ensure that 'name' if in a register is the topmost variable in that register + 9549 lookup-var-helper: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) + 9550 # pseudocode: + 9551 # var curr: (addr handle var) = &vars->data[vars->top - 12] + 9552 # var min = vars->data + 9553 # while curr >= min + 9554 # var v: (handle var) = *curr + 9555 # if v->name == name + 9556 # return + 9557 # curr -= 12 + 9558 # + 9559 # . prologue + 9560 55/push-ebp + 9561 89/<- %ebp 4/r32/esp + 9562 # . save registers + 9563 50/push-eax + 9564 51/push-ecx + 9565 52/push-edx + 9566 53/push-ebx + 9567 56/push-esi + 9568 57/push-edi + 9569 # clear out + 9570 (zero-out *(ebp+0x10) *Handle-size) + 9571 # esi = vars + 9572 8b/-> *(ebp+0xc) 6/r32/esi + 9573 # ebx = vars->top + 9574 8b/-> *esi 3/r32/ebx + 9575 # if (vars->top > vars->size) abort + 9576 3b/compare<- *(esi+4) 0/r32/eax + 9577 0f 8f/jump-if-> $lookup-var-helper:error1/disp32 + 9578 # var min/edx: (addr handle var) = vars->data + 9579 8d/copy-address *(esi+8) 2/r32/edx + 9580 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] + 9581 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 + 9582 # var var-in-reg/edi: 8 addrs + 9583 68/push 0/imm32 + 9584 68/push 0/imm32 + 9585 68/push 0/imm32 + 9586 68/push 0/imm32 + 9587 68/push 0/imm32 + 9588 68/push 0/imm32 + 9589 68/push 0/imm32 + 9590 68/push 0/imm32 + 9591 89/<- %edi 4/r32/esp + 9592 { + 9593 $lookup-var-helper:loop: + 9594 # if (curr < min) return + 9595 39/compare %ebx 2/r32/edx + 9596 0f 82/jump-if-addr< break/disp32 + 9597 # var v/ecx: (addr var) = lookup(*curr) + 9598 (lookup *ebx *(ebx+4)) # => eax + 9599 89/<- %ecx 0/r32/eax + 9600 # var vn/eax: (addr array byte) = lookup(v->name) + 9601 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax + 9602 # if (vn == name) return curr + 9603 (slice-equal? *(ebp+8) %eax) # => eax + 9604 3d/compare-eax-and 0/imm32/false + 9605 { + 9606 74/jump-if-= break/disp8 + 9607 $lookup-var-helper:found: + 9608 # var vr/eax: (addr array byte) = lookup(v->register) + 9609 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax + 9610 3d/compare-eax-and 0/imm32 + 9611 { + 9612 74/jump-if-= break/disp8 + 9613 $lookup-var-helper:found-register: + 9614 # var reg/eax: int = get(Registers, vr) + 9615 (get Mu-registers %eax 0xc "Mu-registers") # => eax + 9616 8b/-> *eax 0/r32/eax + 9617 # if (var-in-reg[reg]) error + 9618 8b/-> *(edi+eax<<2) 0/r32/eax + 9619 3d/compare-eax-and 0/imm32 + 9620 0f 85/jump-if-!= $lookup-var-helper:error2/disp32 + 9621 } + 9622 $lookup-var-helper:return: + 9623 # esi = out + 9624 8b/-> *(ebp+0x10) 6/r32/esi + 9625 # *out = *curr + 9626 8b/-> *ebx 0/r32/eax + 9627 89/<- *esi 0/r32/eax + 9628 8b/-> *(ebx+4) 0/r32/eax + 9629 89/<- *(esi+4) 0/r32/eax + 9630 # return + 9631 eb/jump $lookup-var-helper:end/disp8 + 9632 } + 9633 # 'name' not yet found; update var-in-reg if v in register + 9634 # . var vr/eax: (addr array byte) = lookup(v->register) + 9635 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax + 9636 # . if (var == 0) continue + 9637 3d/compare-eax-and 0/imm32 + 9638 74/jump-if-= $lookup-var-helper:continue/disp8 + 9639 # . var reg/eax: int = get(Registers, vr) + 9640 (get Mu-registers %eax 0xc "Mu-registers") # => eax + 9641 8b/-> *eax 0/r32/eax + 9642 # . if (var-in-reg[reg] == 0) var-in-reg[reg] = v + 9643 81 7/subop/compare *(edi+eax<<2) 0/imm32 + 9644 75/jump-if-!= $lookup-var-helper:continue/disp8 + 9645 89/<- *(edi+eax<<2) 1/r32/ecx + 9646 $lookup-var-helper:continue: + 9647 # curr -= 12 + 9648 81 5/subop/subtract %ebx 0xc/imm32 + 9649 e9/jump loop/disp32 + 9650 } + 9651 $lookup-var-helper:end: + 9652 # . reclaim locals + 9653 81 0/subop/add %esp 0x20/imm32 + 9654 # . restore registers + 9655 5f/pop-to-edi + 9656 5e/pop-to-esi + 9657 5b/pop-to-ebx + 9658 5a/pop-to-edx + 9659 59/pop-to-ecx + 9660 58/pop-to-eax + 9661 # . epilogue + 9662 89/<- %esp 5/r32/ebp + 9663 5d/pop-to-ebp + 9664 c3/return + 9665 + 9666 $lookup-var-helper:error1: + 9667 (write-buffered *(ebp+0x18) "fn ") + 9668 8b/-> *(ebp+0x14) 0/r32/eax + 9669 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9670 (write-buffered *(ebp+0x18) %eax) + 9671 (write-buffered *(ebp+0x18) ": malformed stack when looking up '") + 9672 (write-slice-buffered *(ebp+0x18) *(ebp+8)) + 9673 (write-buffered *(ebp+0x18) "'\n") + 9674 (flush *(ebp+0x18)) + 9675 (stop *(ebp+0x1c) 1) + 9676 # never gets here + 9677 + 9678 $lookup-var-helper:error2: + 9679 # eax contains the conflicting var at this point + 9680 (write-buffered *(ebp+0x18) "fn ") + 9681 50/push-eax + 9682 8b/-> *(ebp+0x14) 0/r32/eax + 9683 (lookup *eax *(eax+4)) # Function-name Function-name => eax + 9684 (write-buffered *(ebp+0x18) %eax) + 9685 58/pop-eax + 9686 (write-buffered *(ebp+0x18) ": register ") + 9687 50/push-eax + 9688 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9689 (write-buffered *(ebp+0x18) %eax) + 9690 58/pop-to-eax + 9691 (write-buffered *(ebp+0x18) " reads var '") + 9692 (write-slice-buffered *(ebp+0x18) *(ebp+8)) + 9693 (write-buffered *(ebp+0x18) "' after writing var '") + 9694 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 9695 (write-buffered *(ebp+0x18) %eax) + 9696 (write-buffered *(ebp+0x18) "'\n") + 9697 (flush *(ebp+0x18)) + 9698 (stop *(ebp+0x1c) 1) + 9699 # never gets here + 9700 + 9701 dump-vars: # vars: (addr stack live-var) + 9702 # pseudocode: + 9703 # var curr: (addr handle var) = &vars->data[vars->top - 12] + 9704 # var min = vars->data + 9705 # while curr >= min + 9706 # var v: (handle var) = *curr + 9707 # print v + 9708 # curr -= 12 9709 # - 9710 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) # arg order slightly different; 'fn' is deemphasized - 9711 { - 9712 # if (out != 0) return - 9713 8b/-> *(ebp+0x14) 0/r32/eax - 9714 81 7/subop/compare *eax 0/imm32 - 9715 75/jump-if-!= break/disp8 - 9716 # if name is one of fn's outputs, return it - 9717 (find-in-function-outputs *(ebp+0x10) *(ebp+8) *(ebp+0x14)) - 9718 8b/-> *(ebp+0x14) 0/r32/eax - 9719 81 7/subop/compare *eax 0/imm32 - 9720 # otherwise abort - 9721 0f 84/jump-if-= $lookup-or-define-var:abort/disp32 - 9722 } - 9723 $lookup-or-define-var:end: - 9724 # . restore registers - 9725 58/pop-to-eax - 9726 # . epilogue - 9727 89/<- %esp 5/r32/ebp - 9728 5d/pop-to-ebp - 9729 c3/return - 9730 - 9731 $lookup-or-define-var:abort: - 9732 (write-buffered *(ebp+0x18) "unknown variable '") - 9733 (write-slice-buffered *(ebp+0x18) *(ebp+8)) - 9734 (write-buffered *(ebp+0x18) "'\n") - 9735 (flush *(ebp+0x18)) - 9736 (stop *(ebp+0x1c) 1) - 9737 # never gets here - 9738 - 9739 find-in-function-outputs: # fn: (addr function), name: (addr slice), out: (addr handle var) - 9740 # . prologue - 9741 55/push-ebp - 9742 89/<- %ebp 4/r32/esp - 9743 # . save registers - 9744 50/push-eax - 9745 51/push-ecx - 9746 # var curr/ecx: (addr list var) = lookup(fn->outputs) - 9747 8b/-> *(ebp+8) 1/r32/ecx - 9748 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax - 9749 89/<- %ecx 0/r32/eax - 9750 # while curr != null - 9751 { - 9752 81 7/subop/compare %ecx 0/imm32 - 9753 74/jump-if-= break/disp8 - 9754 # var v/eax: (addr var) = lookup(curr->value) - 9755 (lookup *ecx *(ecx+4)) # List-value List-value => eax - 9756 # var s/eax: (addr array byte) = lookup(v->name) - 9757 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9758 # if (s == name) return curr->value - 9759 (slice-equal? *(ebp+0xc) %eax) # => eax - 9760 3d/compare-eax-and 0/imm32/false - 9761 { - 9762 74/jump-if-= break/disp8 - 9763 # var edi = out - 9764 57/push-edi - 9765 8b/-> *(ebp+0x10) 7/r32/edi - 9766 # *out = curr->value - 9767 8b/-> *ecx 0/r32/eax - 9768 89/<- *edi 0/r32/eax - 9769 8b/-> *(ecx+4) 0/r32/eax - 9770 89/<- *(edi+4) 0/r32/eax - 9771 # - 9772 5f/pop-to-edi - 9773 eb/jump $find-in-function-outputs:end/disp8 - 9774 } - 9775 # curr = curr->next - 9776 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax - 9777 89/<- %ecx 0/r32/eax - 9778 # - 9779 eb/jump loop/disp8 - 9780 } - 9781 b8/copy-to-eax 0/imm32 - 9782 $find-in-function-outputs:end: - 9783 # . restore registers - 9784 59/pop-to-ecx - 9785 58/pop-to-eax - 9786 # . epilogue - 9787 89/<- %esp 5/r32/ebp - 9788 5d/pop-to-ebp - 9789 c3/return - 9790 - 9791 # push 'out' to 'vars' if not already there; it's assumed to be a fn output - 9792 maybe-define-var: # out: (handle var), vars: (addr stack live-var) - 9793 # . prologue - 9794 55/push-ebp - 9795 89/<- %ebp 4/r32/esp - 9796 # . save registers - 9797 50/push-eax - 9798 # var out-addr/eax: (addr var) - 9799 (lookup *(ebp+8) *(ebp+0xc)) # => eax - 9800 # - 9801 (binding-exists? %eax *(ebp+0x10)) # => eax - 9802 3d/compare-eax-and 0/imm32/false - 9803 75/jump-if-!= $maybe-define-var:end/disp8 - 9804 # otherwise update vars - 9805 (push *(ebp+0x10) *(ebp+8)) - 9806 (push *(ebp+0x10) *(ebp+0xc)) - 9807 (push *(ebp+0x10) 0) # 'out' is always a fn output; never spill it - 9808 $maybe-define-var:end: - 9809 # . restore registers - 9810 58/pop-to-eax - 9811 # . epilogue - 9812 89/<- %esp 5/r32/ebp - 9813 5d/pop-to-ebp - 9814 c3/return - 9815 - 9816 # simpler version of lookup-var-helper - 9817 binding-exists?: # target: (addr var), vars: (addr stack live-var) -> result/eax: boolean - 9818 # pseudocode: - 9819 # var curr: (addr handle var) = &vars->data[vars->top - 12] - 9820 # var min = vars->data - 9821 # while curr >= min - 9822 # var v: (handle var) = *curr - 9823 # if v->name == target->name - 9824 # return true - 9825 # curr -= 12 - 9826 # return false - 9827 # - 9828 # . prologue - 9829 55/push-ebp - 9830 89/<- %ebp 4/r32/esp - 9831 # . save registers - 9832 51/push-ecx - 9833 52/push-edx - 9834 56/push-esi - 9835 # var target-name/ecx: (addr array byte) = lookup(target->name) - 9836 8b/-> *(ebp+8) 0/r32/eax - 9837 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9838 89/<- %ecx 0/r32/eax - 9839 # esi = vars - 9840 8b/-> *(ebp+0xc) 6/r32/esi - 9841 # eax = vars->top - 9842 8b/-> *esi 0/r32/eax - 9843 # var min/edx: (addr handle var) = vars->data - 9844 8d/copy-address *(esi+8) 2/r32/edx - 9845 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] - 9846 8d/copy-address *(esi+eax-4) 6/r32/esi # vars + 8 + vars->type - 12 - 9847 { - 9848 $binding-exists?:loop: - 9849 # if (curr < min) return - 9850 39/compare %esi 2/r32/edx - 9851 0f 82/jump-if-addr< break/disp32 - 9852 # var v/eax: (addr var) = lookup(*curr) - 9853 (lookup *esi *(esi+4)) # => eax - 9854 # var vn/eax: (addr array byte) = lookup(v->name) - 9855 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9856 # if (vn == target-name) return true - 9857 (string-equal? %ecx %eax) # => eax - 9858 3d/compare-eax-and 0/imm32/false - 9859 75/jump-if-!= $binding-exists?:end/disp8 # eax already contains true - 9860 # curr -= 12 - 9861 81 5/subop/subtract %esi 0xc/imm32 - 9862 e9/jump loop/disp32 - 9863 } - 9864 b8/copy-to-eax 0/imm32/false - 9865 $binding-exists?:end: - 9866 # . restore registers - 9867 5e/pop-to-esi - 9868 5a/pop-to-edx - 9869 59/pop-to-ecx - 9870 # . epilogue - 9871 89/<- %esp 5/r32/ebp - 9872 5d/pop-to-ebp - 9873 c3/return - 9874 - 9875 test-parse-mu-stmt: - 9876 # . prologue - 9877 55/push-ebp - 9878 89/<- %ebp 4/r32/esp - 9879 # setup - 9880 (clear-stream _test-input-stream) - 9881 (write _test-input-stream "increment n\n") - 9882 # var vars/ecx: (stack (addr var) 16) - 9883 81 5/subop/subtract %esp 0xc0/imm32 - 9884 68/push 0xc0/imm32/size - 9885 68/push 0/imm32/top - 9886 89/<- %ecx 4/r32/esp - 9887 (clear-stack %ecx) - 9888 # var v/edx: (handle var) - 9889 68/push 0/imm32 - 9890 68/push 0/imm32 - 9891 89/<- %edx 4/r32/esp - 9892 # var s/eax: (handle array byte) - 9893 68/push 0/imm32 - 9894 68/push 0/imm32 - 9895 89/<- %eax 4/r32/esp - 9896 # v = new var("n") - 9897 (copy-array Heap "n" %eax) - 9898 (new-var Heap *eax *(eax+4) %edx) - 9899 # - 9900 (push %ecx *edx) - 9901 (push %ecx *(edx+4)) - 9902 (push %ecx 0) - 9903 # var out/eax: (handle stmt) - 9904 68/push 0/imm32 - 9905 68/push 0/imm32 - 9906 89/<- %eax 4/r32/esp - 9907 # convert - 9908 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) - 9909 # var out-addr/edx: (addr stmt) = lookup(*out) - 9910 (lookup *eax *(eax+4)) # => eax - 9911 89/<- %edx 0/r32/eax - 9912 # out->tag - 9913 (check-ints-equal *edx 1 "F - test-parse-mu-stmt/tag") # Stmt-tag is Stmt1 - 9914 # out->operation - 9915 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax - 9916 (check-strings-equal %eax "increment" "F - test-parse-mu-stmt/name") # Stmt1-operation - 9917 # out->inouts->value->name - 9918 # . eax = out->inouts - 9919 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9920 # . eax = out->inouts->value - 9921 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9922 # . eax = out->inouts->value->name - 9923 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9924 # . - 9925 (check-strings-equal %eax "n" "F - test-parse-mu-stmt/inout:0") - 9926 # . epilogue - 9927 89/<- %esp 5/r32/ebp - 9928 5d/pop-to-ebp - 9929 c3/return - 9930 - 9931 test-parse-mu-stmt-with-comma: - 9932 # . prologue - 9933 55/push-ebp - 9934 89/<- %ebp 4/r32/esp - 9935 # setup - 9936 (clear-stream _test-input-stream) - 9937 (write _test-input-stream "copy-to n, 3\n") - 9938 # var vars/ecx: (stack (addr var) 16) - 9939 81 5/subop/subtract %esp 0xc0/imm32 - 9940 68/push 0xc0/imm32/size - 9941 68/push 0/imm32/top - 9942 89/<- %ecx 4/r32/esp - 9943 (clear-stack %ecx) - 9944 # var v/edx: (handle var) - 9945 68/push 0/imm32 - 9946 68/push 0/imm32 - 9947 89/<- %edx 4/r32/esp - 9948 # var s/eax: (handle array byte) - 9949 68/push 0/imm32 - 9950 68/push 0/imm32 - 9951 89/<- %eax 4/r32/esp - 9952 # v = new var("n") - 9953 (copy-array Heap "n" %eax) - 9954 (new-var Heap *eax *(eax+4) %edx) - 9955 # - 9956 (push %ecx *edx) - 9957 (push %ecx *(edx+4)) - 9958 (push %ecx 0) - 9959 # var out/eax: (handle stmt) - 9960 68/push 0/imm32 - 9961 68/push 0/imm32 - 9962 89/<- %eax 4/r32/esp - 9963 # convert - 9964 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) - 9965 # var out-addr/edx: (addr stmt) = lookup(*out) - 9966 (lookup *eax *(eax+4)) # => eax - 9967 89/<- %edx 0/r32/eax - 9968 # out->tag - 9969 (check-ints-equal *edx 1 "F - test-parse-mu-stmt-with-comma/tag") # Stmt-tag is Stmt1 - 9970 # out->operation - 9971 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax - 9972 (check-strings-equal %eax "copy-to" "F - test-parse-mu-stmt-with-comma/name") # Stmt1-operation - 9973 # out->inouts->value->name - 9974 # . eax = out->inouts - 9975 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9976 # . eax = out->inouts->value - 9977 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9978 # . eax = out->inouts->value->name - 9979 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 9980 # . - 9981 (check-strings-equal %eax "n" "F - test-parse-mu-stmt-with-comma/inout:0") - 9982 # . epilogue - 9983 89/<- %esp 5/r32/ebp - 9984 5d/pop-to-ebp - 9985 c3/return - 9986 - 9987 new-var: # ad: (addr allocation-descriptor), name: (handle array byte), out: (addr handle var) - 9988 # . prologue - 9989 55/push-ebp - 9990 89/<- %ebp 4/r32/esp - 9991 # . save registers - 9992 50/push-eax - 9993 51/push-ecx - 9994 # ecx = out - 9995 8b/-> *(ebp+0x14) 1/r32/ecx - 9996 # - 9997 (allocate *(ebp+8) *Var-size %ecx) - 9998 # var out-addr/eax: (addr var) - 9999 (lookup *ecx *(ecx+4)) # => eax -10000 # out-addr->name = name -10001 8b/-> *(ebp+0xc) 1/r32/ecx -10002 89/<- *eax 1/r32/ecx # Var-name -10003 8b/-> *(ebp+0x10) 1/r32/ecx -10004 89/<- *(eax+4) 1/r32/ecx # Var-name -10005 #? (write-buffered Stderr "var ") -10006 #? (lookup *(ebp+0xc) *(ebp+0x10)) -10007 #? (write-buffered Stderr %eax) -10008 #? (write-buffered Stderr " at ") -10009 #? 8b/-> *(ebp+0x14) 1/r32/ecx -10010 #? (lookup *ecx *(ecx+4)) # => eax -10011 #? (write-int32-hex-buffered Stderr %eax) -10012 #? (write-buffered Stderr Newline) -10013 #? (flush Stderr) -10014 $new-var:end: -10015 # . restore registers -10016 59/pop-to-ecx -10017 58/pop-to-eax -10018 # . epilogue -10019 89/<- %esp 5/r32/ebp -10020 5d/pop-to-ebp -10021 c3/return -10022 -10023 new-literal-integer: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -10024 # . prologue -10025 55/push-ebp -10026 89/<- %ebp 4/r32/esp -10027 # . save registers -10028 50/push-eax -10029 51/push-ecx -10030 # if (!is-hex-int?(name)) abort -10031 (is-hex-int? *(ebp+0xc)) # => eax -10032 3d/compare-eax-and 0/imm32/false -10033 0f 84/jump-if-= $new-literal-integer:abort/disp32 -10034 # a little more error-checking -10035 (check-mu-hex-int *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c)) -10036 # out = new var(s) -10037 (new-var-from-slice *(ebp+8) *(ebp+0xc) *(ebp+0x10)) -10038 # var out-addr/ecx: (addr var) = lookup(*out) -10039 8b/-> *(ebp+0x10) 0/r32/eax -10040 (lookup *eax *(eax+4)) # => eax -10041 89/<- %ecx 0/r32/eax -10042 # out-addr->block-depth = *Curr-block-depth -10043 8b/-> *Curr-block-depth 0/r32/eax -10044 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -10045 # out-addr->type = new tree() -10046 8d/copy-address *(ecx+8) 0/r32/eax # Var-type -10047 (allocate *(ebp+8) *Type-tree-size %eax) -10048 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -10049 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -10050 # nothing else to do; default type is 'literal' -10051 $new-literal-integer:end: -10052 # . reclaim locals -10053 81 0/subop/add %esp 8/imm32 -10054 # . restore registers -10055 59/pop-to-ecx -10056 58/pop-to-eax -10057 # . epilogue -10058 89/<- %esp 5/r32/ebp -10059 5d/pop-to-ebp -10060 c3/return -10061 -10062 $new-literal-integer:abort: -10063 (write-buffered *(ebp+0x18) "fn ") -10064 8b/-> *(ebp+0x14) 0/r32/eax -10065 (lookup *eax *(eax+4)) # Function-name Function-name => eax -10066 (write-buffered *(ebp+0x18) %eax) -10067 (write-buffered *(ebp+0x18) ": variable '") -10068 (write-slice-buffered *(ebp+0x18) *(ebp+0xc)) -10069 (write-buffered *(ebp+0x18) "' cannot begin with a digit (or do you have a typo in a number?)\n") -10070 (flush *(ebp+0x18)) -10071 (stop *(ebp+0x1c) 1) -10072 # never gets here -10073 -10074 # precondition: name is a valid hex integer; require a '0x' prefix -10075 check-mu-hex-int: # name: (addr slice), err: (addr buffered-file), ed: (addr exit-descriptor) -10076 # . prologue -10077 55/push-ebp -10078 89/<- %ebp 4/r32/esp -10079 # . save registers -10080 50/push-eax -10081 51/push-ecx -10082 52/push-edx -10083 # -10084 8b/-> *(ebp+8) 1/r32/ecx -10085 # var start/ecx: (addr byte) = name->start -10086 8b/-> *(ecx+4) 2/r32/edx -10087 # var end/ecx: (addr byte) = name->end -10088 8b/-> *ecx 1/r32/ecx -10089 # var len/eax: int = name->end - name->start -10090 89/<- %eax 2/r32/edx -10091 29/subtract-from %eax 1/r32/ecx -10092 # if (len <= 1) return -10093 3d/compare-eax-with 1/imm32 -10094 0f 8e/jump-if-<= $check-mu-hex-int:end/disp32 -10095 $check-mu-hex-int:length->-1: -10096 # if slice-starts-with?("0x") return -10097 (slice-starts-with? *(ebp+8) "0x") # => eax -10098 3d/compare-eax-with 0/imm32/false -10099 75/jump-if-!= $check-mu-hex-int:end/disp8 -10100 $check-mu-hex-int:abort: -10101 # otherwise abort -10102 (write-buffered *(ebp+0xc) "literal integers are always hex in Mu; either start '") -10103 (write-slice-buffered *(ebp+0xc) *(ebp+8)) -10104 (write-buffered *(ebp+0xc) "' with a '0x' to be unambiguous, or convert it to decimal.\n") -10105 (flush *(ebp+0xc)) -10106 (stop *(ebp+0x10) 1) -10107 $check-mu-hex-int:end: + 9710 # . prologue + 9711 55/push-ebp + 9712 89/<- %ebp 4/r32/esp + 9713 # . save registers + 9714 52/push-edx + 9715 53/push-ebx + 9716 56/push-esi + 9717 # esi = vars + 9718 8b/-> *(ebp+8) 6/r32/esi + 9719 # ebx = vars->top + 9720 8b/-> *esi 3/r32/ebx + 9721 # var min/edx: (addr handle var) = vars->data + 9722 8d/copy-address *(esi+8) 2/r32/edx + 9723 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] + 9724 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 + 9725 { + 9726 $dump-vars:loop: + 9727 # if (curr < min) return + 9728 39/compare %ebx 2/r32/edx + 9729 0f 82/jump-if-addr< break/disp32 + 9730 # + 9731 (write-buffered Stderr " var@") + 9732 (dump-var 2 %ebx) + 9733 # curr -= 12 + 9734 81 5/subop/subtract %ebx 0xc/imm32 + 9735 e9/jump loop/disp32 + 9736 } + 9737 $dump-vars:end: + 9738 # . restore registers + 9739 5e/pop-to-esi + 9740 5b/pop-to-ebx + 9741 5a/pop-to-edx + 9742 # . epilogue + 9743 89/<- %esp 5/r32/ebp + 9744 5d/pop-to-ebp + 9745 c3/return + 9746 + 9747 == data + 9748 # Like Registers, but no esp or ebp + 9749 Mu-registers: # (addr stream {(handle array byte), int}) + 9750 # a table is a stream + 9751 0x48/imm32/write + 9752 0/imm32/read + 9753 0x48/imm32/length + 9754 # data + 9755 # it is perfectly ok to use fake alloc-ids -- as long as you never try to reclaim them + 9756 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 + 9757 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 + 9758 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 + 9759 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 + 9760 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 + 9761 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 + 9762 + 9763 $Mu-register-eax: + 9764 0x11/imm32/alloc-id + 9765 3/imm32/size + 9766 0x65/e 0x61/a 0x78/x + 9767 + 9768 $Mu-register-ecx: + 9769 0x11/imm32/alloc-id + 9770 3/imm32/size + 9771 0x65/e 0x63/c 0x78/x + 9772 + 9773 $Mu-register-edx: + 9774 0x11/imm32/alloc-id + 9775 3/imm32/size + 9776 0x65/e 0x64/d 0x78/x + 9777 + 9778 $Mu-register-ebx: + 9779 0x11/imm32/alloc-id + 9780 3/imm32/size + 9781 0x65/e 0x62/b 0x78/x + 9782 + 9783 $Mu-register-esi: + 9784 0x11/imm32/alloc-id + 9785 3/imm32/size + 9786 0x65/e 0x73/s 0x69/i + 9787 + 9788 $Mu-register-edi: + 9789 0x11/imm32/alloc-id + 9790 3/imm32/size + 9791 0x65/e 0x64/d 0x69/i + 9792 + 9793 == code + 9794 + 9795 # return first 'name' from the top (back) of 'vars' and create a new var for a fn output if not found + 9796 lookup-var-or-find-in-fn-outputs: # name: (addr slice), vars: (addr stack live-var), fn: (addr function), out: (addr handle var), err: (addr buffered-file), ed: (addr exit-descriptor) + 9797 # . prologue + 9798 55/push-ebp + 9799 89/<- %ebp 4/r32/esp + 9800 # . save registers + 9801 50/push-eax + 9802 # + 9803 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) # arg order slightly different; 'fn' is deemphasized + 9804 { + 9805 # if (out != 0) return + 9806 8b/-> *(ebp+0x14) 0/r32/eax + 9807 81 7/subop/compare *eax 0/imm32 + 9808 75/jump-if-!= break/disp8 + 9809 # if name is one of fn's outputs, return it + 9810 (find-in-function-outputs *(ebp+0x10) *(ebp+8) *(ebp+0x14)) + 9811 8b/-> *(ebp+0x14) 0/r32/eax + 9812 81 7/subop/compare *eax 0/imm32 + 9813 # otherwise abort + 9814 0f 84/jump-if-= $lookup-or-define-var:abort/disp32 + 9815 } + 9816 $lookup-or-define-var:end: + 9817 # . restore registers + 9818 58/pop-to-eax + 9819 # . epilogue + 9820 89/<- %esp 5/r32/ebp + 9821 5d/pop-to-ebp + 9822 c3/return + 9823 + 9824 $lookup-or-define-var:abort: + 9825 (write-buffered *(ebp+0x18) "unknown variable '") + 9826 (write-slice-buffered *(ebp+0x18) *(ebp+8)) + 9827 (write-buffered *(ebp+0x18) "'\n") + 9828 (flush *(ebp+0x18)) + 9829 (stop *(ebp+0x1c) 1) + 9830 # never gets here + 9831 + 9832 find-in-function-outputs: # fn: (addr function), name: (addr slice), out: (addr handle var) + 9833 # . prologue + 9834 55/push-ebp + 9835 89/<- %ebp 4/r32/esp + 9836 # . save registers + 9837 50/push-eax + 9838 51/push-ecx + 9839 # var curr/ecx: (addr list var) = lookup(fn->outputs) + 9840 8b/-> *(ebp+8) 1/r32/ecx + 9841 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax + 9842 89/<- %ecx 0/r32/eax + 9843 # while curr != null + 9844 { + 9845 81 7/subop/compare %ecx 0/imm32 + 9846 74/jump-if-= break/disp8 + 9847 # var v/eax: (addr var) = lookup(curr->value) + 9848 (lookup *ecx *(ecx+4)) # List-value List-value => eax + 9849 # var s/eax: (addr array byte) = lookup(v->name) + 9850 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 9851 # if (s == name) return curr->value + 9852 (slice-equal? *(ebp+0xc) %eax) # => eax + 9853 3d/compare-eax-and 0/imm32/false + 9854 { + 9855 74/jump-if-= break/disp8 + 9856 # var edi = out + 9857 57/push-edi + 9858 8b/-> *(ebp+0x10) 7/r32/edi + 9859 # *out = curr->value + 9860 8b/-> *ecx 0/r32/eax + 9861 89/<- *edi 0/r32/eax + 9862 8b/-> *(ecx+4) 0/r32/eax + 9863 89/<- *(edi+4) 0/r32/eax + 9864 # + 9865 5f/pop-to-edi + 9866 eb/jump $find-in-function-outputs:end/disp8 + 9867 } + 9868 # curr = curr->next + 9869 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax + 9870 89/<- %ecx 0/r32/eax + 9871 # + 9872 eb/jump loop/disp8 + 9873 } + 9874 b8/copy-to-eax 0/imm32 + 9875 $find-in-function-outputs:end: + 9876 # . restore registers + 9877 59/pop-to-ecx + 9878 58/pop-to-eax + 9879 # . epilogue + 9880 89/<- %esp 5/r32/ebp + 9881 5d/pop-to-ebp + 9882 c3/return + 9883 + 9884 # push 'out' to 'vars' if not already there; it's assumed to be a fn output + 9885 maybe-define-var: # out: (handle var), vars: (addr stack live-var) + 9886 # . prologue + 9887 55/push-ebp + 9888 89/<- %ebp 4/r32/esp + 9889 # . save registers + 9890 50/push-eax + 9891 # var out-addr/eax: (addr var) + 9892 (lookup *(ebp+8) *(ebp+0xc)) # => eax + 9893 # + 9894 (binding-exists? %eax *(ebp+0x10)) # => eax + 9895 3d/compare-eax-and 0/imm32/false + 9896 75/jump-if-!= $maybe-define-var:end/disp8 + 9897 # otherwise update vars + 9898 (push *(ebp+0x10) *(ebp+8)) + 9899 (push *(ebp+0x10) *(ebp+0xc)) + 9900 (push *(ebp+0x10) 0) # 'out' is always a fn output; never spill it + 9901 $maybe-define-var:end: + 9902 # . restore registers + 9903 58/pop-to-eax + 9904 # . epilogue + 9905 89/<- %esp 5/r32/ebp + 9906 5d/pop-to-ebp + 9907 c3/return + 9908 + 9909 # simpler version of lookup-var-helper + 9910 binding-exists?: # target: (addr var), vars: (addr stack live-var) -> result/eax: boolean + 9911 # pseudocode: + 9912 # var curr: (addr handle var) = &vars->data[vars->top - 12] + 9913 # var min = vars->data + 9914 # while curr >= min + 9915 # var v: (handle var) = *curr + 9916 # if v->name == target->name + 9917 # return true + 9918 # curr -= 12 + 9919 # return false + 9920 # + 9921 # . prologue + 9922 55/push-ebp + 9923 89/<- %ebp 4/r32/esp + 9924 # . save registers + 9925 51/push-ecx + 9926 52/push-edx + 9927 56/push-esi + 9928 # var target-name/ecx: (addr array byte) = lookup(target->name) + 9929 8b/-> *(ebp+8) 0/r32/eax + 9930 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 9931 89/<- %ecx 0/r32/eax + 9932 # esi = vars + 9933 8b/-> *(ebp+0xc) 6/r32/esi + 9934 # eax = vars->top + 9935 8b/-> *esi 0/r32/eax + 9936 # var min/edx: (addr handle var) = vars->data + 9937 8d/copy-address *(esi+8) 2/r32/edx + 9938 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] + 9939 8d/copy-address *(esi+eax-4) 6/r32/esi # vars + 8 + vars->type - 12 + 9940 { + 9941 $binding-exists?:loop: + 9942 # if (curr < min) return + 9943 39/compare %esi 2/r32/edx + 9944 0f 82/jump-if-addr< break/disp32 + 9945 # var v/eax: (addr var) = lookup(*curr) + 9946 (lookup *esi *(esi+4)) # => eax + 9947 # var vn/eax: (addr array byte) = lookup(v->name) + 9948 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 9949 # if (vn == target-name) return true + 9950 (string-equal? %ecx %eax) # => eax + 9951 3d/compare-eax-and 0/imm32/false + 9952 75/jump-if-!= $binding-exists?:end/disp8 # eax already contains true + 9953 # curr -= 12 + 9954 81 5/subop/subtract %esi 0xc/imm32 + 9955 e9/jump loop/disp32 + 9956 } + 9957 b8/copy-to-eax 0/imm32/false + 9958 $binding-exists?:end: + 9959 # . restore registers + 9960 5e/pop-to-esi + 9961 5a/pop-to-edx + 9962 59/pop-to-ecx + 9963 # . epilogue + 9964 89/<- %esp 5/r32/ebp + 9965 5d/pop-to-ebp + 9966 c3/return + 9967 + 9968 test-parse-mu-stmt: + 9969 # . prologue + 9970 55/push-ebp + 9971 89/<- %ebp 4/r32/esp + 9972 # setup + 9973 (clear-stream _test-input-stream) + 9974 (write _test-input-stream "increment n\n") + 9975 # var vars/ecx: (stack (addr var) 16) + 9976 81 5/subop/subtract %esp 0xc0/imm32 + 9977 68/push 0xc0/imm32/size + 9978 68/push 0/imm32/top + 9979 89/<- %ecx 4/r32/esp + 9980 (clear-stack %ecx) + 9981 # var v/edx: (handle var) + 9982 68/push 0/imm32 + 9983 68/push 0/imm32 + 9984 89/<- %edx 4/r32/esp + 9985 # var s/eax: (handle array byte) + 9986 68/push 0/imm32 + 9987 68/push 0/imm32 + 9988 89/<- %eax 4/r32/esp + 9989 # v = new var("n") + 9990 (copy-array Heap "n" %eax) + 9991 (new-var Heap *eax *(eax+4) %edx) + 9992 # + 9993 (push %ecx *edx) + 9994 (push %ecx *(edx+4)) + 9995 (push %ecx 0) + 9996 # var out/eax: (handle stmt) + 9997 68/push 0/imm32 + 9998 68/push 0/imm32 + 9999 89/<- %eax 4/r32/esp +10000 # convert +10001 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) +10002 # var out-addr/edx: (addr stmt) = lookup(*out) +10003 (lookup *eax *(eax+4)) # => eax +10004 89/<- %edx 0/r32/eax +10005 # out->tag +10006 (check-ints-equal *edx 1 "F - test-parse-mu-stmt/tag") # Stmt-tag is Stmt1 +10007 # out->operation +10008 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax +10009 (check-strings-equal %eax "increment" "F - test-parse-mu-stmt/name") # Stmt1-operation +10010 # out->inouts->value->name +10011 # . eax = out->inouts +10012 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +10013 # . eax = out->inouts->value +10014 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +10015 # . eax = out->inouts->value->name +10016 (lookup *eax *(eax+4)) # Var-name Var-name => eax +10017 # . +10018 (check-strings-equal %eax "n" "F - test-parse-mu-stmt/inout:0") +10019 # . epilogue +10020 89/<- %esp 5/r32/ebp +10021 5d/pop-to-ebp +10022 c3/return +10023 +10024 test-parse-mu-stmt-with-comma: +10025 # . prologue +10026 55/push-ebp +10027 89/<- %ebp 4/r32/esp +10028 # setup +10029 (clear-stream _test-input-stream) +10030 (write _test-input-stream "copy-to n, 3\n") +10031 # var vars/ecx: (stack (addr var) 16) +10032 81 5/subop/subtract %esp 0xc0/imm32 +10033 68/push 0xc0/imm32/size +10034 68/push 0/imm32/top +10035 89/<- %ecx 4/r32/esp +10036 (clear-stack %ecx) +10037 # var v/edx: (handle var) +10038 68/push 0/imm32 +10039 68/push 0/imm32 +10040 89/<- %edx 4/r32/esp +10041 # var s/eax: (handle array byte) +10042 68/push 0/imm32 +10043 68/push 0/imm32 +10044 89/<- %eax 4/r32/esp +10045 # v = new var("n") +10046 (copy-array Heap "n" %eax) +10047 (new-var Heap *eax *(eax+4) %edx) +10048 # +10049 (push %ecx *edx) +10050 (push %ecx *(edx+4)) +10051 (push %ecx 0) +10052 # var out/eax: (handle stmt) +10053 68/push 0/imm32 +10054 68/push 0/imm32 +10055 89/<- %eax 4/r32/esp +10056 # convert +10057 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) +10058 # var out-addr/edx: (addr stmt) = lookup(*out) +10059 (lookup *eax *(eax+4)) # => eax +10060 89/<- %edx 0/r32/eax +10061 # out->tag +10062 (check-ints-equal *edx 1 "F - test-parse-mu-stmt-with-comma/tag") # Stmt-tag is Stmt1 +10063 # out->operation +10064 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax +10065 (check-strings-equal %eax "copy-to" "F - test-parse-mu-stmt-with-comma/name") # Stmt1-operation +10066 # out->inouts->value->name +10067 # . eax = out->inouts +10068 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +10069 # . eax = out->inouts->value +10070 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +10071 # . eax = out->inouts->value->name +10072 (lookup *eax *(eax+4)) # Var-name Var-name => eax +10073 # . +10074 (check-strings-equal %eax "n" "F - test-parse-mu-stmt-with-comma/inout:0") +10075 # . epilogue +10076 89/<- %esp 5/r32/ebp +10077 5d/pop-to-ebp +10078 c3/return +10079 +10080 new-var: # ad: (addr allocation-descriptor), name: (handle array byte), out: (addr handle var) +10081 # . prologue +10082 55/push-ebp +10083 89/<- %ebp 4/r32/esp +10084 # . save registers +10085 50/push-eax +10086 51/push-ecx +10087 # ecx = out +10088 8b/-> *(ebp+0x14) 1/r32/ecx +10089 # +10090 (allocate *(ebp+8) *Var-size %ecx) +10091 # var out-addr/eax: (addr var) +10092 (lookup *ecx *(ecx+4)) # => eax +10093 # out-addr->name = name +10094 8b/-> *(ebp+0xc) 1/r32/ecx +10095 89/<- *eax 1/r32/ecx # Var-name +10096 8b/-> *(ebp+0x10) 1/r32/ecx +10097 89/<- *(eax+4) 1/r32/ecx # Var-name +10098 #? (write-buffered Stderr "var ") +10099 #? (lookup *(ebp+0xc) *(ebp+0x10)) +10100 #? (write-buffered Stderr %eax) +10101 #? (write-buffered Stderr " at ") +10102 #? 8b/-> *(ebp+0x14) 1/r32/ecx +10103 #? (lookup *ecx *(ecx+4)) # => eax +10104 #? (write-int32-hex-buffered Stderr %eax) +10105 #? (write-buffered Stderr Newline) +10106 #? (flush Stderr) +10107 $new-var:end: 10108 # . restore registers -10109 5a/pop-to-edx -10110 59/pop-to-ecx -10111 58/pop-to-eax -10112 # . epilogue -10113 89/<- %esp 5/r32/ebp -10114 5d/pop-to-ebp -10115 c3/return -10116 -10117 new-literal: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) -10118 # . prologue -10119 55/push-ebp -10120 89/<- %ebp 4/r32/esp -10121 # . save registers -10122 50/push-eax -10123 51/push-ecx -10124 # var s/ecx: (handle array byte) -10125 68/push 0/imm32 -10126 68/push 0/imm32 -10127 89/<- %ecx 4/r32/esp -10128 # s = slice-to-string(name) -10129 (slice-to-string Heap *(ebp+0xc) %ecx) -10130 # allocate to out -10131 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) -10132 # var out-addr/ecx: (addr var) = lookup(*out) -10133 8b/-> *(ebp+0x10) 1/r32/ecx -10134 (lookup *ecx *(ecx+4)) # => eax -10135 89/<- %ecx 0/r32/eax -10136 # out-addr->block-depth = *Curr-block-depth -10137 8b/-> *Curr-block-depth 0/r32/eax -10138 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -10139 # out-addr->type/eax = new type -10140 8d/copy-address *(ecx+8) 0/r32/eax # Var-type -10141 (allocate *(ebp+8) *Type-tree-size %eax) -10142 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +10109 59/pop-to-ecx +10110 58/pop-to-eax +10111 # . epilogue +10112 89/<- %esp 5/r32/ebp +10113 5d/pop-to-ebp +10114 c3/return +10115 +10116 new-literal-integer: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +10117 # . prologue +10118 55/push-ebp +10119 89/<- %ebp 4/r32/esp +10120 # . save registers +10121 50/push-eax +10122 51/push-ecx +10123 # if (!is-hex-int?(name)) abort +10124 (is-hex-int? *(ebp+0xc)) # => eax +10125 3d/compare-eax-and 0/imm32/false +10126 0f 84/jump-if-= $new-literal-integer:abort/disp32 +10127 # a little more error-checking +10128 (check-mu-hex-int *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c)) +10129 # out = new var(s) +10130 (new-var-from-slice *(ebp+8) *(ebp+0xc) *(ebp+0x10)) +10131 # var out-addr/ecx: (addr var) = lookup(*out) +10132 8b/-> *(ebp+0x10) 0/r32/eax +10133 (lookup *eax *(eax+4)) # => eax +10134 89/<- %ecx 0/r32/eax +10135 # out-addr->block-depth = *Curr-block-depth +10136 8b/-> *Curr-block-depth 0/r32/eax +10137 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +10138 # out-addr->type = new tree() +10139 8d/copy-address *(ecx+8) 0/r32/eax # Var-type +10140 (allocate *(ebp+8) *Type-tree-size %eax) +10141 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +10142 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom 10143 # nothing else to do; default type is 'literal' -10144 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -10145 $new-literal:end: -10146 # . reclaim locals -10147 81 0/subop/add %esp 8/imm32 -10148 # . restore registers -10149 59/pop-to-ecx -10150 58/pop-to-eax -10151 # . epilogue -10152 89/<- %esp 5/r32/ebp -10153 5d/pop-to-ebp -10154 c3/return -10155 -10156 new-var-from-slice: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) -10157 # . prologue -10158 55/push-ebp -10159 89/<- %ebp 4/r32/esp -10160 # . save registers -10161 51/push-ecx -10162 # var tmp/ecx: (handle array byte) -10163 68/push 0/imm32 -10164 68/push 0/imm32 -10165 89/<- %ecx 4/r32/esp -10166 # tmp = slice-to-string(name) -10167 (slice-to-string Heap *(ebp+0xc) %ecx) -10168 # out = new-var(tmp) -10169 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) -10170 $new-var-from-slice:end: -10171 # . reclaim locals -10172 81 0/subop/add %esp 8/imm32 -10173 # . restore registers -10174 59/pop-to-ecx -10175 # . epilogue -10176 89/<- %esp 5/r32/ebp -10177 5d/pop-to-ebp -10178 c3/return -10179 -10180 new-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) -10181 # . prologue -10182 55/push-ebp -10183 89/<- %ebp 4/r32/esp -10184 # . save registers -10185 50/push-eax -10186 51/push-ecx -10187 # -10188 (allocate *(ebp+8) *Stmt-size *(ebp+0x14)) -10189 # var out-addr/eax: (addr stmt) = lookup(*out) -10190 8b/-> *(ebp+0x14) 0/r32/eax -10191 (lookup *eax *(eax+4)) # => eax -10192 # out-addr->tag = stmt -10193 c7 0/subop/copy *eax 2/imm32/tag/var-on-stack # Stmt-tag -10194 # result->var = var -10195 8b/-> *(ebp+0xc) 1/r32/ecx -10196 89/<- *(eax+4) 1/r32/ecx # Vardef-var -10197 8b/-> *(ebp+0x10) 1/r32/ecx -10198 89/<- *(eax+8) 1/r32/ecx # Vardef-var -10199 $new-var-def:end: -10200 # . restore registers -10201 59/pop-to-ecx -10202 58/pop-to-eax -10203 # . epilogue -10204 89/<- %esp 5/r32/ebp -10205 5d/pop-to-ebp -10206 c3/return -10207 -10208 new-reg-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) -10209 # . prologue -10210 55/push-ebp -10211 89/<- %ebp 4/r32/esp -10212 # . save registers -10213 50/push-eax -10214 # eax = out -10215 8b/-> *(ebp+0x14) 0/r32/eax -10216 # -10217 (allocate *(ebp+8) *Stmt-size %eax) -10218 # var out-addr/eax: (addr stmt) = lookup(*out) -10219 (lookup *eax *(eax+4)) # => eax -10220 # set tag -10221 c7 0/subop/copy *eax 3/imm32/tag/var-in-register # Stmt-tag -10222 # set output -10223 8d/copy-address *(eax+0x14) 0/r32/eax # Regvardef-outputs -10224 (append-stmt-var Heap *(ebp+0xc) *(ebp+0x10) 0 0 0 %eax) -10225 $new-reg-var-def:end: -10226 # . restore registers -10227 58/pop-to-eax -10228 # . epilogue -10229 89/<- %esp 5/r32/ebp -10230 5d/pop-to-ebp -10231 c3/return -10232 -10233 append-list: # ad: (addr allocation-descriptor), value: (handle _type), list: (handle list _type), out: (addr handle list _type) -10234 # . prologue -10235 55/push-ebp -10236 89/<- %ebp 4/r32/esp -10237 # . save registers -10238 50/push-eax -10239 51/push-ecx -10240 57/push-edi -10241 # edi = out -10242 8b/-> *(ebp+0x1c) 7/r32/edi -10243 # *out = new list -10244 (allocate *(ebp+8) *List-size %edi) -10245 # var out-addr/edi: (addr list _type) = lookup(*out) -10246 (lookup *edi *(edi+4)) # => eax -10247 89/<- %edi 0/r32/eax -10248 # out-addr->value = value -10249 8b/-> *(ebp+0xc) 0/r32/eax -10250 89/<- *edi 0/r32/eax # List-value -10251 8b/-> *(ebp+0x10) 0/r32/eax -10252 89/<- *(edi+4) 0/r32/eax # List-value -10253 # if (list == null) return -10254 81 7/subop/compare *(ebp+0x14) 0/imm32 -10255 74/jump-if-= $append-list:end/disp8 -10256 # otherwise append -10257 $append-list:non-empty-list: -10258 # var curr/eax: (addr list _type) = lookup(list) -10259 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax -10260 # while (curr->next != null) curr = curr->next -10261 { -10262 81 7/subop/compare *(eax+8) 0/imm32 # List-next -10263 74/jump-if-= break/disp8 -10264 # curr = lookup(curr->next) -10265 (lookup *(eax+8) *(eax+0xc)) # List-next, List-next => eax -10266 # -10267 eb/jump loop/disp8 -10268 } -10269 # edi = out -10270 8b/-> *(ebp+0x1c) 7/r32/edi -10271 # curr->next = out -10272 8b/-> *edi 1/r32/ecx -10273 89/<- *(eax+8) 1/r32/ecx # List-next -10274 8b/-> *(edi+4) 1/r32/ecx -10275 89/<- *(eax+0xc) 1/r32/ecx # List-next -10276 # out = list -10277 8b/-> *(ebp+0x14) 1/r32/ecx -10278 89/<- *edi 1/r32/ecx -10279 8b/-> *(ebp+0x18) 1/r32/ecx -10280 89/<- *(edi+4) 1/r32/ecx -10281 $append-list:end: -10282 # . restore registers -10283 5f/pop-to-edi -10284 59/pop-to-ecx -10285 58/pop-to-eax -10286 # . epilogue -10287 89/<- %esp 5/r32/ebp -10288 5d/pop-to-ebp -10289 c3/return -10290 -10291 append-stmt-var: # ad: (addr allocation-descriptor), v: (handle var), vars: (handle stmt-var), is-deref?: boolean, out: (addr handle stmt-var) -10292 # . prologue -10293 55/push-ebp -10294 89/<- %ebp 4/r32/esp -10295 # . save registers -10296 50/push-eax -10297 51/push-ecx -10298 57/push-edi -10299 # edi = out -10300 8b/-> *(ebp+0x20) 7/r32/edi -10301 # out = new stmt-var -10302 (allocate *(ebp+8) *Stmt-var-size %edi) -10303 # var out-addr/ecx: (addr stmt-var) = lookup(*out) -10304 (lookup *edi *(edi+4)) # => eax -10305 89/<- %ecx 0/r32/eax -10306 # out-addr->value = v -10307 8b/-> *(ebp+0xc) 0/r32/eax -10308 89/<- *ecx 0/r32/eax # Stmt-var-value -10309 8b/-> *(ebp+0x10) 0/r32/eax -10310 89/<- *(ecx+4) 0/r32/eax # Stmt-var-value -10311 # out-addr->is-deref? = is-deref? -10312 8b/-> *(ebp+0x1c) 0/r32/eax -10313 89/<- *(ecx+0x10) 0/r32/eax # Stmt-var-is-deref -10314 # if (vars == null) return result -10315 81 7/subop/compare *(ebp+0x14) 0/imm32/null -10316 74/jump-if-= $append-stmt-var:end/disp8 -10317 # otherwise append -10318 # var curr/eax: (addr stmt-var) = lookup(vars) -10319 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax -10320 # while (curr->next != null) curr = curr->next -10321 { -10322 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next -10323 74/jump-if-= break/disp8 -10324 # curr = lookup(curr->next) -10325 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next, Stmt-var-next => eax -10326 # -10327 eb/jump loop/disp8 -10328 } -10329 # curr->next = out -10330 8b/-> *edi 1/r32/ecx -10331 89/<- *(eax+8) 1/r32/ecx # Stmt-var-next -10332 8b/-> *(edi+4) 1/r32/ecx -10333 89/<- *(eax+0xc) 1/r32/ecx # Stmt-var-next -10334 # out = vars -10335 8b/-> *(ebp+0x14) 1/r32/ecx -10336 89/<- *edi 1/r32/ecx -10337 8b/-> *(ebp+0x18) 1/r32/ecx -10338 89/<- *(edi+4) 1/r32/ecx -10339 $append-stmt-var:end: -10340 # . restore registers -10341 5f/pop-to-edi -10342 59/pop-to-ecx -10343 58/pop-to-eax -10344 # . epilogue -10345 89/<- %esp 5/r32/ebp -10346 5d/pop-to-ebp -10347 c3/return -10348 -10349 append-to-block: # ad: (addr allocation-descriptor), block: (addr block), x: (handle stmt) -10350 # . prologue -10351 55/push-ebp -10352 89/<- %ebp 4/r32/esp -10353 # . save registers -10354 50/push-eax -10355 56/push-esi -10356 # esi = block -10357 8b/-> *(ebp+0xc) 6/r32/esi -10358 # block->stmts = append(x, block->stmts) -10359 8d/copy-address *(esi+4) 0/r32/eax # Block-stmts -10360 (append-list *(ebp+8) *(ebp+0x10) *(ebp+0x14) *(esi+4) *(esi+8) %eax) # ad, x, x, Block-stmts, Block-stmts -10361 $append-to-block:end: -10362 # . restore registers -10363 5e/pop-to-esi -10364 58/pop-to-eax -10365 # . epilogue -10366 89/<- %esp 5/r32/ebp -10367 5d/pop-to-ebp -10368 c3/return -10369 -10370 ## Parsing types -10371 # We need to create metadata on user-defined types, and we need to use this -10372 # metadata as we parse instructions. -10373 # However, we also want to allow types to be used before their definitions. -10374 # This means we can't ever assume any type data structures exist. -10375 -10376 lookup-or-create-constant: # container: (addr stmt-var), field-name: (addr slice), out: (addr handle var) -10377 # . prologue -10378 55/push-ebp -10379 89/<- %ebp 4/r32/esp -10380 # . save registers -10381 50/push-eax -10382 56/push-esi -10383 # var container-type/esi: type-id -10384 (container-type *(ebp+8)) # => eax -10385 89/<- %esi 0/r32/eax -10386 # var tmp/eax: (handle typeinfo) = find-or-create-typeinfo(container-type) -10387 68/push 0/imm32 -10388 68/push 0/imm32 -10389 89/<- %eax 4/r32/esp -10390 (find-or-create-typeinfo %esi %eax) -10391 # var tmp-addr/eax: (addr typeinfo) = lookup(tmp) -10392 (lookup *eax *(eax+4)) # => eax -10393 # result = find-or-create-typeinfo-output-var(typeinfo, field-name) -10394 #? (write-buffered Stderr "constant: ") -10395 #? (write-slice-buffered Stderr *(ebp+0xc)) -10396 #? (write-buffered Stderr Newline) -10397 #? (flush Stderr) -10398 (find-or-create-typeinfo-output-var %eax *(ebp+0xc) *(ebp+0x10)) -10399 #? 8b/-> *(ebp+0x10) 0/r32/eax -10400 #? (write-buffered Stderr "@") -10401 #? (lookup *eax *(eax+4)) -10402 #? (write-int32-hex-buffered Stderr %eax) -10403 #? (lookup *eax *(eax+4)) -10404 #? (write-buffered Stderr %eax) -10405 #? (write-buffered Stderr Newline) -10406 #? (flush Stderr) -10407 #? (write-buffered Stderr "offset: ") -10408 #? 8b/-> *(eax+0x14) 0/r32/eax -10409 #? (write-int32-hex-buffered Stderr %eax) -10410 #? (write-buffered Stderr Newline) -10411 #? (flush Stderr) -10412 $lookup-or-create-constant:end: -10413 # . reclaim locals -10414 81 0/subop/add %esp 8/imm32 -10415 # . restore registers -10416 5e/pop-to-esi -10417 58/pop-to-eax -10418 # . epilogue -10419 89/<- %esp 5/r32/ebp -10420 5d/pop-to-ebp -10421 c3/return -10422 -10423 # if addr var: -10424 # container->var->type->right->left->value -10425 # otherwise -10426 # container->var->type->value -10427 container-type: # container: (addr stmt-var) -> result/eax: type-id -10428 # . prologue -10429 55/push-ebp -10430 89/<- %ebp 4/r32/esp -10431 # -10432 8b/-> *(ebp+8) 0/r32/eax -10433 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -10434 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -10435 { -10436 81 7/subop/compare *(eax+8) 0/imm32 # Type-tree-right -10437 74/jump-if-= break/disp8 -10438 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -10439 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -10440 } -10441 8b/-> *(eax+4) 0/r32/eax # Type-tree-value -10442 $container-type:end: -10443 # . epilogue -10444 89/<- %esp 5/r32/ebp -10445 5d/pop-to-ebp -10446 c3/return -10447 -10448 is-container?: # t: type-id -> result/eax: boolean -10449 # . prologue -10450 55/push-ebp -10451 89/<- %ebp 4/r32/esp -10452 # -10453 8b/-> *(ebp+8) 0/r32/eax -10454 c1/shift 4/subop/left %eax 2/imm8 -10455 3b/compare 0/r32/eax *Primitive-type-ids -10456 0f 9d/set-if->= %al -10457 81 4/subop/and %eax 0xff/imm32 -10458 $is-container?:end: -10459 # . epilogue -10460 89/<- %esp 5/r32/ebp -10461 5d/pop-to-ebp -10462 c3/return -10463 -10464 find-or-create-typeinfo: # t: type-id, out: (addr handle typeinfo) -10465 # . prologue -10466 55/push-ebp -10467 89/<- %ebp 4/r32/esp -10468 # . save registers -10469 50/push-eax -10470 51/push-ecx -10471 52/push-edx -10472 57/push-edi -10473 # edi = out -10474 8b/-> *(ebp+0xc) 7/r32/edi -10475 # var fields/ecx: (handle table (handle array byte) (handle typeinfo-entry)) -10476 68/push 0/imm32 -10477 68/push 0/imm32 -10478 89/<- %ecx 4/r32/esp -10479 # find-typeinfo(t, out) -10480 (find-typeinfo *(ebp+8) %edi) -10481 { -10482 # if (*out != 0) break -10483 81 7/subop/compare *edi 0/imm32 -10484 0f 85/jump-if-!= break/disp32 -10485 $find-or-create-typeinfo:create: -10486 # *out = allocate -10487 (allocate Heap *Typeinfo-size %edi) -10488 # var tmp/eax: (addr typeinfo) = lookup(*out) -10489 (lookup *edi *(edi+4)) # => eax -10490 #? (write-buffered Stderr "created typeinfo at ") -10491 #? (write-int32-hex-buffered Stderr %eax) -10492 #? (write-buffered Stderr " for type-id ") -10493 #? (write-int32-hex-buffered Stderr *(ebp+8)) -10494 #? (write-buffered Stderr Newline) -10495 #? (flush Stderr) -10496 # tmp->id = t -10497 8b/-> *(ebp+8) 2/r32/edx -10498 89/<- *eax 2/r32/edx # Typeinfo-id -10499 # tmp->fields = new table -10500 # . fields = new table -10501 (new-stream Heap 0x40 *Typeinfo-fields-row-size %ecx) -10502 # . tmp->fields = fields -10503 8b/-> *ecx 2/r32/edx -10504 89/<- *(eax+4) 2/r32/edx # Typeinfo-fields -10505 8b/-> *(ecx+4) 2/r32/edx -10506 89/<- *(eax+8) 2/r32/edx # Typeinfo-fields -10507 # tmp->next = Program->types -10508 8b/-> *_Program-types 1/r32/ecx -10509 89/<- *(eax+0x10) 1/r32/ecx # Typeinfo-next -10510 8b/-> *_Program-types->payload 1/r32/ecx -10511 89/<- *(eax+0x14) 1/r32/ecx # Typeinfo-next -10512 # Program->types = out -10513 8b/-> *edi 1/r32/ecx -10514 89/<- *_Program-types 1/r32/ecx -10515 8b/-> *(edi+4) 1/r32/ecx -10516 89/<- *_Program-types->payload 1/r32/ecx -10517 } -10518 $find-or-create-typeinfo:end: -10519 # . reclaim locals -10520 81 0/subop/add %esp 8/imm32 -10521 # . restore registers -10522 5f/pop-to-edi -10523 5a/pop-to-edx -10524 59/pop-to-ecx -10525 58/pop-to-eax -10526 # . epilogue -10527 89/<- %esp 5/r32/ebp -10528 5d/pop-to-ebp -10529 c3/return -10530 -10531 find-typeinfo: # t: type-id, out: (addr handle typeinfo) -10532 # . prologue -10533 55/push-ebp -10534 89/<- %ebp 4/r32/esp -10535 # . save registers -10536 50/push-eax -10537 51/push-ecx -10538 52/push-edx -10539 57/push-edi -10540 # ecx = t -10541 8b/-> *(ebp+8) 1/r32/ecx -10542 # edi = out -10543 8b/-> *(ebp+0xc) 7/r32/edi -10544 # *out = Program->types -10545 8b/-> *_Program-types 0/r32/eax -10546 89/<- *edi 0/r32/eax -10547 8b/-> *_Program-types->payload 0/r32/eax -10548 89/<- *(edi+4) 0/r32/eax -10549 { -10550 $find-typeinfo:loop: -10551 # if (*out == 0) break -10552 81 7/subop/compare *edi 0/imm32 -10553 74/jump-if-= break/disp8 -10554 $find-typeinfo:check: -10555 # var tmp/eax: (addr typeinfo) = lookup(*out) -10556 (lookup *edi *(edi+4)) # => eax -10557 # if (tmp->id == t) break -10558 39/compare *eax 1/r32/ecx # Typeinfo-id -10559 74/jump-if-= break/disp8 -10560 $find-typeinfo:continue: -10561 # *out = tmp->next -10562 8b/-> *(eax+0x10) 2/r32/edx # Typeinfo-next -10563 89/<- *edi 2/r32/edx -10564 8b/-> *(eax+0x14) 2/r32/edx # Typeinfo-next -10565 89/<- *(edi+4) 2/r32/edx -10566 # -10567 eb/jump loop/disp8 -10568 } -10569 $find-typeinfo:end: -10570 # . restore registers -10571 5f/pop-to-edi -10572 5a/pop-to-edx -10573 59/pop-to-ecx -10574 58/pop-to-eax -10575 # . epilogue -10576 89/<- %esp 5/r32/ebp -10577 5d/pop-to-ebp -10578 c3/return -10579 -10580 find-or-create-typeinfo-output-var: # T: (addr typeinfo), f: (addr slice), out: (addr handle var) -10581 # . prologue -10582 55/push-ebp -10583 89/<- %ebp 4/r32/esp -10584 # . save registers -10585 50/push-eax -10586 52/push-edx -10587 57/push-edi -10588 # var dest/edi: (handle typeinfo-entry) -10589 68/push 0/imm32 -10590 68/push 0/imm32 -10591 89/<- %edi 4/r32/esp -10592 # find-or-create-typeinfo-fields(T, f, dest) -10593 (find-or-create-typeinfo-fields *(ebp+8) *(ebp+0xc) %edi) -10594 # var dest-addr/edi: (addr typeinfo-entry) = lookup(dest) -10595 (lookup *edi *(edi+4)) # => eax -10596 89/<- %edi 0/r32/eax -10597 # if dest-addr->output-var doesn't exist, create it -10598 { -10599 81 7/subop/compare *(edi+0xc) 0/imm32 # Typeinfo-entry-output-var -10600 0f 85/jump-if-!= break/disp32 -10601 # dest-addr->output-var = new var(dummy name, type, -1 offset) -10602 # . var name/eax: (handle array byte) = "field" -10603 68/push 0/imm32 -10604 68/push 0/imm32 -10605 89/<- %eax 4/r32/esp -10606 (slice-to-string Heap *(ebp+0xc) %eax) -10607 # . new var -10608 8d/copy-address *(edi+0xc) 2/r32/edx -10609 (new-var Heap *eax *(eax+4) %edx) -10610 # . reclaim name -10611 81 0/subop/add %esp 8/imm32 -10612 # var result/edx: (addr var) = lookup(dest-addr->output-var) -10613 (lookup *(edi+0xc) *(edi+0x10)) # => eax -10614 89/<- %edx 0/r32/eax -10615 # result->type = new constant type -10616 8d/copy-address *(edx+8) 0/r32/eax # Var-type -10617 (allocate Heap *Type-tree-size %eax) -10618 (lookup *(edx+8) *(edx+0xc)) # => eax -10619 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -10620 c7 0/subop/copy *(eax+4) 6/imm32/constant # Type-tree-value -10621 c7 0/subop/copy *(eax+8) 0/imm32 # Type-tree-left -10622 c7 0/subop/copy *(eax+0xc) 0/imm32 # Type-tree-right -10623 c7 0/subop/copy *(eax+0x10) 0/imm32 # Type-tree-right -10624 # result->offset isn't filled out yet -10625 c7 0/subop/copy *(edx+0x14) -1/imm32/uninitialized # Var-offset -10626 } -10627 # out = dest-addr->output-var -10628 8b/-> *(ebp+0x10) 2/r32/edx -10629 8b/-> *(edi+0xc) 0/r32/eax # Typeinfo-entry-output-var -10630 89/<- *edx 0/r32/eax -10631 8b/-> *(edi+0x10) 0/r32/eax # Typeinfo-entry-output-var -10632 89/<- *(edx+4) 0/r32/eax -10633 $find-or-create-typeinfo-output-var:end: -10634 # . reclaim locals -10635 81 0/subop/add %esp 8/imm32 -10636 # . restore registers -10637 5f/pop-to-edi -10638 5a/pop-to-edx -10639 58/pop-to-eax -10640 # . epilogue -10641 89/<- %esp 5/r32/ebp -10642 5d/pop-to-ebp -10643 c3/return -10644 -10645 find-or-create-typeinfo-fields: # T: (addr typeinfo), f: (addr slice), out: (addr handle typeinfo-entry) -10646 # . prologue -10647 55/push-ebp -10648 89/<- %ebp 4/r32/esp -10649 # . save registers -10650 50/push-eax -10651 56/push-esi -10652 57/push-edi -10653 # eax = lookup(T->fields) -10654 8b/-> *(ebp+8) 0/r32/eax -10655 (lookup *(eax+4) *(eax+8)) # Typeinfo-fields Typeinfo-fields => eax -10656 # edi = out -10657 8b/-> *(ebp+0x10) 7/r32/edi -10658 # var src/esi: (addr handle typeinfo-entry) = get-or-insert-slice(T->fields, f) -10659 (get-or-insert-slice %eax *(ebp+0xc) *Typeinfo-fields-row-size Heap) # => eax -10660 89/<- %esi 0/r32/eax -10661 # if src doesn't exist, allocate it -10662 { -10663 81 7/subop/compare *esi 0/imm32 -10664 75/jump-if-!= break/disp8 -10665 (allocate Heap *Typeinfo-entry-size %esi) -10666 #? (write-buffered Stderr "handle at ") -10667 #? (write-int32-hex-buffered Stderr %esi) -10668 #? (write-buffered Stderr ": ") -10669 #? (write-int32-hex-buffered Stderr *esi) -10670 #? (write-buffered Stderr " ") -10671 #? (write-int32-hex-buffered Stderr *(esi+4)) -10672 #? (write-buffered Stderr Newline) -10673 #? (flush Stderr) -10674 #? (lookup *esi *(esi+4)) -10675 #? (write-buffered Stderr "created typeinfo fields at ") -10676 #? (write-int32-hex-buffered Stderr %esi) -10677 #? (write-buffered Stderr " for ") -10678 #? (write-int32-hex-buffered Stderr *(ebp+8)) -10679 #? (write-buffered Stderr Newline) -10680 #? (flush Stderr) -10681 } -10682 # *out = src -10683 # . *edi = *src -10684 8b/-> *esi 0/r32/eax -10685 89/<- *edi 0/r32/eax -10686 8b/-> *(esi+4) 0/r32/eax -10687 89/<- *(edi+4) 0/r32/eax -10688 $find-or-create-typeinfo-fields:end: -10689 # . restore registers -10690 5f/pop-to-edi -10691 5e/pop-to-esi -10692 58/pop-to-eax -10693 # . epilogue -10694 89/<- %esp 5/r32/ebp -10695 5d/pop-to-ebp -10696 c3/return -10697 -10698 populate-mu-type: # in: (addr stream byte), t: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -10699 # pseudocode: -10700 # var line: (stream byte 512) -10701 # curr-index = 0 -10702 # while true -10703 # clear-stream(line) -10704 # read-line-buffered(in, line) -10705 # if line->write == 0 -10706 # abort -10707 # word-slice = next-mu-token(line) -10708 # if slice-empty?(word-slice) # end of line -10709 # continue -10710 # if slice-equal?(word-slice, "}") -10711 # break -10712 # var v: (handle var) = parse-var-with-type(word-slice, line) -10713 # var r: (handle typeinfo-fields) = find-or-create-typeinfo-fields(t, word-slice/v->name) -10714 # TODO: ensure that r->first is null -10715 # r->index = curr-index -10716 # curr-index++ -10717 # r->input-var = v -10718 # if r->output-var == 0 -10719 # r->output-var = new literal -10720 # TODO: ensure nothing else in line -10721 # t->total-size-in-bytes = -2 (not yet initialized) -10722 # -10723 # . prologue -10724 55/push-ebp -10725 89/<- %ebp 4/r32/esp -10726 # var curr-index: int at *(ebp-4) -10727 68/push 0/imm32 -10728 # . save registers -10729 50/push-eax -10730 51/push-ecx -10731 52/push-edx -10732 53/push-ebx -10733 56/push-esi -10734 57/push-edi -10735 # edi = t -10736 8b/-> *(ebp+0xc) 7/r32/edi -10737 # var line/ecx: (stream byte 512) -10738 81 5/subop/subtract %esp 0x200/imm32 -10739 68/push 0x200/imm32/size -10740 68/push 0/imm32/read -10741 68/push 0/imm32/write -10742 89/<- %ecx 4/r32/esp -10743 # var word-slice/edx: slice -10744 68/push 0/imm32/end -10745 68/push 0/imm32/start -10746 89/<- %edx 4/r32/esp -10747 # var v/esi: (handle var) -10748 68/push 0/imm32 -10749 68/push 0/imm32 -10750 89/<- %esi 4/r32/esp -10751 # var r/ebx: (handle typeinfo-entry) -10752 68/push 0/imm32 -10753 68/push 0/imm32 -10754 89/<- %ebx 4/r32/esp +10144 $new-literal-integer:end: +10145 # . reclaim locals +10146 81 0/subop/add %esp 8/imm32 +10147 # . restore registers +10148 59/pop-to-ecx +10149 58/pop-to-eax +10150 # . epilogue +10151 89/<- %esp 5/r32/ebp +10152 5d/pop-to-ebp +10153 c3/return +10154 +10155 $new-literal-integer:abort: +10156 (write-buffered *(ebp+0x18) "fn ") +10157 8b/-> *(ebp+0x14) 0/r32/eax +10158 (lookup *eax *(eax+4)) # Function-name Function-name => eax +10159 (write-buffered *(ebp+0x18) %eax) +10160 (write-buffered *(ebp+0x18) ": variable '") +10161 (write-slice-buffered *(ebp+0x18) *(ebp+0xc)) +10162 (write-buffered *(ebp+0x18) "' cannot begin with a digit (or do you have a typo in a number?)\n") +10163 (flush *(ebp+0x18)) +10164 (stop *(ebp+0x1c) 1) +10165 # never gets here +10166 +10167 # precondition: name is a valid hex integer; require a '0x' prefix +10168 check-mu-hex-int: # name: (addr slice), err: (addr buffered-file), ed: (addr exit-descriptor) +10169 # . prologue +10170 55/push-ebp +10171 89/<- %ebp 4/r32/esp +10172 # . save registers +10173 50/push-eax +10174 51/push-ecx +10175 52/push-edx +10176 # +10177 8b/-> *(ebp+8) 1/r32/ecx +10178 # var start/ecx: (addr byte) = name->start +10179 8b/-> *(ecx+4) 2/r32/edx +10180 # var end/ecx: (addr byte) = name->end +10181 8b/-> *ecx 1/r32/ecx +10182 # var len/eax: int = name->end - name->start +10183 89/<- %eax 2/r32/edx +10184 29/subtract-from %eax 1/r32/ecx +10185 # if (len <= 1) return +10186 3d/compare-eax-with 1/imm32 +10187 0f 8e/jump-if-<= $check-mu-hex-int:end/disp32 +10188 $check-mu-hex-int:length->-1: +10189 # if slice-starts-with?("0x") return +10190 (slice-starts-with? *(ebp+8) "0x") # => eax +10191 3d/compare-eax-with 0/imm32/false +10192 75/jump-if-!= $check-mu-hex-int:end/disp8 +10193 $check-mu-hex-int:abort: +10194 # otherwise abort +10195 (write-buffered *(ebp+0xc) "literal integers are always hex in Mu; either start '") +10196 (write-slice-buffered *(ebp+0xc) *(ebp+8)) +10197 (write-buffered *(ebp+0xc) "' with a '0x' to be unambiguous, or convert it to decimal.\n") +10198 (flush *(ebp+0xc)) +10199 (stop *(ebp+0x10) 1) +10200 $check-mu-hex-int:end: +10201 # . restore registers +10202 5a/pop-to-edx +10203 59/pop-to-ecx +10204 58/pop-to-eax +10205 # . epilogue +10206 89/<- %esp 5/r32/ebp +10207 5d/pop-to-ebp +10208 c3/return +10209 +10210 new-literal: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) +10211 # . prologue +10212 55/push-ebp +10213 89/<- %ebp 4/r32/esp +10214 # . save registers +10215 50/push-eax +10216 51/push-ecx +10217 # var s/ecx: (handle array byte) +10218 68/push 0/imm32 +10219 68/push 0/imm32 +10220 89/<- %ecx 4/r32/esp +10221 # s = slice-to-string(name) +10222 (slice-to-string Heap *(ebp+0xc) %ecx) +10223 # allocate to out +10224 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) +10225 # var out-addr/ecx: (addr var) = lookup(*out) +10226 8b/-> *(ebp+0x10) 1/r32/ecx +10227 (lookup *ecx *(ecx+4)) # => eax +10228 89/<- %ecx 0/r32/eax +10229 # out-addr->block-depth = *Curr-block-depth +10230 8b/-> *Curr-block-depth 0/r32/eax +10231 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +10232 # out-addr->type/eax = new type +10233 8d/copy-address *(ecx+8) 0/r32/eax # Var-type +10234 (allocate *(ebp+8) *Type-tree-size %eax) +10235 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +10236 # nothing else to do; default type is 'literal' +10237 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +10238 $new-literal:end: +10239 # . reclaim locals +10240 81 0/subop/add %esp 8/imm32 +10241 # . restore registers +10242 59/pop-to-ecx +10243 58/pop-to-eax +10244 # . epilogue +10245 89/<- %esp 5/r32/ebp +10246 5d/pop-to-ebp +10247 c3/return +10248 +10249 new-var-from-slice: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) +10250 # . prologue +10251 55/push-ebp +10252 89/<- %ebp 4/r32/esp +10253 # . save registers +10254 51/push-ecx +10255 # var tmp/ecx: (handle array byte) +10256 68/push 0/imm32 +10257 68/push 0/imm32 +10258 89/<- %ecx 4/r32/esp +10259 # tmp = slice-to-string(name) +10260 (slice-to-string Heap *(ebp+0xc) %ecx) +10261 # out = new-var(tmp) +10262 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) +10263 $new-var-from-slice:end: +10264 # . reclaim locals +10265 81 0/subop/add %esp 8/imm32 +10266 # . restore registers +10267 59/pop-to-ecx +10268 # . epilogue +10269 89/<- %esp 5/r32/ebp +10270 5d/pop-to-ebp +10271 c3/return +10272 +10273 new-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) +10274 # . prologue +10275 55/push-ebp +10276 89/<- %ebp 4/r32/esp +10277 # . save registers +10278 50/push-eax +10279 51/push-ecx +10280 # +10281 (allocate *(ebp+8) *Stmt-size *(ebp+0x14)) +10282 # var out-addr/eax: (addr stmt) = lookup(*out) +10283 8b/-> *(ebp+0x14) 0/r32/eax +10284 (lookup *eax *(eax+4)) # => eax +10285 # out-addr->tag = stmt +10286 c7 0/subop/copy *eax 2/imm32/tag/var-on-stack # Stmt-tag +10287 # result->var = var +10288 8b/-> *(ebp+0xc) 1/r32/ecx +10289 89/<- *(eax+4) 1/r32/ecx # Vardef-var +10290 8b/-> *(ebp+0x10) 1/r32/ecx +10291 89/<- *(eax+8) 1/r32/ecx # Vardef-var +10292 $new-var-def:end: +10293 # . restore registers +10294 59/pop-to-ecx +10295 58/pop-to-eax +10296 # . epilogue +10297 89/<- %esp 5/r32/ebp +10298 5d/pop-to-ebp +10299 c3/return +10300 +10301 new-reg-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) +10302 # . prologue +10303 55/push-ebp +10304 89/<- %ebp 4/r32/esp +10305 # . save registers +10306 50/push-eax +10307 # eax = out +10308 8b/-> *(ebp+0x14) 0/r32/eax +10309 # +10310 (allocate *(ebp+8) *Stmt-size %eax) +10311 # var out-addr/eax: (addr stmt) = lookup(*out) +10312 (lookup *eax *(eax+4)) # => eax +10313 # set tag +10314 c7 0/subop/copy *eax 3/imm32/tag/var-in-register # Stmt-tag +10315 # set output +10316 8d/copy-address *(eax+0x14) 0/r32/eax # Regvardef-outputs +10317 (append-stmt-var Heap *(ebp+0xc) *(ebp+0x10) 0 0 0 %eax) +10318 $new-reg-var-def:end: +10319 # . restore registers +10320 58/pop-to-eax +10321 # . epilogue +10322 89/<- %esp 5/r32/ebp +10323 5d/pop-to-ebp +10324 c3/return +10325 +10326 append-list: # ad: (addr allocation-descriptor), value: (handle _type), list: (handle list _type), out: (addr handle list _type) +10327 # . prologue +10328 55/push-ebp +10329 89/<- %ebp 4/r32/esp +10330 # . save registers +10331 50/push-eax +10332 51/push-ecx +10333 57/push-edi +10334 # edi = out +10335 8b/-> *(ebp+0x1c) 7/r32/edi +10336 # *out = new list +10337 (allocate *(ebp+8) *List-size %edi) +10338 # var out-addr/edi: (addr list _type) = lookup(*out) +10339 (lookup *edi *(edi+4)) # => eax +10340 89/<- %edi 0/r32/eax +10341 # out-addr->value = value +10342 8b/-> *(ebp+0xc) 0/r32/eax +10343 89/<- *edi 0/r32/eax # List-value +10344 8b/-> *(ebp+0x10) 0/r32/eax +10345 89/<- *(edi+4) 0/r32/eax # List-value +10346 # if (list == null) return +10347 81 7/subop/compare *(ebp+0x14) 0/imm32 +10348 74/jump-if-= $append-list:end/disp8 +10349 # otherwise append +10350 $append-list:non-empty-list: +10351 # var curr/eax: (addr list _type) = lookup(list) +10352 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax +10353 # while (curr->next != null) curr = curr->next +10354 { +10355 81 7/subop/compare *(eax+8) 0/imm32 # List-next +10356 74/jump-if-= break/disp8 +10357 # curr = lookup(curr->next) +10358 (lookup *(eax+8) *(eax+0xc)) # List-next, List-next => eax +10359 # +10360 eb/jump loop/disp8 +10361 } +10362 # edi = out +10363 8b/-> *(ebp+0x1c) 7/r32/edi +10364 # curr->next = out +10365 8b/-> *edi 1/r32/ecx +10366 89/<- *(eax+8) 1/r32/ecx # List-next +10367 8b/-> *(edi+4) 1/r32/ecx +10368 89/<- *(eax+0xc) 1/r32/ecx # List-next +10369 # out = list +10370 8b/-> *(ebp+0x14) 1/r32/ecx +10371 89/<- *edi 1/r32/ecx +10372 8b/-> *(ebp+0x18) 1/r32/ecx +10373 89/<- *(edi+4) 1/r32/ecx +10374 $append-list:end: +10375 # . restore registers +10376 5f/pop-to-edi +10377 59/pop-to-ecx +10378 58/pop-to-eax +10379 # . epilogue +10380 89/<- %esp 5/r32/ebp +10381 5d/pop-to-ebp +10382 c3/return +10383 +10384 append-stmt-var: # ad: (addr allocation-descriptor), v: (handle var), vars: (handle stmt-var), is-deref?: boolean, out: (addr handle stmt-var) +10385 # . prologue +10386 55/push-ebp +10387 89/<- %ebp 4/r32/esp +10388 # . save registers +10389 50/push-eax +10390 51/push-ecx +10391 57/push-edi +10392 # edi = out +10393 8b/-> *(ebp+0x20) 7/r32/edi +10394 # out = new stmt-var +10395 (allocate *(ebp+8) *Stmt-var-size %edi) +10396 # var out-addr/ecx: (addr stmt-var) = lookup(*out) +10397 (lookup *edi *(edi+4)) # => eax +10398 89/<- %ecx 0/r32/eax +10399 # out-addr->value = v +10400 8b/-> *(ebp+0xc) 0/r32/eax +10401 89/<- *ecx 0/r32/eax # Stmt-var-value +10402 8b/-> *(ebp+0x10) 0/r32/eax +10403 89/<- *(ecx+4) 0/r32/eax # Stmt-var-value +10404 # out-addr->is-deref? = is-deref? +10405 8b/-> *(ebp+0x1c) 0/r32/eax +10406 89/<- *(ecx+0x10) 0/r32/eax # Stmt-var-is-deref +10407 # if (vars == null) return result +10408 81 7/subop/compare *(ebp+0x14) 0/imm32/null +10409 74/jump-if-= $append-stmt-var:end/disp8 +10410 # otherwise append +10411 # var curr/eax: (addr stmt-var) = lookup(vars) +10412 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax +10413 # while (curr->next != null) curr = curr->next +10414 { +10415 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next +10416 74/jump-if-= break/disp8 +10417 # curr = lookup(curr->next) +10418 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next, Stmt-var-next => eax +10419 # +10420 eb/jump loop/disp8 +10421 } +10422 # curr->next = out +10423 8b/-> *edi 1/r32/ecx +10424 89/<- *(eax+8) 1/r32/ecx # Stmt-var-next +10425 8b/-> *(edi+4) 1/r32/ecx +10426 89/<- *(eax+0xc) 1/r32/ecx # Stmt-var-next +10427 # out = vars +10428 8b/-> *(ebp+0x14) 1/r32/ecx +10429 89/<- *edi 1/r32/ecx +10430 8b/-> *(ebp+0x18) 1/r32/ecx +10431 89/<- *(edi+4) 1/r32/ecx +10432 $append-stmt-var:end: +10433 # . restore registers +10434 5f/pop-to-edi +10435 59/pop-to-ecx +10436 58/pop-to-eax +10437 # . epilogue +10438 89/<- %esp 5/r32/ebp +10439 5d/pop-to-ebp +10440 c3/return +10441 +10442 append-to-block: # ad: (addr allocation-descriptor), block: (addr block), x: (handle stmt) +10443 # . prologue +10444 55/push-ebp +10445 89/<- %ebp 4/r32/esp +10446 # . save registers +10447 50/push-eax +10448 56/push-esi +10449 # esi = block +10450 8b/-> *(ebp+0xc) 6/r32/esi +10451 # block->stmts = append(x, block->stmts) +10452 8d/copy-address *(esi+4) 0/r32/eax # Block-stmts +10453 (append-list *(ebp+8) *(ebp+0x10) *(ebp+0x14) *(esi+4) *(esi+8) %eax) # ad, x, x, Block-stmts, Block-stmts +10454 $append-to-block:end: +10455 # . restore registers +10456 5e/pop-to-esi +10457 58/pop-to-eax +10458 # . epilogue +10459 89/<- %esp 5/r32/ebp +10460 5d/pop-to-ebp +10461 c3/return +10462 +10463 ## Parsing types +10464 # We need to create metadata on user-defined types, and we need to use this +10465 # metadata as we parse instructions. +10466 # However, we also want to allow types to be used before their definitions. +10467 # This means we can't ever assume any type data structures exist. +10468 +10469 lookup-or-create-constant: # container: (addr stmt-var), field-name: (addr slice), out: (addr handle var) +10470 # . prologue +10471 55/push-ebp +10472 89/<- %ebp 4/r32/esp +10473 # . save registers +10474 50/push-eax +10475 56/push-esi +10476 # var container-type/esi: type-id +10477 (container-type *(ebp+8)) # => eax +10478 89/<- %esi 0/r32/eax +10479 # var tmp/eax: (handle typeinfo) = find-or-create-typeinfo(container-type) +10480 68/push 0/imm32 +10481 68/push 0/imm32 +10482 89/<- %eax 4/r32/esp +10483 (find-or-create-typeinfo %esi %eax) +10484 # var tmp-addr/eax: (addr typeinfo) = lookup(tmp) +10485 (lookup *eax *(eax+4)) # => eax +10486 # result = find-or-create-typeinfo-output-var(typeinfo, field-name) +10487 #? (write-buffered Stderr "constant: ") +10488 #? (write-slice-buffered Stderr *(ebp+0xc)) +10489 #? (write-buffered Stderr Newline) +10490 #? (flush Stderr) +10491 (find-or-create-typeinfo-output-var %eax *(ebp+0xc) *(ebp+0x10)) +10492 #? 8b/-> *(ebp+0x10) 0/r32/eax +10493 #? (write-buffered Stderr "@") +10494 #? (lookup *eax *(eax+4)) +10495 #? (write-int32-hex-buffered Stderr %eax) +10496 #? (lookup *eax *(eax+4)) +10497 #? (write-buffered Stderr %eax) +10498 #? (write-buffered Stderr Newline) +10499 #? (flush Stderr) +10500 #? (write-buffered Stderr "offset: ") +10501 #? 8b/-> *(eax+0x14) 0/r32/eax +10502 #? (write-int32-hex-buffered Stderr %eax) +10503 #? (write-buffered Stderr Newline) +10504 #? (flush Stderr) +10505 $lookup-or-create-constant:end: +10506 # . reclaim locals +10507 81 0/subop/add %esp 8/imm32 +10508 # . restore registers +10509 5e/pop-to-esi +10510 58/pop-to-eax +10511 # . epilogue +10512 89/<- %esp 5/r32/ebp +10513 5d/pop-to-ebp +10514 c3/return +10515 +10516 # if addr var: +10517 # container->var->type->right->left->value +10518 # otherwise +10519 # container->var->type->value +10520 container-type: # container: (addr stmt-var) -> result/eax: type-id +10521 # . prologue +10522 55/push-ebp +10523 89/<- %ebp 4/r32/esp +10524 # +10525 8b/-> *(ebp+8) 0/r32/eax +10526 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +10527 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +10528 { +10529 81 7/subop/compare *(eax+8) 0/imm32 # Type-tree-right +10530 74/jump-if-= break/disp8 +10531 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +10532 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +10533 } +10534 8b/-> *(eax+4) 0/r32/eax # Type-tree-value +10535 $container-type:end: +10536 # . epilogue +10537 89/<- %esp 5/r32/ebp +10538 5d/pop-to-ebp +10539 c3/return +10540 +10541 is-container?: # t: type-id -> result/eax: boolean +10542 # . prologue +10543 55/push-ebp +10544 89/<- %ebp 4/r32/esp +10545 # +10546 8b/-> *(ebp+8) 0/r32/eax +10547 c1/shift 4/subop/left %eax 2/imm8 +10548 3b/compare 0/r32/eax *Primitive-type-ids +10549 0f 9d/set-if->= %al +10550 81 4/subop/and %eax 0xff/imm32 +10551 $is-container?:end: +10552 # . epilogue +10553 89/<- %esp 5/r32/ebp +10554 5d/pop-to-ebp +10555 c3/return +10556 +10557 find-or-create-typeinfo: # t: type-id, out: (addr handle typeinfo) +10558 # . prologue +10559 55/push-ebp +10560 89/<- %ebp 4/r32/esp +10561 # . save registers +10562 50/push-eax +10563 51/push-ecx +10564 52/push-edx +10565 57/push-edi +10566 # edi = out +10567 8b/-> *(ebp+0xc) 7/r32/edi +10568 # var fields/ecx: (handle table (handle array byte) (handle typeinfo-entry)) +10569 68/push 0/imm32 +10570 68/push 0/imm32 +10571 89/<- %ecx 4/r32/esp +10572 # find-typeinfo(t, out) +10573 (find-typeinfo *(ebp+8) %edi) +10574 { +10575 # if (*out != 0) break +10576 81 7/subop/compare *edi 0/imm32 +10577 0f 85/jump-if-!= break/disp32 +10578 $find-or-create-typeinfo:create: +10579 # *out = allocate +10580 (allocate Heap *Typeinfo-size %edi) +10581 # var tmp/eax: (addr typeinfo) = lookup(*out) +10582 (lookup *edi *(edi+4)) # => eax +10583 #? (write-buffered Stderr "created typeinfo at ") +10584 #? (write-int32-hex-buffered Stderr %eax) +10585 #? (write-buffered Stderr " for type-id ") +10586 #? (write-int32-hex-buffered Stderr *(ebp+8)) +10587 #? (write-buffered Stderr Newline) +10588 #? (flush Stderr) +10589 # tmp->id = t +10590 8b/-> *(ebp+8) 2/r32/edx +10591 89/<- *eax 2/r32/edx # Typeinfo-id +10592 # tmp->fields = new table +10593 # . fields = new table +10594 (new-stream Heap 0x40 *Typeinfo-fields-row-size %ecx) +10595 # . tmp->fields = fields +10596 8b/-> *ecx 2/r32/edx +10597 89/<- *(eax+4) 2/r32/edx # Typeinfo-fields +10598 8b/-> *(ecx+4) 2/r32/edx +10599 89/<- *(eax+8) 2/r32/edx # Typeinfo-fields +10600 # tmp->next = Program->types +10601 8b/-> *_Program-types 1/r32/ecx +10602 89/<- *(eax+0x10) 1/r32/ecx # Typeinfo-next +10603 8b/-> *_Program-types->payload 1/r32/ecx +10604 89/<- *(eax+0x14) 1/r32/ecx # Typeinfo-next +10605 # Program->types = out +10606 8b/-> *edi 1/r32/ecx +10607 89/<- *_Program-types 1/r32/ecx +10608 8b/-> *(edi+4) 1/r32/ecx +10609 89/<- *_Program-types->payload 1/r32/ecx +10610 } +10611 $find-or-create-typeinfo:end: +10612 # . reclaim locals +10613 81 0/subop/add %esp 8/imm32 +10614 # . restore registers +10615 5f/pop-to-edi +10616 5a/pop-to-edx +10617 59/pop-to-ecx +10618 58/pop-to-eax +10619 # . epilogue +10620 89/<- %esp 5/r32/ebp +10621 5d/pop-to-ebp +10622 c3/return +10623 +10624 find-typeinfo: # t: type-id, out: (addr handle typeinfo) +10625 # . prologue +10626 55/push-ebp +10627 89/<- %ebp 4/r32/esp +10628 # . save registers +10629 50/push-eax +10630 51/push-ecx +10631 52/push-edx +10632 57/push-edi +10633 # ecx = t +10634 8b/-> *(ebp+8) 1/r32/ecx +10635 # edi = out +10636 8b/-> *(ebp+0xc) 7/r32/edi +10637 # *out = Program->types +10638 8b/-> *_Program-types 0/r32/eax +10639 89/<- *edi 0/r32/eax +10640 8b/-> *_Program-types->payload 0/r32/eax +10641 89/<- *(edi+4) 0/r32/eax +10642 { +10643 $find-typeinfo:loop: +10644 # if (*out == 0) break +10645 81 7/subop/compare *edi 0/imm32 +10646 74/jump-if-= break/disp8 +10647 $find-typeinfo:check: +10648 # var tmp/eax: (addr typeinfo) = lookup(*out) +10649 (lookup *edi *(edi+4)) # => eax +10650 # if (tmp->id == t) break +10651 39/compare *eax 1/r32/ecx # Typeinfo-id +10652 74/jump-if-= break/disp8 +10653 $find-typeinfo:continue: +10654 # *out = tmp->next +10655 8b/-> *(eax+0x10) 2/r32/edx # Typeinfo-next +10656 89/<- *edi 2/r32/edx +10657 8b/-> *(eax+0x14) 2/r32/edx # Typeinfo-next +10658 89/<- *(edi+4) 2/r32/edx +10659 # +10660 eb/jump loop/disp8 +10661 } +10662 $find-typeinfo:end: +10663 # . restore registers +10664 5f/pop-to-edi +10665 5a/pop-to-edx +10666 59/pop-to-ecx +10667 58/pop-to-eax +10668 # . epilogue +10669 89/<- %esp 5/r32/ebp +10670 5d/pop-to-ebp +10671 c3/return +10672 +10673 find-or-create-typeinfo-output-var: # T: (addr typeinfo), f: (addr slice), out: (addr handle var) +10674 # . prologue +10675 55/push-ebp +10676 89/<- %ebp 4/r32/esp +10677 # . save registers +10678 50/push-eax +10679 52/push-edx +10680 57/push-edi +10681 # var dest/edi: (handle typeinfo-entry) +10682 68/push 0/imm32 +10683 68/push 0/imm32 +10684 89/<- %edi 4/r32/esp +10685 # find-or-create-typeinfo-fields(T, f, dest) +10686 (find-or-create-typeinfo-fields *(ebp+8) *(ebp+0xc) %edi) +10687 # var dest-addr/edi: (addr typeinfo-entry) = lookup(dest) +10688 (lookup *edi *(edi+4)) # => eax +10689 89/<- %edi 0/r32/eax +10690 # if dest-addr->output-var doesn't exist, create it +10691 { +10692 81 7/subop/compare *(edi+0xc) 0/imm32 # Typeinfo-entry-output-var +10693 0f 85/jump-if-!= break/disp32 +10694 # dest-addr->output-var = new var(dummy name, type, -1 offset) +10695 # . var name/eax: (handle array byte) = "field" +10696 68/push 0/imm32 +10697 68/push 0/imm32 +10698 89/<- %eax 4/r32/esp +10699 (slice-to-string Heap *(ebp+0xc) %eax) +10700 # . new var +10701 8d/copy-address *(edi+0xc) 2/r32/edx +10702 (new-var Heap *eax *(eax+4) %edx) +10703 # . reclaim name +10704 81 0/subop/add %esp 8/imm32 +10705 # var result/edx: (addr var) = lookup(dest-addr->output-var) +10706 (lookup *(edi+0xc) *(edi+0x10)) # => eax +10707 89/<- %edx 0/r32/eax +10708 # result->type = new constant type +10709 8d/copy-address *(edx+8) 0/r32/eax # Var-type +10710 (allocate Heap *Type-tree-size %eax) +10711 (lookup *(edx+8) *(edx+0xc)) # => eax +10712 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +10713 c7 0/subop/copy *(eax+4) 6/imm32/constant # Type-tree-value +10714 c7 0/subop/copy *(eax+8) 0/imm32 # Type-tree-left +10715 c7 0/subop/copy *(eax+0xc) 0/imm32 # Type-tree-right +10716 c7 0/subop/copy *(eax+0x10) 0/imm32 # Type-tree-right +10717 # result->offset isn't filled out yet +10718 c7 0/subop/copy *(edx+0x14) -1/imm32/uninitialized # Var-offset +10719 } +10720 # out = dest-addr->output-var +10721 8b/-> *(ebp+0x10) 2/r32/edx +10722 8b/-> *(edi+0xc) 0/r32/eax # Typeinfo-entry-output-var +10723 89/<- *edx 0/r32/eax +10724 8b/-> *(edi+0x10) 0/r32/eax # Typeinfo-entry-output-var +10725 89/<- *(edx+4) 0/r32/eax +10726 $find-or-create-typeinfo-output-var:end: +10727 # . reclaim locals +10728 81 0/subop/add %esp 8/imm32 +10729 # . restore registers +10730 5f/pop-to-edi +10731 5a/pop-to-edx +10732 58/pop-to-eax +10733 # . epilogue +10734 89/<- %esp 5/r32/ebp +10735 5d/pop-to-ebp +10736 c3/return +10737 +10738 find-or-create-typeinfo-fields: # T: (addr typeinfo), f: (addr slice), out: (addr handle typeinfo-entry) +10739 # . prologue +10740 55/push-ebp +10741 89/<- %ebp 4/r32/esp +10742 # . save registers +10743 50/push-eax +10744 56/push-esi +10745 57/push-edi +10746 # eax = lookup(T->fields) +10747 8b/-> *(ebp+8) 0/r32/eax +10748 (lookup *(eax+4) *(eax+8)) # Typeinfo-fields Typeinfo-fields => eax +10749 # edi = out +10750 8b/-> *(ebp+0x10) 7/r32/edi +10751 # var src/esi: (addr handle typeinfo-entry) = get-or-insert-slice(T->fields, f) +10752 (get-or-insert-slice %eax *(ebp+0xc) *Typeinfo-fields-row-size Heap) # => eax +10753 89/<- %esi 0/r32/eax +10754 # if src doesn't exist, allocate it 10755 { -10756 $populate-mu-type:line-loop: -10757 (clear-stream %ecx) -10758 (read-line-buffered *(ebp+8) %ecx) -10759 # if (line->write == 0) abort -10760 81 7/subop/compare *ecx 0/imm32 -10761 0f 84/jump-if-= $populate-mu-type:error1/disp32 -10762 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ -10768 (next-mu-token %ecx %edx) -10769 # if slice-empty?(word-slice) continue -10770 (slice-empty? %edx) # => eax -10771 3d/compare-eax-and 0/imm32 -10772 0f 85/jump-if-!= loop/disp32 -10773 # if slice-equal?(word-slice, "}") break -10774 (slice-equal? %edx "}") -10775 3d/compare-eax-and 0/imm32 -10776 0f 85/jump-if-!= break/disp32 -10777 $populate-mu-type:parse-element: -10778 # v = parse-var-with-type(word-slice, first-line) -10779 # must do this first to strip the trailing ':' from word-slice before -10780 # using it in find-or-create-typeinfo-fields below -10781 # TODO: clean up that mutation in parse-var-with-type -10782 (parse-var-with-type %edx %ecx %esi *(ebp+0x10) *(ebp+0x14)) -10783 # if v is an addr, abort -10784 (lookup *esi *(esi+4)) # => eax -10785 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -10786 (is-mu-addr-type? %eax) # => eax -10787 3d/compare-eax-and 0/imm32/false -10788 0f 85/jump-if-!= $populate-mu-type:error2/disp32 -10789 # if v is an array, abort (we could support it, but initialization gets complex) -10790 (lookup *esi *(esi+4)) # => eax -10791 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -10792 (is-mu-array-type? %eax) # => eax -10793 3d/compare-eax-and 0/imm32/false -10794 0f 85/jump-if-!= $populate-mu-type:error3/disp32 -10795 # if v is a slice, abort -10796 (lookup *esi *(esi+4)) # => eax -10797 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -10798 (is-simple-mu-type? %eax 0xc) # slice => eax -10799 3d/compare-eax-and 0/imm32/false -10800 0f 85/jump-if-!= $populate-mu-type:error4/disp32 -10801 # if v is a stream, abort (we could support it, but initialization gets even more complex) -10802 (lookup *esi *(esi+4)) # => eax -10803 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -10804 (is-mu-stream-type? %eax) # => eax -10805 3d/compare-eax-and 0/imm32/false -10806 0f 85/jump-if-!= $populate-mu-type:error5/disp32 -10807 # var tmp/ecx -10808 51/push-ecx -10809 $populate-mu-type:create-typeinfo-fields: -10810 # var r/ebx: (handle typeinfo-entry) -10811 (find-or-create-typeinfo-fields %edi %edx %ebx) -10812 # r->index = curr-index -10813 (lookup *ebx *(ebx+4)) # => eax -10814 8b/-> *(ebp-4) 1/r32/ecx -10815 #? (write-buffered Stderr "saving index ") -10816 #? (write-int32-hex-buffered Stderr %ecx) -10817 #? (write-buffered Stderr " at ") -10818 #? (write-int32-hex-buffered Stderr %edi) -10819 #? (write-buffered Stderr Newline) -10820 #? (flush Stderr) -10821 89/<- *(eax+8) 1/r32/ecx # Typeinfo-entry-index -10822 # ++curr-index -10823 ff 0/subop/increment *(ebp-4) -10824 $populate-mu-type:set-input-type: -10825 # r->input-var = v -10826 8b/-> *esi 1/r32/ecx -10827 89/<- *eax 1/r32/ecx # Typeinfo-entry-input-var -10828 8b/-> *(esi+4) 1/r32/ecx -10829 89/<- *(eax+4) 1/r32/ecx # Typeinfo-entry-input-var -10830 # restore line -10831 59/pop-to-ecx -10832 { -10833 $populate-mu-type:create-output-type: -10834 # if (r->output-var == 0) create a new var with some placeholder data -10835 81 7/subop/compare *(eax+0xc) 0/imm32 # Typeinfo-entry-output-var -10836 75/jump-if-!= break/disp8 -10837 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var -10838 (new-literal Heap %edx %eax) -10839 } -10840 e9/jump loop/disp32 -10841 } -10842 $populate-mu-type:invalidate-total-size-in-bytes: -10843 # Offsets and total size may not be accurate here since we may not yet -10844 # have encountered the element types. -10845 # We'll recompute them separately after parsing the entire program. -10846 c7 0/subop/copy *(edi+0xc) -2/imm32/uninitialized # Typeinfo-total-size-in-bytes -10847 $populate-mu-type:end: -10848 # . reclaim locals -10849 81 0/subop/add %esp 0x224/imm32 -10850 # . restore registers -10851 5f/pop-to-edi -10852 5e/pop-to-esi -10853 5b/pop-to-ebx -10854 5a/pop-to-edx -10855 59/pop-to-ecx -10856 58/pop-to-eax -10857 # reclaim curr-index -10858 81 0/subop/add %esp 4/imm32 -10859 # . epilogue -10860 89/<- %esp 5/r32/ebp -10861 5d/pop-to-ebp -10862 c3/return -10863 -10864 $populate-mu-type:error1: -10865 # error("incomplete type definition '" t->name "'\n") -10866 (write-buffered *(ebp+0x10) "incomplete type definition '") -10867 (type-name *edi) # Typeinfo-id => eax -10868 (write-buffered *(ebp+0x10) %eax) -10869 (write-buffered *(ebp+0x10) "\n") -10870 (flush *(ebp+0x10)) -10871 (stop *(ebp+0x14) 1) -10872 # never gets here -10873 -10874 $populate-mu-type:error2: -10875 (write-buffered *(ebp+0x10) "type ") -10876 (type-name *edi) # Typeinfo-id => eax -10877 (write-buffered *(ebp+0x10) %eax) -10878 (write-buffered *(ebp+0x10) ": 'addr' elements not allowed\n") -10879 (flush *(ebp+0x10)) -10880 (stop *(ebp+0x14) 1) -10881 # never gets here -10882 -10883 $populate-mu-type:error3: -10884 (write-buffered *(ebp+0x10) "type ") -10885 (type-name *edi) # Typeinfo-id => eax -10886 (write-buffered *(ebp+0x10) %eax) -10887 (write-buffered *(ebp+0x10) ": 'array' elements not allowed for now\n") -10888 (flush *(ebp+0x10)) -10889 (stop *(ebp+0x14) 1) -10890 # never gets here -10891 -10892 $populate-mu-type:error4: -10893 (write-buffered *(ebp+0x10) "type ") -10894 (type-name *edi) # Typeinfo-id => eax -10895 (write-buffered *(ebp+0x10) %eax) -10896 (write-buffered *(ebp+0x10) ": 'slice' elements not allowed\n") -10897 (flush *(ebp+0x10)) -10898 (stop *(ebp+0x14) 1) -10899 # never gets here -10900 -10901 $populate-mu-type:error5: -10902 (write-buffered *(ebp+0x10) "type ") -10903 (type-name *edi) # Typeinfo-id => eax -10904 (write-buffered *(ebp+0x10) %eax) -10905 (write-buffered *(ebp+0x10) ": 'stream' elements not allowed for now\n") -10906 (flush *(ebp+0x10)) -10907 (stop *(ebp+0x14) 1) -10908 # never gets here -10909 -10910 type-name: # index: int -> result/eax: (addr array byte) -10911 # . prologue -10912 55/push-ebp -10913 89/<- %ebp 4/r32/esp -10914 # -10915 (index Type-id *(ebp+8)) -10916 $type-name:end: -10917 # . epilogue -10918 89/<- %esp 5/r32/ebp -10919 5d/pop-to-ebp -10920 c3/return -10921 -10922 index: # arr: (addr stream (handle array byte)), index: int -> result/eax: (addr array byte) -10923 # . prologue -10924 55/push-ebp -10925 89/<- %ebp 4/r32/esp -10926 # . save registers -10927 56/push-esi -10928 # TODO: bounds-check index -10929 # esi = arr -10930 8b/-> *(ebp+8) 6/r32/esi -10931 # eax = index -10932 8b/-> *(ebp+0xc) 0/r32/eax -10933 # eax = *(arr + 12 + index) -10934 8b/-> *(esi+eax<<2+0xc) 0/r32/eax -10935 $index:end: -10936 # . restore registers -10937 5e/pop-to-esi -10938 # . epilogue -10939 89/<- %esp 5/r32/ebp -10940 5d/pop-to-ebp -10941 c3/return -10942 -10943 ####################################################### -10944 # Compute type sizes -10945 ####################################################### -10946 -10947 # Compute the sizes of all user-defined types. -10948 # We'll need the sizes of their elements, which may be other user-defined -10949 # types, which we will compute as needed. -10950 -10951 # Initially, all user-defined types have their sizes set to -2 (invalid) -10952 populate-mu-type-sizes: # err: (addr buffered-file), ed: (addr exit-descriptor) -10953 # . prologue -10954 55/push-ebp -10955 89/<- %ebp 4/r32/esp -10956 $populate-mu-type-sizes:total-sizes: -10957 # var curr/eax: (addr typeinfo) = lookup(Program->types) -10958 (lookup *_Program-types *_Program-types->payload) # => eax -10959 { -10960 # if (curr == null) break -10961 3d/compare-eax-and 0/imm32/null -10962 74/jump-if-= break/disp8 -10963 (populate-mu-type-sizes-in-type %eax *(ebp+8) *(ebp+0xc)) -10964 # curr = lookup(curr->next) -10965 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -10966 eb/jump loop/disp8 -10967 } -10968 $populate-mu-type-sizes:offsets: -10969 # curr = *Program->types -10970 (lookup *_Program-types *_Program-types->payload) # => eax -10971 { -10972 # if (curr == null) break -10973 3d/compare-eax-and 0/imm32/null -10974 74/jump-if-= break/disp8 -10975 (populate-mu-type-offsets %eax *(ebp+8) *(ebp+0xc)) -10976 # curr = curr->next -10977 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -10978 eb/jump loop/disp8 -10979 } -10980 $populate-mu-type-sizes:end: -10981 # . epilogue -10982 89/<- %esp 5/r32/ebp -10983 5d/pop-to-ebp -10984 c3/return -10985 -10986 # compute sizes of all fields, recursing as necessary -10987 # sum up all their sizes to arrive at total size -10988 # fields may be out of order, but that doesn't affect the answer -10989 populate-mu-type-sizes-in-type: # T: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -10990 # . prologue -10991 55/push-ebp -10992 89/<- %ebp 4/r32/esp -10993 # . save registers -10994 50/push-eax -10995 51/push-ecx -10996 52/push-edx -10997 56/push-esi -10998 57/push-edi -10999 # esi = T -11000 8b/-> *(ebp+8) 6/r32/esi -11001 # if T is already computed, return -11002 81 7/subop/compare *(esi+0xc) 0/imm32 # Typeinfo-total-size-in-bytes -11003 0f 8d/jump-if->= $populate-mu-type-sizes-in-type:end/disp32 -11004 # if T is being computed, abort -11005 81 7/subop/compare *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes -11006 0f 84/jump-if-= $populate-mu-type-sizes-in-type:abort/disp32 -11007 # tag T (-2 to -1) to avoid infinite recursion -11008 c7 0/subop/copy *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes -11009 # var total-size/edi: int = 0 -11010 bf/copy-to-edi 0/imm32 -11011 # - for every field, if it's a user-defined type, compute its size -11012 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) -11013 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax -11014 89/<- %ecx 0/r32/eax -11015 # var table-size/edx: int = table->write -11016 8b/-> *ecx 2/r32/edx # stream-write -11017 # var curr/ecx: (addr table_row) = table->data -11018 8d/copy-address *(ecx+0xc) 1/r32/ecx -11019 # var max/edx: (addr table_row) = table->data + table->write -11020 8d/copy-address *(ecx+edx) 2/r32/edx -11021 { -11022 $populate-mu-type-sizes-in-type:loop: -11023 # if (curr >= max) break -11024 39/compare %ecx 2/r32/edx -11025 73/jump-if-addr>= break/disp8 -11026 # var t/eax: (addr typeinfo-entry) = lookup(curr->value) -11027 (lookup *(ecx+8) *(ecx+0xc)) # => eax -11028 # if (t->input-var == 0) silently ignore it; we'll emit a nice error message while type-checking -11029 81 7/subop/compare *eax 0/imm32 # Typeinfo-entry-input-var -11030 74/jump-if-= $populate-mu-type-sizes-in-type:end/disp8 -11031 # compute size of t->input-var -11032 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -11033 (compute-size-of-var %eax) # => eax -11034 # result += eax -11035 01/add-to %edi 0/r32/eax -11036 # curr += row-size -11037 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size -11038 # -11039 eb/jump loop/disp8 -11040 } -11041 # - save result -11042 89/<- *(esi+0xc) 7/r32/edi # Typeinfo-total-size-in-bytes -11043 $populate-mu-type-sizes-in-type:end: -11044 # . restore registers -11045 5f/pop-to-edi -11046 5e/pop-to-esi -11047 5a/pop-to-edx -11048 59/pop-to-ecx -11049 58/pop-to-eax -11050 # . epilogue -11051 89/<- %esp 5/r32/ebp -11052 5d/pop-to-ebp -11053 c3/return -11054 -11055 $populate-mu-type-sizes-in-type:abort: -11056 (write-buffered *(ebp+0xc) "cycle in type definitions\n") -11057 (flush *(ebp+0xc)) -11058 (stop *(ebp+0x10) 1) -11059 # never gets here -11060 -11061 # Analogous to size-of, except we need to compute what size-of can just read -11062 # off the right data structures. -11063 compute-size-of-var: # in: (addr var) -> result/eax: int -11064 # . prologue -11065 55/push-ebp -11066 89/<- %ebp 4/r32/esp -11067 # . push registers -11068 51/push-ecx -11069 # var t/ecx: (addr type-tree) = lookup(v->type) -11070 8b/-> *(ebp+8) 1/r32/ecx -11071 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -11072 89/<- %ecx 0/r32/eax -11073 # if (t->is-atom == false) t = lookup(t->left) -11074 { -11075 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -11076 75/jump-if-!= break/disp8 -11077 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -11078 89/<- %ecx 0/r32/eax -11079 } -11080 # TODO: ensure t is an atom -11081 (compute-size-of-type-id *(ecx+4)) # Type-tree-value => eax -11082 $compute-size-of-var:end: -11083 # . restore registers -11084 59/pop-to-ecx -11085 # . epilogue -11086 89/<- %esp 5/r32/ebp -11087 5d/pop-to-ebp -11088 c3/return -11089 -11090 compute-size-of-type-id: # t: type-id -> result/eax: int -11091 # . prologue -11092 55/push-ebp -11093 89/<- %ebp 4/r32/esp -11094 # . save registers -11095 51/push-ecx -11096 # var out/ecx: (handle typeinfo) -11097 68/push 0/imm32 -11098 68/push 0/imm32 -11099 89/<- %ecx 4/r32/esp -11100 # eax = t -11101 8b/-> *(ebp+8) 0/r32/eax -11102 # if t is a literal, return 0 -11103 3d/compare-eax-and 0/imm32/literal -11104 0f 84/jump-if-= $compute-size-of-type-id:end/disp32 # eax changes type from type-id to int -11105 # if t is a byte, return 4 (because we don't really support non-multiples of 4) -11106 3d/compare-eax-and 8/imm32/byte -11107 { -11108 75/jump-if-!= break/disp8 -11109 b8/copy-to-eax 4/imm32 -11110 eb/jump $compute-size-of-type-id:end/disp8 -11111 } -11112 # if t is a handle, return 8 -11113 3d/compare-eax-and 4/imm32/handle +10756 81 7/subop/compare *esi 0/imm32 +10757 75/jump-if-!= break/disp8 +10758 (allocate Heap *Typeinfo-entry-size %esi) +10759 #? (write-buffered Stderr "handle at ") +10760 #? (write-int32-hex-buffered Stderr %esi) +10761 #? (write-buffered Stderr ": ") +10762 #? (write-int32-hex-buffered Stderr *esi) +10763 #? (write-buffered Stderr " ") +10764 #? (write-int32-hex-buffered Stderr *(esi+4)) +10765 #? (write-buffered Stderr Newline) +10766 #? (flush Stderr) +10767 #? (lookup *esi *(esi+4)) +10768 #? (write-buffered Stderr "created typeinfo fields at ") +10769 #? (write-int32-hex-buffered Stderr %esi) +10770 #? (write-buffered Stderr " for ") +10771 #? (write-int32-hex-buffered Stderr *(ebp+8)) +10772 #? (write-buffered Stderr Newline) +10773 #? (flush Stderr) +10774 } +10775 # *out = src +10776 # . *edi = *src +10777 8b/-> *esi 0/r32/eax +10778 89/<- *edi 0/r32/eax +10779 8b/-> *(esi+4) 0/r32/eax +10780 89/<- *(edi+4) 0/r32/eax +10781 $find-or-create-typeinfo-fields:end: +10782 # . restore registers +10783 5f/pop-to-edi +10784 5e/pop-to-esi +10785 58/pop-to-eax +10786 # . epilogue +10787 89/<- %esp 5/r32/ebp +10788 5d/pop-to-ebp +10789 c3/return +10790 +10791 populate-mu-type: # in: (addr stream byte), t: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +10792 # pseudocode: +10793 # var line: (stream byte 512) +10794 # curr-index = 0 +10795 # while true +10796 # clear-stream(line) +10797 # read-line-buffered(in, line) +10798 # if line->write == 0 +10799 # abort +10800 # word-slice = next-mu-token(line) +10801 # if slice-empty?(word-slice) # end of line +10802 # continue +10803 # if slice-equal?(word-slice, "}") +10804 # break +10805 # var v: (handle var) = parse-var-with-type(word-slice, line) +10806 # var r: (handle typeinfo-fields) = find-or-create-typeinfo-fields(t, word-slice/v->name) +10807 # TODO: ensure that r->first is null +10808 # r->index = curr-index +10809 # curr-index++ +10810 # r->input-var = v +10811 # if r->output-var == 0 +10812 # r->output-var = new literal +10813 # TODO: ensure nothing else in line +10814 # t->total-size-in-bytes = -2 (not yet initialized) +10815 # +10816 # . prologue +10817 55/push-ebp +10818 89/<- %ebp 4/r32/esp +10819 # var curr-index: int at *(ebp-4) +10820 68/push 0/imm32 +10821 # . save registers +10822 50/push-eax +10823 51/push-ecx +10824 52/push-edx +10825 53/push-ebx +10826 56/push-esi +10827 57/push-edi +10828 # edi = t +10829 8b/-> *(ebp+0xc) 7/r32/edi +10830 # var line/ecx: (stream byte 512) +10831 81 5/subop/subtract %esp 0x200/imm32 +10832 68/push 0x200/imm32/size +10833 68/push 0/imm32/read +10834 68/push 0/imm32/write +10835 89/<- %ecx 4/r32/esp +10836 # var word-slice/edx: slice +10837 68/push 0/imm32/end +10838 68/push 0/imm32/start +10839 89/<- %edx 4/r32/esp +10840 # var v/esi: (handle var) +10841 68/push 0/imm32 +10842 68/push 0/imm32 +10843 89/<- %esi 4/r32/esp +10844 # var r/ebx: (handle typeinfo-entry) +10845 68/push 0/imm32 +10846 68/push 0/imm32 +10847 89/<- %ebx 4/r32/esp +10848 { +10849 $populate-mu-type:line-loop: +10850 (clear-stream %ecx) +10851 (read-line-buffered *(ebp+8) %ecx) +10852 # if (line->write == 0) abort +10853 81 7/subop/compare *ecx 0/imm32 +10854 0f 84/jump-if-= $populate-mu-type:error1/disp32 +10855 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ +10861 (next-mu-token %ecx %edx) +10862 # if slice-empty?(word-slice) continue +10863 (slice-empty? %edx) # => eax +10864 3d/compare-eax-and 0/imm32 +10865 0f 85/jump-if-!= loop/disp32 +10866 # if slice-equal?(word-slice, "}") break +10867 (slice-equal? %edx "}") +10868 3d/compare-eax-and 0/imm32 +10869 0f 85/jump-if-!= break/disp32 +10870 $populate-mu-type:parse-element: +10871 # v = parse-var-with-type(word-slice, first-line) +10872 # must do this first to strip the trailing ':' from word-slice before +10873 # using it in find-or-create-typeinfo-fields below +10874 # TODO: clean up that mutation in parse-var-with-type +10875 (parse-var-with-type %edx %ecx %esi *(ebp+0x10) *(ebp+0x14)) +10876 # if v is an addr, abort +10877 (lookup *esi *(esi+4)) # => eax +10878 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +10879 (is-mu-addr-type? %eax) # => eax +10880 3d/compare-eax-and 0/imm32/false +10881 0f 85/jump-if-!= $populate-mu-type:error2/disp32 +10882 # if v is an array, abort (we could support it, but initialization gets complex) +10883 (lookup *esi *(esi+4)) # => eax +10884 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +10885 (is-mu-array-type? %eax) # => eax +10886 3d/compare-eax-and 0/imm32/false +10887 0f 85/jump-if-!= $populate-mu-type:error3/disp32 +10888 # if v is a slice, abort +10889 (lookup *esi *(esi+4)) # => eax +10890 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +10891 (is-simple-mu-type? %eax 0xc) # slice => eax +10892 3d/compare-eax-and 0/imm32/false +10893 0f 85/jump-if-!= $populate-mu-type:error4/disp32 +10894 # if v is a stream, abort (we could support it, but initialization gets even more complex) +10895 (lookup *esi *(esi+4)) # => eax +10896 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +10897 (is-mu-stream-type? %eax) # => eax +10898 3d/compare-eax-and 0/imm32/false +10899 0f 85/jump-if-!= $populate-mu-type:error5/disp32 +10900 # var tmp/ecx +10901 51/push-ecx +10902 $populate-mu-type:create-typeinfo-fields: +10903 # var r/ebx: (handle typeinfo-entry) +10904 (find-or-create-typeinfo-fields %edi %edx %ebx) +10905 # r->index = curr-index +10906 (lookup *ebx *(ebx+4)) # => eax +10907 8b/-> *(ebp-4) 1/r32/ecx +10908 #? (write-buffered Stderr "saving index ") +10909 #? (write-int32-hex-buffered Stderr %ecx) +10910 #? (write-buffered Stderr " at ") +10911 #? (write-int32-hex-buffered Stderr %edi) +10912 #? (write-buffered Stderr Newline) +10913 #? (flush Stderr) +10914 89/<- *(eax+8) 1/r32/ecx # Typeinfo-entry-index +10915 # ++curr-index +10916 ff 0/subop/increment *(ebp-4) +10917 $populate-mu-type:set-input-type: +10918 # r->input-var = v +10919 8b/-> *esi 1/r32/ecx +10920 89/<- *eax 1/r32/ecx # Typeinfo-entry-input-var +10921 8b/-> *(esi+4) 1/r32/ecx +10922 89/<- *(eax+4) 1/r32/ecx # Typeinfo-entry-input-var +10923 # restore line +10924 59/pop-to-ecx +10925 { +10926 $populate-mu-type:create-output-type: +10927 # if (r->output-var == 0) create a new var with some placeholder data +10928 81 7/subop/compare *(eax+0xc) 0/imm32 # Typeinfo-entry-output-var +10929 75/jump-if-!= break/disp8 +10930 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var +10931 (new-literal Heap %edx %eax) +10932 } +10933 e9/jump loop/disp32 +10934 } +10935 $populate-mu-type:invalidate-total-size-in-bytes: +10936 # Offsets and total size may not be accurate here since we may not yet +10937 # have encountered the element types. +10938 # We'll recompute them separately after parsing the entire program. +10939 c7 0/subop/copy *(edi+0xc) -2/imm32/uninitialized # Typeinfo-total-size-in-bytes +10940 $populate-mu-type:end: +10941 # . reclaim locals +10942 81 0/subop/add %esp 0x224/imm32 +10943 # . restore registers +10944 5f/pop-to-edi +10945 5e/pop-to-esi +10946 5b/pop-to-ebx +10947 5a/pop-to-edx +10948 59/pop-to-ecx +10949 58/pop-to-eax +10950 # reclaim curr-index +10951 81 0/subop/add %esp 4/imm32 +10952 # . epilogue +10953 89/<- %esp 5/r32/ebp +10954 5d/pop-to-ebp +10955 c3/return +10956 +10957 $populate-mu-type:error1: +10958 # error("incomplete type definition '" t->name "'\n") +10959 (write-buffered *(ebp+0x10) "incomplete type definition '") +10960 (type-name *edi) # Typeinfo-id => eax +10961 (write-buffered *(ebp+0x10) %eax) +10962 (write-buffered *(ebp+0x10) "\n") +10963 (flush *(ebp+0x10)) +10964 (stop *(ebp+0x14) 1) +10965 # never gets here +10966 +10967 $populate-mu-type:error2: +10968 (write-buffered *(ebp+0x10) "type ") +10969 (type-name *edi) # Typeinfo-id => eax +10970 (write-buffered *(ebp+0x10) %eax) +10971 (write-buffered *(ebp+0x10) ": 'addr' elements not allowed\n") +10972 (flush *(ebp+0x10)) +10973 (stop *(ebp+0x14) 1) +10974 # never gets here +10975 +10976 $populate-mu-type:error3: +10977 (write-buffered *(ebp+0x10) "type ") +10978 (type-name *edi) # Typeinfo-id => eax +10979 (write-buffered *(ebp+0x10) %eax) +10980 (write-buffered *(ebp+0x10) ": 'array' elements not allowed for now\n") +10981 (flush *(ebp+0x10)) +10982 (stop *(ebp+0x14) 1) +10983 # never gets here +10984 +10985 $populate-mu-type:error4: +10986 (write-buffered *(ebp+0x10) "type ") +10987 (type-name *edi) # Typeinfo-id => eax +10988 (write-buffered *(ebp+0x10) %eax) +10989 (write-buffered *(ebp+0x10) ": 'slice' elements not allowed\n") +10990 (flush *(ebp+0x10)) +10991 (stop *(ebp+0x14) 1) +10992 # never gets here +10993 +10994 $populate-mu-type:error5: +10995 (write-buffered *(ebp+0x10) "type ") +10996 (type-name *edi) # Typeinfo-id => eax +10997 (write-buffered *(ebp+0x10) %eax) +10998 (write-buffered *(ebp+0x10) ": 'stream' elements not allowed for now\n") +10999 (flush *(ebp+0x10)) +11000 (stop *(ebp+0x14) 1) +11001 # never gets here +11002 +11003 type-name: # index: int -> result/eax: (addr array byte) +11004 # . prologue +11005 55/push-ebp +11006 89/<- %ebp 4/r32/esp +11007 # +11008 (index Type-id *(ebp+8)) +11009 $type-name:end: +11010 # . epilogue +11011 89/<- %esp 5/r32/ebp +11012 5d/pop-to-ebp +11013 c3/return +11014 +11015 index: # arr: (addr stream (handle array byte)), index: int -> result/eax: (addr array byte) +11016 # . prologue +11017 55/push-ebp +11018 89/<- %ebp 4/r32/esp +11019 # . save registers +11020 56/push-esi +11021 # TODO: bounds-check index +11022 # esi = arr +11023 8b/-> *(ebp+8) 6/r32/esi +11024 # eax = index +11025 8b/-> *(ebp+0xc) 0/r32/eax +11026 # eax = *(arr + 12 + index) +11027 8b/-> *(esi+eax<<2+0xc) 0/r32/eax +11028 $index:end: +11029 # . restore registers +11030 5e/pop-to-esi +11031 # . epilogue +11032 89/<- %esp 5/r32/ebp +11033 5d/pop-to-ebp +11034 c3/return +11035 +11036 ####################################################### +11037 # Compute type sizes +11038 ####################################################### +11039 +11040 # Compute the sizes of all user-defined types. +11041 # We'll need the sizes of their elements, which may be other user-defined +11042 # types, which we will compute as needed. +11043 +11044 # Initially, all user-defined types have their sizes set to -2 (invalid) +11045 populate-mu-type-sizes: # err: (addr buffered-file), ed: (addr exit-descriptor) +11046 # . prologue +11047 55/push-ebp +11048 89/<- %ebp 4/r32/esp +11049 $populate-mu-type-sizes:total-sizes: +11050 # var curr/eax: (addr typeinfo) = lookup(Program->types) +11051 (lookup *_Program-types *_Program-types->payload) # => eax +11052 { +11053 # if (curr == null) break +11054 3d/compare-eax-and 0/imm32/null +11055 74/jump-if-= break/disp8 +11056 (populate-mu-type-sizes-in-type %eax *(ebp+8) *(ebp+0xc)) +11057 # curr = lookup(curr->next) +11058 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +11059 eb/jump loop/disp8 +11060 } +11061 $populate-mu-type-sizes:offsets: +11062 # curr = *Program->types +11063 (lookup *_Program-types *_Program-types->payload) # => eax +11064 { +11065 # if (curr == null) break +11066 3d/compare-eax-and 0/imm32/null +11067 74/jump-if-= break/disp8 +11068 (populate-mu-type-offsets %eax *(ebp+8) *(ebp+0xc)) +11069 # curr = curr->next +11070 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +11071 eb/jump loop/disp8 +11072 } +11073 $populate-mu-type-sizes:end: +11074 # . epilogue +11075 89/<- %esp 5/r32/ebp +11076 5d/pop-to-ebp +11077 c3/return +11078 +11079 # compute sizes of all fields, recursing as necessary +11080 # sum up all their sizes to arrive at total size +11081 # fields may be out of order, but that doesn't affect the answer +11082 populate-mu-type-sizes-in-type: # T: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +11083 # . prologue +11084 55/push-ebp +11085 89/<- %ebp 4/r32/esp +11086 # . save registers +11087 50/push-eax +11088 51/push-ecx +11089 52/push-edx +11090 56/push-esi +11091 57/push-edi +11092 # esi = T +11093 8b/-> *(ebp+8) 6/r32/esi +11094 # if T is already computed, return +11095 81 7/subop/compare *(esi+0xc) 0/imm32 # Typeinfo-total-size-in-bytes +11096 0f 8d/jump-if->= $populate-mu-type-sizes-in-type:end/disp32 +11097 # if T is being computed, abort +11098 81 7/subop/compare *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes +11099 0f 84/jump-if-= $populate-mu-type-sizes-in-type:abort/disp32 +11100 # tag T (-2 to -1) to avoid infinite recursion +11101 c7 0/subop/copy *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes +11102 # var total-size/edi: int = 0 +11103 bf/copy-to-edi 0/imm32 +11104 # - for every field, if it's a user-defined type, compute its size +11105 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) +11106 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax +11107 89/<- %ecx 0/r32/eax +11108 # var table-size/edx: int = table->write +11109 8b/-> *ecx 2/r32/edx # stream-write +11110 # var curr/ecx: (addr table_row) = table->data +11111 8d/copy-address *(ecx+0xc) 1/r32/ecx +11112 # var max/edx: (addr table_row) = table->data + table->write +11113 8d/copy-address *(ecx+edx) 2/r32/edx 11114 { -11115 75/jump-if-!= break/disp8 -11116 b8/copy-to-eax 8/imm32 -11117 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int -11118 } -11119 # if t is a slice, return 8 -11120 3d/compare-eax-and 0xc/imm32/slice -11121 { -11122 75/jump-if-!= break/disp8 -11123 b8/copy-to-eax 8/imm32 -11124 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int -11125 } -11126 # if t is a user-defined type, compute its size -11127 # TODO: support non-atom type -11128 (find-typeinfo %eax %ecx) -11129 { -11130 81 7/subop/compare *ecx 0/imm32 -11131 74/jump-if-= break/disp8 -11132 $compute-size-of-type-id:user-defined: -11133 (populate-mu-type-sizes %eax) -11134 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes -11135 eb/jump $compute-size-of-type-id:end/disp8 -11136 } -11137 # otherwise return the word size -11138 b8/copy-to-eax 4/imm32 -11139 $compute-size-of-type-id:end: -11140 # . reclaim locals -11141 81 0/subop/add %esp 8/imm32 -11142 # . restore registers -11143 59/pop-to-ecx -11144 # . epilogue -11145 89/<- %esp 5/r32/ebp -11146 5d/pop-to-ebp -11147 c3/return -11148 -11149 # at this point we have total sizes for all user-defined types -11150 # compute offsets for each element -11151 # complication: fields may be out of order -11152 populate-mu-type-offsets: # in: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -11153 # . prologue -11154 55/push-ebp -11155 89/<- %ebp 4/r32/esp -11156 # . save registers -11157 50/push-eax -11158 51/push-ecx -11159 52/push-edx -11160 53/push-ebx -11161 56/push-esi -11162 57/push-edi -11163 #? (dump-typeinfos "aaa\n") -11164 # var curr-offset/edi: int = 0 -11165 bf/copy-to-edi 0/imm32 -11166 # var table/ecx: (addr table string_key (handle typeinfo-entry)) = lookup(in->fields) -11167 8b/-> *(ebp+8) 1/r32/ecx -11168 (lookup *(ecx+4) *(ecx+8)) # Typeinfo-fields Typeinfo-fields => eax -11169 89/<- %ecx 0/r32/eax -11170 # var num-elems/edx: int = table->write / Typeinfo-fields-row-size -11171 8b/-> *ecx 2/r32/edx # stream-write -11172 c1 5/subop/shift-right-logical %edx 4/imm8 -11173 # var i/ebx: int = 0 -11174 bb/copy-to-ebx 0/imm32 -11175 { -11176 $populate-mu-type-offsets:loop: -11177 39/compare %ebx 2/r32/edx -11178 0f 8d/jump-if->= break/disp32 -11179 #? (write-buffered Stderr "looking up index ") -11180 #? (write-int32-hex-buffered Stderr %ebx) -11181 #? (write-buffered Stderr " in ") -11182 #? (write-int32-hex-buffered Stderr *(ebp+8)) -11183 #? (write-buffered Stderr Newline) -11184 #? (flush Stderr) -11185 # var v/esi: (addr typeinfo-entry) -11186 (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10)) # => eax -11187 89/<- %esi 0/r32/eax -11188 # if v is null, silently move on; we'll emit a nice error message while type-checking -11189 81 7/subop/compare %esi 0/imm32 # Typeinfo-entry-input-var -11190 74/jump-if-= $populate-mu-type-offsets:end/disp8 -11191 # if (v->input-var == 0) silently ignore v; we'll emit a nice error message while type-checking -11192 81 7/subop/compare *esi 0/imm32 # Typeinfo-entry-input-var -11193 74/jump-if-= $populate-mu-type-offsets:end/disp8 -11194 # v->output-var->offset = curr-offset -11195 # . eax: (addr var) -11196 (lookup *(esi+0xc) *(esi+0x10)) # Typeinfo-entry-output-var Typeinfo-entry-output-var => eax -11197 89/<- *(eax+0x14) 7/r32/edi # Var-offset -11198 # curr-offset += size-of(v->input-var) -11199 (lookup *esi *(esi+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -11200 (size-of %eax) # => eax -11201 01/add-to %edi 0/r32/eax -11202 # ++i -11203 43/increment-ebx -11204 e9/jump loop/disp32 -11205 } -11206 $populate-mu-type-offsets:end: -11207 # . restore registers -11208 5f/pop-to-edi -11209 5e/pop-to-esi -11210 5b/pop-to-ebx -11211 5a/pop-to-edx -11212 59/pop-to-ecx -11213 58/pop-to-eax -11214 # . epilogue -11215 89/<- %esp 5/r32/ebp -11216 5d/pop-to-ebp -11217 c3/return -11218 -11219 locate-typeinfo-entry-with-index: # table: (addr table (handle array byte) (handle typeinfo-entry)), idx: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: (addr typeinfo-entry) -11220 # . prologue -11221 55/push-ebp -11222 89/<- %ebp 4/r32/esp -11223 # . save registers -11224 51/push-ecx -11225 52/push-edx -11226 53/push-ebx -11227 56/push-esi -11228 57/push-edi -11229 # esi = table -11230 8b/-> *(ebp+8) 6/r32/esi -11231 # var curr/ecx: (addr row (handle array byte) (handle typeinfo-entry)) = table->data -11232 8d/copy-address *(esi+0xc) 1/r32/ecx -11233 # var max/edx: (addr byte) = &table->data[table->write] -11234 8b/-> *esi 2/r32/edx -11235 8d/copy-address *(ecx+edx) 2/r32/edx -11236 { -11237 $locate-typeinfo-entry-with-index:loop: -11238 39/compare %ecx 2/r32/edx -11239 73/jump-if-addr>= break/disp8 -11240 # var v/eax: (addr typeinfo-entry) -11241 (lookup *(ecx+8) *(ecx+0xc)) # => eax -11242 # if (v->index == idx) return v -11243 8b/-> *(eax+8) 3/r32/ebx # Typeinfo-entry-index -11244 #? (write-buffered Stderr "comparing ") -11245 #? (write-int32-hex-buffered Stderr %ebx) -11246 #? (write-buffered Stderr " and ") -11247 #? (write-int32-hex-buffered Stderr *(ebp+0xc)) -11248 #? (write-buffered Stderr Newline) -11249 #? (flush Stderr) -11250 39/compare *(ebp+0xc) 3/r32/ebx -11251 74/jump-if-= $locate-typeinfo-entry-with-index:end/disp8 -11252 # curr += Typeinfo-entry-size -11253 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-entry-size -11254 # -11255 eb/jump loop/disp8 -11256 } -11257 # return 0 -11258 b8/copy-to-eax 0/imm32 -11259 $locate-typeinfo-entry-with-index:end: -11260 #? (write-buffered Stderr "returning ") -11261 #? (write-int32-hex-buffered Stderr %eax) -11262 #? (write-buffered Stderr Newline) -11263 #? (flush Stderr) -11264 # . restore registers -11265 5f/pop-to-edi -11266 5e/pop-to-esi -11267 5b/pop-to-ebx -11268 5a/pop-to-edx -11269 59/pop-to-ecx -11270 # . epilogue -11271 89/<- %esp 5/r32/ebp -11272 5d/pop-to-ebp -11273 c3/return -11274 -11275 dump-typeinfos: # hdr: (addr array byte) -11276 # . prologue -11277 55/push-ebp -11278 89/<- %ebp 4/r32/esp -11279 # . save registers -11280 50/push-eax -11281 # -11282 (write-buffered Stderr *(ebp+8)) -11283 (flush Stderr) -11284 # var curr/eax: (addr typeinfo) = lookup(Program->types) -11285 (lookup *_Program-types *_Program-types->payload) # => eax -11286 { -11287 # if (curr == null) break -11288 3d/compare-eax-and 0/imm32 -11289 74/jump-if-= break/disp8 -11290 (write-buffered Stderr "---\n") -11291 (flush Stderr) -11292 (dump-typeinfo %eax) -11293 # curr = lookup(curr->next) -11294 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -11295 eb/jump loop/disp8 -11296 } -11297 $dump-typeinfos:end: -11298 # . restore registers -11299 58/pop-to-eax -11300 # . epilogue -11301 89/<- %esp 5/r32/ebp -11302 5d/pop-to-ebp -11303 c3/return -11304 -11305 dump-typeinfo: # in: (addr typeinfo) -11306 # . prologue -11307 55/push-ebp -11308 89/<- %ebp 4/r32/esp -11309 # . save registers -11310 50/push-eax -11311 51/push-ecx -11312 52/push-edx -11313 53/push-ebx -11314 56/push-esi -11315 57/push-edi -11316 # esi = in -11317 8b/-> *(ebp+8) 6/r32/esi -11318 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) -11319 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax -11320 89/<- %ecx 0/r32/eax -11321 (write-buffered Stderr "id:") -11322 (write-int32-hex-buffered Stderr *esi) -11323 (write-buffered Stderr "\n") -11324 (write-buffered Stderr "fields @ ") -11325 (write-int32-hex-buffered Stderr %ecx) -11326 (write-buffered Stderr Newline) -11327 (flush Stderr) -11328 (write-buffered Stderr " write: ") -11329 (write-int32-hex-buffered Stderr *ecx) -11330 (write-buffered Stderr Newline) -11331 (flush Stderr) -11332 (write-buffered Stderr " read: ") -11333 (write-int32-hex-buffered Stderr *(ecx+4)) -11334 (write-buffered Stderr Newline) -11335 (flush Stderr) -11336 (write-buffered Stderr " size: ") -11337 (write-int32-hex-buffered Stderr *(ecx+8)) -11338 (write-buffered Stderr Newline) -11339 (flush Stderr) -11340 # var table-size/edx: int = table->write -11341 8b/-> *ecx 2/r32/edx # stream-write -11342 # var curr/ecx: (addr table_row) = table->data -11343 8d/copy-address *(ecx+0xc) 1/r32/ecx -11344 # var max/edx: (addr table_row) = table->data + table->write -11345 8d/copy-address *(ecx+edx) 2/r32/edx -11346 { -11347 $dump-typeinfo:loop: -11348 # if (curr >= max) break -11349 39/compare %ecx 2/r32/edx -11350 0f 83/jump-if-addr>= break/disp32 -11351 (write-buffered Stderr " row:\n") -11352 (write-buffered Stderr " key: ") -11353 (write-int32-hex-buffered Stderr *ecx) -11354 (write-buffered Stderr ",") -11355 (write-int32-hex-buffered Stderr *(ecx+4)) -11356 (write-buffered Stderr " = '") -11357 (lookup *ecx *(ecx+4)) -11358 (write-buffered Stderr %eax) -11359 (write-buffered Stderr "' @ ") -11360 (write-int32-hex-buffered Stderr %eax) -11361 (write-buffered Stderr Newline) -11362 (flush Stderr) -11363 (write-buffered Stderr " value: ") -11364 (write-int32-hex-buffered Stderr *(ecx+8)) -11365 (write-buffered Stderr ",") -11366 (write-int32-hex-buffered Stderr *(ecx+0xc)) -11367 (write-buffered Stderr " = typeinfo-entry@") -11368 (lookup *(ecx+8) *(ecx+0xc)) -11369 (write-int32-hex-buffered Stderr %eax) -11370 (write-buffered Stderr Newline) -11371 (flush Stderr) -11372 (write-buffered Stderr " input var@") -11373 (dump-var 5 %eax) -11374 (lookup *(ecx+8) *(ecx+0xc)) -11375 (write-buffered Stderr " index: ") -11376 (write-int32-hex-buffered Stderr *(eax+8)) -11377 (write-buffered Stderr Newline) -11378 (flush Stderr) -11379 (write-buffered Stderr " output var@") -11380 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var -11381 (dump-var 5 %eax) -11382 (flush Stderr) -11383 # curr += row-size -11384 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size -11385 # -11386 e9/jump loop/disp32 -11387 } -11388 $dump-typeinfo:end: -11389 # . restore registers -11390 5f/pop-to-edi -11391 5e/pop-to-esi -11392 5b/pop-to-ebx -11393 5a/pop-to-edx -11394 59/pop-to-ecx -11395 58/pop-to-eax -11396 # . epilogue -11397 89/<- %esp 5/r32/ebp -11398 5d/pop-to-ebp -11399 c3/return -11400 -11401 dump-var: # indent: int, v: (addr handle var) -11402 # . prologue -11403 55/push-ebp -11404 89/<- %ebp 4/r32/esp -11405 # . save registers -11406 50/push-eax +11115 $populate-mu-type-sizes-in-type:loop: +11116 # if (curr >= max) break +11117 39/compare %ecx 2/r32/edx +11118 73/jump-if-addr>= break/disp8 +11119 # var t/eax: (addr typeinfo-entry) = lookup(curr->value) +11120 (lookup *(ecx+8) *(ecx+0xc)) # => eax +11121 # if (t->input-var == 0) silently ignore it; we'll emit a nice error message while type-checking +11122 81 7/subop/compare *eax 0/imm32 # Typeinfo-entry-input-var +11123 74/jump-if-= $populate-mu-type-sizes-in-type:end/disp8 +11124 # compute size of t->input-var +11125 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +11126 (compute-size-of-var %eax *(ebp+0xc) *(ebp+0x10)) # => eax +11127 # result += eax +11128 01/add-to %edi 0/r32/eax +11129 # curr += row-size +11130 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size +11131 # +11132 eb/jump loop/disp8 +11133 } +11134 # - save result +11135 89/<- *(esi+0xc) 7/r32/edi # Typeinfo-total-size-in-bytes +11136 $populate-mu-type-sizes-in-type:end: +11137 # . restore registers +11138 5f/pop-to-edi +11139 5e/pop-to-esi +11140 5a/pop-to-edx +11141 59/pop-to-ecx +11142 58/pop-to-eax +11143 # . epilogue +11144 89/<- %esp 5/r32/ebp +11145 5d/pop-to-ebp +11146 c3/return +11147 +11148 $populate-mu-type-sizes-in-type:abort: +11149 (write-buffered *(ebp+0xc) "cycle in type definitions\n") +11150 (flush *(ebp+0xc)) +11151 (stop *(ebp+0x10) 1) +11152 # never gets here +11153 +11154 # Analogous to size-of, except we need to compute what size-of can just read +11155 # off the right data structures. +11156 compute-size-of-var: # in: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +11157 # . prologue +11158 55/push-ebp +11159 89/<- %ebp 4/r32/esp +11160 # . push registers +11161 51/push-ecx +11162 # var t/ecx: (addr type-tree) = lookup(v->type) +11163 8b/-> *(ebp+8) 1/r32/ecx +11164 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +11165 89/<- %ecx 0/r32/eax +11166 # if (t->is-atom == false) t = lookup(t->left) +11167 { +11168 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +11169 75/jump-if-!= break/disp8 +11170 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +11171 89/<- %ecx 0/r32/eax +11172 } +11173 # TODO: ensure t is an atom +11174 (compute-size-of-type-id *(ecx+4) *(ebp+0xc) *(ebp+0x10)) # Type-tree-value => eax +11175 $compute-size-of-var:end: +11176 # . restore registers +11177 59/pop-to-ecx +11178 # . epilogue +11179 89/<- %esp 5/r32/ebp +11180 5d/pop-to-ebp +11181 c3/return +11182 +11183 compute-size-of-type-id: # t: type-id, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +11184 # . prologue +11185 55/push-ebp +11186 89/<- %ebp 4/r32/esp +11187 # . save registers +11188 51/push-ecx +11189 # var out/ecx: (handle typeinfo) +11190 68/push 0/imm32 +11191 68/push 0/imm32 +11192 89/<- %ecx 4/r32/esp +11193 # eax = t +11194 8b/-> *(ebp+8) 0/r32/eax +11195 # if t is a literal, return 0 +11196 3d/compare-eax-and 0/imm32/literal +11197 0f 84/jump-if-= $compute-size-of-type-id:end/disp32 # eax changes type from type-id to int +11198 # if t is a byte, return 4 (because we don't really support non-multiples of 4) +11199 3d/compare-eax-and 8/imm32/byte +11200 { +11201 75/jump-if-!= break/disp8 +11202 b8/copy-to-eax 4/imm32 +11203 eb/jump $compute-size-of-type-id:end/disp8 +11204 } +11205 # if t is a handle, return 8 +11206 3d/compare-eax-and 4/imm32/handle +11207 { +11208 75/jump-if-!= break/disp8 +11209 b8/copy-to-eax 8/imm32 +11210 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int +11211 } +11212 # if t is a slice, return 8 +11213 3d/compare-eax-and 0xc/imm32/slice +11214 { +11215 75/jump-if-!= break/disp8 +11216 b8/copy-to-eax 8/imm32 +11217 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int +11218 } +11219 # if t is a user-defined type, compute its size +11220 # TODO: support non-atom type +11221 (find-typeinfo %eax %ecx) +11222 { +11223 81 7/subop/compare *ecx 0/imm32 +11224 74/jump-if-= break/disp8 +11225 $compute-size-of-type-id:user-defined: +11226 (lookup *ecx *(ecx+4)) # => eax +11227 (populate-mu-type-sizes-in-type %eax *(ebp+0xc) *(ebp+0x10)) +11228 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes +11229 eb/jump $compute-size-of-type-id:end/disp8 +11230 } +11231 # otherwise return the word size +11232 b8/copy-to-eax 4/imm32 +11233 $compute-size-of-type-id:end: +11234 # . reclaim locals +11235 81 0/subop/add %esp 8/imm32 +11236 # . restore registers +11237 59/pop-to-ecx +11238 # . epilogue +11239 89/<- %esp 5/r32/ebp +11240 5d/pop-to-ebp +11241 c3/return +11242 +11243 # at this point we have total sizes for all user-defined types +11244 # compute offsets for each element +11245 # complication: fields may be out of order +11246 populate-mu-type-offsets: # in: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +11247 # . prologue +11248 55/push-ebp +11249 89/<- %ebp 4/r32/esp +11250 # . save registers +11251 50/push-eax +11252 51/push-ecx +11253 52/push-edx +11254 53/push-ebx +11255 56/push-esi +11256 57/push-edi +11257 #? (dump-typeinfos "aaa\n") +11258 # var curr-offset/edi: int = 0 +11259 bf/copy-to-edi 0/imm32 +11260 # var table/ecx: (addr table string_key (handle typeinfo-entry)) = lookup(in->fields) +11261 8b/-> *(ebp+8) 1/r32/ecx +11262 (lookup *(ecx+4) *(ecx+8)) # Typeinfo-fields Typeinfo-fields => eax +11263 89/<- %ecx 0/r32/eax +11264 # var num-elems/edx: int = table->write / Typeinfo-fields-row-size +11265 8b/-> *ecx 2/r32/edx # stream-write +11266 c1 5/subop/shift-right-logical %edx 4/imm8 +11267 # var i/ebx: int = 0 +11268 bb/copy-to-ebx 0/imm32 +11269 { +11270 $populate-mu-type-offsets:loop: +11271 39/compare %ebx 2/r32/edx +11272 0f 8d/jump-if->= break/disp32 +11273 #? (write-buffered Stderr "looking up index ") +11274 #? (write-int32-hex-buffered Stderr %ebx) +11275 #? (write-buffered Stderr " in ") +11276 #? (write-int32-hex-buffered Stderr *(ebp+8)) +11277 #? (write-buffered Stderr Newline) +11278 #? (flush Stderr) +11279 # var v/esi: (addr typeinfo-entry) +11280 (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10)) # => eax +11281 89/<- %esi 0/r32/eax +11282 # if v is null, silently move on; we'll emit a nice error message while type-checking +11283 81 7/subop/compare %esi 0/imm32 # Typeinfo-entry-input-var +11284 74/jump-if-= $populate-mu-type-offsets:end/disp8 +11285 # if (v->input-var == 0) silently ignore v; we'll emit a nice error message while type-checking +11286 81 7/subop/compare *esi 0/imm32 # Typeinfo-entry-input-var +11287 74/jump-if-= $populate-mu-type-offsets:end/disp8 +11288 # v->output-var->offset = curr-offset +11289 # . eax: (addr var) +11290 (lookup *(esi+0xc) *(esi+0x10)) # Typeinfo-entry-output-var Typeinfo-entry-output-var => eax +11291 89/<- *(eax+0x14) 7/r32/edi # Var-offset +11292 # curr-offset += size-of(v->input-var) +11293 (lookup *esi *(esi+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +11294 (size-of %eax) # => eax +11295 01/add-to %edi 0/r32/eax +11296 # ++i +11297 43/increment-ebx +11298 e9/jump loop/disp32 +11299 } +11300 $populate-mu-type-offsets:end: +11301 # . restore registers +11302 5f/pop-to-edi +11303 5e/pop-to-esi +11304 5b/pop-to-ebx +11305 5a/pop-to-edx +11306 59/pop-to-ecx +11307 58/pop-to-eax +11308 # . epilogue +11309 89/<- %esp 5/r32/ebp +11310 5d/pop-to-ebp +11311 c3/return +11312 +11313 locate-typeinfo-entry-with-index: # table: (addr table (handle array byte) (handle typeinfo-entry)), idx: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: (addr typeinfo-entry) +11314 # . prologue +11315 55/push-ebp +11316 89/<- %ebp 4/r32/esp +11317 # . save registers +11318 51/push-ecx +11319 52/push-edx +11320 53/push-ebx +11321 56/push-esi +11322 57/push-edi +11323 # esi = table +11324 8b/-> *(ebp+8) 6/r32/esi +11325 # var curr/ecx: (addr row (handle array byte) (handle typeinfo-entry)) = table->data +11326 8d/copy-address *(esi+0xc) 1/r32/ecx +11327 # var max/edx: (addr byte) = &table->data[table->write] +11328 8b/-> *esi 2/r32/edx +11329 8d/copy-address *(ecx+edx) 2/r32/edx +11330 { +11331 $locate-typeinfo-entry-with-index:loop: +11332 39/compare %ecx 2/r32/edx +11333 73/jump-if-addr>= break/disp8 +11334 # var v/eax: (addr typeinfo-entry) +11335 (lookup *(ecx+8) *(ecx+0xc)) # => eax +11336 # if (v->index == idx) return v +11337 8b/-> *(eax+8) 3/r32/ebx # Typeinfo-entry-index +11338 #? (write-buffered Stderr "comparing ") +11339 #? (write-int32-hex-buffered Stderr %ebx) +11340 #? (write-buffered Stderr " and ") +11341 #? (write-int32-hex-buffered Stderr *(ebp+0xc)) +11342 #? (write-buffered Stderr Newline) +11343 #? (flush Stderr) +11344 39/compare *(ebp+0xc) 3/r32/ebx +11345 74/jump-if-= $locate-typeinfo-entry-with-index:end/disp8 +11346 # curr += Typeinfo-entry-size +11347 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-entry-size +11348 # +11349 eb/jump loop/disp8 +11350 } +11351 # return 0 +11352 b8/copy-to-eax 0/imm32 +11353 $locate-typeinfo-entry-with-index:end: +11354 #? (write-buffered Stderr "returning ") +11355 #? (write-int32-hex-buffered Stderr %eax) +11356 #? (write-buffered Stderr Newline) +11357 #? (flush Stderr) +11358 # . restore registers +11359 5f/pop-to-edi +11360 5e/pop-to-esi +11361 5b/pop-to-ebx +11362 5a/pop-to-edx +11363 59/pop-to-ecx +11364 # . epilogue +11365 89/<- %esp 5/r32/ebp +11366 5d/pop-to-ebp +11367 c3/return +11368 +11369 dump-typeinfos: # hdr: (addr array byte) +11370 # . prologue +11371 55/push-ebp +11372 89/<- %ebp 4/r32/esp +11373 # . save registers +11374 50/push-eax +11375 # +11376 (write-buffered Stderr *(ebp+8)) +11377 (flush Stderr) +11378 # var curr/eax: (addr typeinfo) = lookup(Program->types) +11379 (lookup *_Program-types *_Program-types->payload) # => eax +11380 { +11381 # if (curr == null) break +11382 3d/compare-eax-and 0/imm32 +11383 74/jump-if-= break/disp8 +11384 (write-buffered Stderr "---\n") +11385 (flush Stderr) +11386 (dump-typeinfo %eax) +11387 # curr = lookup(curr->next) +11388 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +11389 eb/jump loop/disp8 +11390 } +11391 $dump-typeinfos:end: +11392 # . restore registers +11393 58/pop-to-eax +11394 # . epilogue +11395 89/<- %esp 5/r32/ebp +11396 5d/pop-to-ebp +11397 c3/return +11398 +11399 dump-typeinfo: # in: (addr typeinfo) +11400 # . prologue +11401 55/push-ebp +11402 89/<- %ebp 4/r32/esp +11403 # . save registers +11404 50/push-eax +11405 51/push-ecx +11406 52/push-edx 11407 53/push-ebx -11408 # eax = v -11409 8b/-> *(ebp+0xc) 0/r32/eax -11410 # -11411 (write-int32-hex-buffered Stderr *eax) -11412 (write-buffered Stderr ",") -11413 (write-int32-hex-buffered Stderr *(eax+4)) -11414 (write-buffered Stderr "->") -11415 (lookup *eax *(eax+4)) -11416 (write-int32-hex-buffered Stderr %eax) -11417 (write-buffered Stderr Newline) -11418 (flush Stderr) -11419 { -11420 3d/compare-eax-and 0/imm32 -11421 0f 84/jump-if-= break/disp32 -11422 (emit-indent Stderr *(ebp+8)) -11423 (write-buffered Stderr "name: ") -11424 89/<- %ebx 0/r32/eax -11425 (write-int32-hex-buffered Stderr *ebx) # Var-name -11426 (write-buffered Stderr ",") -11427 (write-int32-hex-buffered Stderr *(ebx+4)) # Var-name -11428 (write-buffered Stderr "->") -11429 (lookup *ebx *(ebx+4)) # Var-name -11430 (write-int32-hex-buffered Stderr %eax) -11431 { -11432 3d/compare-eax-and 0/imm32 -11433 74/jump-if-= break/disp8 -11434 (write-buffered Stderr Space) -11435 (write-buffered Stderr %eax) -11436 } -11437 (write-buffered Stderr Newline) -11438 (flush Stderr) -11439 (emit-indent Stderr *(ebp+8)) -11440 (write-buffered Stderr "block depth: ") -11441 (write-int32-hex-buffered Stderr *(ebx+0x10)) # Var-block-depth -11442 (write-buffered Stderr Newline) -11443 (flush Stderr) -11444 (emit-indent Stderr *(ebp+8)) -11445 (write-buffered Stderr "stack offset: ") -11446 (write-int32-hex-buffered Stderr *(ebx+0x14)) # Var-offset -11447 (write-buffered Stderr Newline) -11448 (flush Stderr) -11449 (emit-indent Stderr *(ebp+8)) -11450 (write-buffered Stderr "reg: ") -11451 (write-int32-hex-buffered Stderr *(ebx+0x18)) # Var-register -11452 (write-buffered Stderr ",") -11453 (write-int32-hex-buffered Stderr *(ebx+0x1c)) # Var-register -11454 (write-buffered Stderr "->") -11455 (flush Stderr) -11456 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register -11457 (write-int32-hex-buffered Stderr %eax) -11458 { -11459 3d/compare-eax-and 0/imm32 -11460 74/jump-if-= break/disp8 -11461 (write-buffered Stderr Space) -11462 (write-buffered Stderr %eax) -11463 } +11408 56/push-esi +11409 57/push-edi +11410 # esi = in +11411 8b/-> *(ebp+8) 6/r32/esi +11412 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) +11413 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax +11414 89/<- %ecx 0/r32/eax +11415 (write-buffered Stderr "id:") +11416 (write-int32-hex-buffered Stderr *esi) +11417 (write-buffered Stderr "\n") +11418 (write-buffered Stderr "fields @ ") +11419 (write-int32-hex-buffered Stderr %ecx) +11420 (write-buffered Stderr Newline) +11421 (flush Stderr) +11422 (write-buffered Stderr " write: ") +11423 (write-int32-hex-buffered Stderr *ecx) +11424 (write-buffered Stderr Newline) +11425 (flush Stderr) +11426 (write-buffered Stderr " read: ") +11427 (write-int32-hex-buffered Stderr *(ecx+4)) +11428 (write-buffered Stderr Newline) +11429 (flush Stderr) +11430 (write-buffered Stderr " size: ") +11431 (write-int32-hex-buffered Stderr *(ecx+8)) +11432 (write-buffered Stderr Newline) +11433 (flush Stderr) +11434 # var table-size/edx: int = table->write +11435 8b/-> *ecx 2/r32/edx # stream-write +11436 # var curr/ecx: (addr table_row) = table->data +11437 8d/copy-address *(ecx+0xc) 1/r32/ecx +11438 # var max/edx: (addr table_row) = table->data + table->write +11439 8d/copy-address *(ecx+edx) 2/r32/edx +11440 { +11441 $dump-typeinfo:loop: +11442 # if (curr >= max) break +11443 39/compare %ecx 2/r32/edx +11444 0f 83/jump-if-addr>= break/disp32 +11445 (write-buffered Stderr " row:\n") +11446 (write-buffered Stderr " key: ") +11447 (write-int32-hex-buffered Stderr *ecx) +11448 (write-buffered Stderr ",") +11449 (write-int32-hex-buffered Stderr *(ecx+4)) +11450 (write-buffered Stderr " = '") +11451 (lookup *ecx *(ecx+4)) +11452 (write-buffered Stderr %eax) +11453 (write-buffered Stderr "' @ ") +11454 (write-int32-hex-buffered Stderr %eax) +11455 (write-buffered Stderr Newline) +11456 (flush Stderr) +11457 (write-buffered Stderr " value: ") +11458 (write-int32-hex-buffered Stderr *(ecx+8)) +11459 (write-buffered Stderr ",") +11460 (write-int32-hex-buffered Stderr *(ecx+0xc)) +11461 (write-buffered Stderr " = typeinfo-entry@") +11462 (lookup *(ecx+8) *(ecx+0xc)) +11463 (write-int32-hex-buffered Stderr %eax) 11464 (write-buffered Stderr Newline) 11465 (flush Stderr) -11466 } -11467 $dump-var:end: -11468 # . restore registers -11469 5b/pop-to-ebx -11470 58/pop-to-eax -11471 # . epilogue -11472 89/<- %esp 5/r32/ebp -11473 5d/pop-to-ebp -11474 c3/return -11475 -11476 ####################################################### -11477 # Type-checking -11478 ####################################################### -11479 -11480 check-mu-types: # err: (addr buffered-file), ed: (addr exit-descriptor) -11481 # . prologue -11482 55/push-ebp -11483 89/<- %ebp 4/r32/esp -11484 # . save registers -11485 50/push-eax -11486 # var curr/eax: (addr function) = lookup(Program->functions) -11487 (lookup *_Program-functions *_Program-functions->payload) # => eax -11488 { -11489 $check-mu-types:loop: -11490 # if (curr == null) break -11491 3d/compare-eax-and 0/imm32 -11492 0f 84/jump-if-= break/disp32 -11493 +-- 8 lines: #? # dump curr->name ------------------------------------------------------------------------------------------------------------------------------------------------ -11501 (check-mu-function %eax *(ebp+8) *(ebp+0xc)) -11502 # curr = lookup(curr->next) -11503 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax -11504 e9/jump loop/disp32 -11505 } -11506 $check-mu-types:end: -11507 # . restore registers -11508 58/pop-to-eax -11509 # . epilogue -11510 89/<- %esp 5/r32/ebp -11511 5d/pop-to-ebp -11512 c3/return -11513 -11514 check-mu-function: # fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11515 # . prologue -11516 55/push-ebp -11517 89/<- %ebp 4/r32/esp -11518 # . save registers -11519 50/push-eax -11520 # eax = f -11521 8b/-> *(ebp+8) 0/r32/eax -11522 # TODO: anything to check in header? -11523 # var body/eax: (addr block) = lookup(f->body) -11524 (lookup *(eax+0x18) *(eax+0x1c)) # Function-body Function-body => eax -11525 (check-mu-block %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10)) -11526 $check-mu-function:end: -11527 # . restore registers -11528 58/pop-to-eax -11529 # . epilogue -11530 89/<- %esp 5/r32/ebp -11531 5d/pop-to-ebp -11532 c3/return -11533 -11534 check-mu-block: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11535 # . prologue -11536 55/push-ebp -11537 89/<- %ebp 4/r32/esp -11538 # . save registers -11539 50/push-eax -11540 # eax = block -11541 8b/-> *(ebp+8) 0/r32/eax -11542 # var stmts/eax: (addr list stmt) = lookup(block->statements) -11543 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax -11544 # -11545 { -11546 $check-mu-block:check-empty: -11547 3d/compare-eax-and 0/imm32 -11548 0f 84/jump-if-= break/disp32 -11549 # emit block->statements -11550 (check-mu-stmt-list %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11551 } -11552 $check-mu-block:end: -11553 # . restore registers -11554 58/pop-to-eax -11555 # . epilogue -11556 89/<- %esp 5/r32/ebp -11557 5d/pop-to-ebp -11558 c3/return -11559 -11560 check-mu-stmt-list: # stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11561 # . prologue -11562 55/push-ebp -11563 89/<- %ebp 4/r32/esp -11564 # . save registers -11565 50/push-eax -11566 56/push-esi -11567 # esi = stmts -11568 8b/-> *(ebp+8) 6/r32/esi -11569 { -11570 $check-mu-stmt-list:loop: -11571 81 7/subop/compare %esi 0/imm32 -11572 0f 84/jump-if-= break/disp32 -11573 # var curr-stmt/eax: (addr stmt) = lookup(stmts->value) -11574 (lookup *esi *(esi+4)) # List-value List-value => eax -11575 { -11576 $check-mu-stmt-list:check-for-block: -11577 81 7/subop/compare *eax 0/imm32/block # Stmt-tag -11578 75/jump-if-!= break/disp8 -11579 $check-mu-stmt-list:block: -11580 (check-mu-block %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11581 eb/jump $check-mu-stmt-list:continue/disp8 -11582 } -11583 { -11584 $check-mu-stmt-list:check-for-stmt1: -11585 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag -11586 0f 85/jump-if-!= break/disp32 -11587 $check-mu-stmt-list:stmt1: -11588 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11589 eb/jump $check-mu-stmt-list:continue/disp8 -11590 } -11591 { -11592 $check-mu-stmt-list:check-for-reg-var-def: -11593 81 7/subop/compare *eax 3/imm32/reg-var-def # Stmt-tag -11594 0f 85/jump-if-!= break/disp32 -11595 $check-mu-stmt-list:reg-var-def: -11596 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11597 eb/jump $check-mu-stmt-list:continue/disp8 -11598 } -11599 $check-mu-stmt-list:continue: -11600 # TODO: raise an error on unrecognized Stmt-tag -11601 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax -11602 89/<- %esi 0/r32/eax -11603 e9/jump loop/disp32 -11604 } -11605 $check-mu-stmt-list:end: -11606 # . restore registers -11607 5e/pop-to-esi -11608 58/pop-to-eax -11609 # . epilogue -11610 89/<- %esp 5/r32/ebp -11611 5d/pop-to-ebp -11612 c3/return -11613 -11614 check-mu-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11615 # . prologue -11616 55/push-ebp -11617 89/<- %ebp 4/r32/esp -11618 # . save registers -11619 50/push-eax -11620 # - if stmt's operation matches a primitive, check against it -11621 (has-primitive-name? *(ebp+8)) # => eax -11622 3d/compare-eax-and 0/imm32/false -11623 { -11624 74/jump-if-= break/disp8 -11625 (check-mu-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11626 e9/jump $check-mu-stmt:end/disp32 -11627 } -11628 # - otherwise find a function to check against -11629 # var f/eax: (addr function) = lookup(*Program->functions) -11630 (lookup *_Program-functions *_Program-functions->payload) # => eax -11631 (find-matching-function %eax *(ebp+8)) # => eax -11632 3d/compare-eax-and 0/imm32 -11633 { -11634 74/jump-if-= break/disp8 -11635 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11636 eb/jump $check-mu-stmt:end/disp8 -11637 } -11638 # var f/eax: (addr function) = lookup(*Program->signatures) -11639 (lookup *_Program-signatures *_Program-signatures->payload) # => eax -11640 (find-matching-function %eax *(ebp+8)) # => eax -11641 3d/compare-eax-and 0/imm32 -11642 { -11643 74/jump-if-= break/disp8 -11644 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11645 eb/jump $check-mu-stmt:end/disp8 -11646 } -11647 # - otherwise abort -11648 e9/jump $check-mu-stmt:unknown-call/disp32 -11649 $check-mu-stmt:end: -11650 # . restore registers -11651 58/pop-to-eax -11652 # . epilogue -11653 89/<- %esp 5/r32/ebp -11654 5d/pop-to-ebp -11655 c3/return -11656 -11657 $check-mu-stmt:unknown-call: -11658 (write-buffered *(ebp+0x10) "unknown function '") -11659 8b/-> *(ebp+8) 0/r32/eax -11660 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -11661 (write-buffered *(ebp+0x10) %eax) -11662 (write-buffered *(ebp+0x10) "'\n") -11663 (flush *(ebp+0x10)) -11664 (stop *(ebp+0x14) 1) -11665 # never gets here -11666 -11667 has-primitive-name?: # stmt: (addr stmt) -> result/eax: boolean -11668 # . prologue -11669 55/push-ebp -11670 89/<- %ebp 4/r32/esp -11671 # . save registers -11672 51/push-ecx -11673 56/push-esi -11674 # var name/esi: (addr array byte) = lookup(stmt->operation) -11675 8b/-> *(ebp+8) 6/r32/esi -11676 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -11677 89/<- %esi 0/r32/eax -11678 # if (name == "get") return true -11679 (string-equal? %esi "get") # => eax -11680 3d/compare-eax-and 0/imm32/false -11681 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11682 # if (name == "index") return true -11683 (string-equal? %esi "index") # => eax -11684 3d/compare-eax-and 0/imm32/false -11685 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11686 # if (name == "length") return true -11687 (string-equal? %esi "length") # => eax -11688 3d/compare-eax-and 0/imm32/false -11689 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11690 # if (name == "compute-offset") return true -11691 (string-equal? %esi "compute-offset") # => eax -11692 3d/compare-eax-and 0/imm32/false -11693 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11694 # if (name == "allocate") return true -11695 (string-equal? %esi "allocate") # => eax -11696 3d/compare-eax-and 0/imm32/false -11697 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11698 # if (name == "populate") return true -11699 (string-equal? %esi "populate") # => eax -11700 3d/compare-eax-and 0/imm32/false -11701 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11702 # if (name == "populate-stream") return true -11703 (string-equal? %esi "populate-stream") # => eax -11704 3d/compare-eax-and 0/imm32/false -11705 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11706 # if (name == "read-from-stream") return true -11707 (string-equal? %esi "read-from-stream") # => eax -11708 3d/compare-eax-and 0/imm32/false -11709 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11710 # if (name == "write-to-stream") return true -11711 (string-equal? %esi "write-to-stream") # => eax -11712 3d/compare-eax-and 0/imm32/false -11713 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -11714 # var curr/ecx: (addr primitive) = Primitives -11715 b9/copy-to-ecx Primitives/imm32 -11716 { -11717 $has-primitive-name?:loop: -11718 # if (curr == null) break -11719 81 7/subop/compare %ecx 0/imm32 -11720 74/jump-if-= break/disp8 -11721 # if (primitive->name == name) return true -11722 (lookup *ecx *(ecx+4)) # Primitive-name Primitive-name => eax -11723 (string-equal? %esi %eax) # => eax -11724 3d/compare-eax-and 0/imm32/false -11725 75/jump-if-!= $has-primitive-name?:end/disp8 -11726 $has-primitive-name?:next-primitive: -11727 # curr = curr->next -11728 (lookup *(ecx+0x38) *(ecx+0x3c)) # Primitive-next Primitive-next => eax -11729 89/<- %ecx 0/r32/eax -11730 # -11731 e9/jump loop/disp32 -11732 } -11733 # return null -11734 b8/copy-to-eax 0/imm32 -11735 $has-primitive-name?:end: -11736 # . restore registers -11737 5e/pop-to-esi -11738 59/pop-to-ecx -11739 # . epilogue -11740 89/<- %esp 5/r32/ebp -11741 5d/pop-to-ebp -11742 c3/return -11743 -11744 check-mu-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11745 # . prologue -11746 55/push-ebp -11747 89/<- %ebp 4/r32/esp -11748 # . save registers -11749 50/push-eax -11750 51/push-ecx -11751 # var op/ecx: (addr array byte) = lookup(stmt->operation) -11752 8b/-> *(ebp+8) 0/r32/eax -11753 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -11754 89/<- %ecx 0/r32/eax -11755 # if (op == "copy") check-mu-copy-stmt -11756 { -11757 (string-equal? %ecx "copy") # => eax -11758 3d/compare-eax-and 0/imm32/false -11759 74/jump-if-= break/disp8 -11760 (check-mu-copy-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11761 e9/jump $check-mu-primitive:end/disp32 -11762 } -11763 # if (op == "copy-to") check-mu-copy-to-stmt -11764 { -11765 (string-equal? %ecx "copy-to") # => eax -11766 3d/compare-eax-and 0/imm32/false -11767 74/jump-if-= break/disp8 -11768 (check-mu-copy-to-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11769 e9/jump $check-mu-primitive:end/disp32 -11770 } -11771 # if (op == "compare") check-mu-compare-stmt -11772 { -11773 (string-equal? %ecx "compare") # => eax -11774 3d/compare-eax-and 0/imm32/false -11775 74/jump-if-= break/disp8 -11776 (check-mu-compare-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11777 e9/jump $check-mu-primitive:end/disp32 -11778 } -11779 # if (op == "address") check-mu-address-stmt -11780 { -11781 (string-equal? %ecx "address") # => eax -11782 3d/compare-eax-and 0/imm32/false -11783 74/jump-if-= break/disp8 -11784 (check-mu-address-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11785 e9/jump $check-mu-primitive:end/disp32 -11786 } -11787 # if (op == "get") check-mu-get-stmt -11788 { -11789 (string-equal? %ecx "get") # => eax -11790 3d/compare-eax-and 0/imm32/false -11791 74/jump-if-= break/disp8 -11792 (check-mu-get-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11793 e9/jump $check-mu-primitive:end/disp32 -11794 } -11795 # if (op == "index") check-mu-index-stmt -11796 { -11797 (string-equal? %ecx "index") # => eax -11798 3d/compare-eax-and 0/imm32/false -11799 74/jump-if-= break/disp8 -11800 (check-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11801 e9/jump $check-mu-primitive:end/disp32 -11802 } -11803 # if (op == "length") check-mu-length-stmt -11804 { -11805 (string-equal? %ecx "length") # => eax -11806 3d/compare-eax-and 0/imm32/false -11807 74/jump-if-= break/disp8 -11808 (check-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11809 e9/jump $check-mu-primitive:end/disp32 -11810 } -11811 # if (op == "compute-offset") check-mu-compute-offset-stmt -11812 { -11813 (string-equal? %ecx "compute-offset") # => eax -11814 3d/compare-eax-and 0/imm32/false -11815 74/jump-if-= break/disp8 -11816 (check-mu-compute-offset-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11817 e9/jump $check-mu-primitive:end/disp32 -11818 } -11819 # if (op == "allocate") check-mu-allocate-stmt -11820 { -11821 (string-equal? %ecx "allocate") # => eax -11822 3d/compare-eax-and 0/imm32/false -11823 74/jump-if-= break/disp8 -11824 (check-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11825 e9/jump $check-mu-primitive:end/disp32 +11466 (write-buffered Stderr " input var@") +11467 (dump-var 5 %eax) +11468 (lookup *(ecx+8) *(ecx+0xc)) +11469 (write-buffered Stderr " index: ") +11470 (write-int32-hex-buffered Stderr *(eax+8)) +11471 (write-buffered Stderr Newline) +11472 (flush Stderr) +11473 (write-buffered Stderr " output var@") +11474 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var +11475 (dump-var 5 %eax) +11476 (flush Stderr) +11477 # curr += row-size +11478 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size +11479 # +11480 e9/jump loop/disp32 +11481 } +11482 $dump-typeinfo:end: +11483 # . restore registers +11484 5f/pop-to-edi +11485 5e/pop-to-esi +11486 5b/pop-to-ebx +11487 5a/pop-to-edx +11488 59/pop-to-ecx +11489 58/pop-to-eax +11490 # . epilogue +11491 89/<- %esp 5/r32/ebp +11492 5d/pop-to-ebp +11493 c3/return +11494 +11495 dump-var: # indent: int, v: (addr handle var) +11496 # . prologue +11497 55/push-ebp +11498 89/<- %ebp 4/r32/esp +11499 # . save registers +11500 50/push-eax +11501 53/push-ebx +11502 # eax = v +11503 8b/-> *(ebp+0xc) 0/r32/eax +11504 # +11505 (write-int32-hex-buffered Stderr *eax) +11506 (write-buffered Stderr ",") +11507 (write-int32-hex-buffered Stderr *(eax+4)) +11508 (write-buffered Stderr "->") +11509 (lookup *eax *(eax+4)) +11510 (write-int32-hex-buffered Stderr %eax) +11511 (write-buffered Stderr Newline) +11512 (flush Stderr) +11513 { +11514 3d/compare-eax-and 0/imm32 +11515 0f 84/jump-if-= break/disp32 +11516 (emit-indent Stderr *(ebp+8)) +11517 (write-buffered Stderr "name: ") +11518 89/<- %ebx 0/r32/eax +11519 (write-int32-hex-buffered Stderr *ebx) # Var-name +11520 (write-buffered Stderr ",") +11521 (write-int32-hex-buffered Stderr *(ebx+4)) # Var-name +11522 (write-buffered Stderr "->") +11523 (lookup *ebx *(ebx+4)) # Var-name +11524 (write-int32-hex-buffered Stderr %eax) +11525 { +11526 3d/compare-eax-and 0/imm32 +11527 74/jump-if-= break/disp8 +11528 (write-buffered Stderr Space) +11529 (write-buffered Stderr %eax) +11530 } +11531 (write-buffered Stderr Newline) +11532 (flush Stderr) +11533 (emit-indent Stderr *(ebp+8)) +11534 (write-buffered Stderr "block depth: ") +11535 (write-int32-hex-buffered Stderr *(ebx+0x10)) # Var-block-depth +11536 (write-buffered Stderr Newline) +11537 (flush Stderr) +11538 (emit-indent Stderr *(ebp+8)) +11539 (write-buffered Stderr "stack offset: ") +11540 (write-int32-hex-buffered Stderr *(ebx+0x14)) # Var-offset +11541 (write-buffered Stderr Newline) +11542 (flush Stderr) +11543 (emit-indent Stderr *(ebp+8)) +11544 (write-buffered Stderr "reg: ") +11545 (write-int32-hex-buffered Stderr *(ebx+0x18)) # Var-register +11546 (write-buffered Stderr ",") +11547 (write-int32-hex-buffered Stderr *(ebx+0x1c)) # Var-register +11548 (write-buffered Stderr "->") +11549 (flush Stderr) +11550 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register +11551 (write-int32-hex-buffered Stderr %eax) +11552 { +11553 3d/compare-eax-and 0/imm32 +11554 74/jump-if-= break/disp8 +11555 (write-buffered Stderr Space) +11556 (write-buffered Stderr %eax) +11557 } +11558 (write-buffered Stderr Newline) +11559 (flush Stderr) +11560 } +11561 $dump-var:end: +11562 # . restore registers +11563 5b/pop-to-ebx +11564 58/pop-to-eax +11565 # . epilogue +11566 89/<- %esp 5/r32/ebp +11567 5d/pop-to-ebp +11568 c3/return +11569 +11570 ####################################################### +11571 # Type-checking +11572 ####################################################### +11573 +11574 check-mu-types: # err: (addr buffered-file), ed: (addr exit-descriptor) +11575 # . prologue +11576 55/push-ebp +11577 89/<- %ebp 4/r32/esp +11578 # . save registers +11579 50/push-eax +11580 # var curr/eax: (addr function) = lookup(Program->functions) +11581 (lookup *_Program-functions *_Program-functions->payload) # => eax +11582 { +11583 $check-mu-types:loop: +11584 # if (curr == null) break +11585 3d/compare-eax-and 0/imm32 +11586 0f 84/jump-if-= break/disp32 +11587 +-- 8 lines: #? # dump curr->name ------------------------------------------------------------------------------------------------------------------------------------------------ +11595 (check-mu-function %eax *(ebp+8) *(ebp+0xc)) +11596 # curr = lookup(curr->next) +11597 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax +11598 e9/jump loop/disp32 +11599 } +11600 $check-mu-types:end: +11601 # . restore registers +11602 58/pop-to-eax +11603 # . epilogue +11604 89/<- %esp 5/r32/ebp +11605 5d/pop-to-ebp +11606 c3/return +11607 +11608 check-mu-function: # fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11609 # . prologue +11610 55/push-ebp +11611 89/<- %ebp 4/r32/esp +11612 # . save registers +11613 50/push-eax +11614 # eax = f +11615 8b/-> *(ebp+8) 0/r32/eax +11616 # TODO: anything to check in header? +11617 # var body/eax: (addr block) = lookup(f->body) +11618 (lookup *(eax+0x18) *(eax+0x1c)) # Function-body Function-body => eax +11619 (check-mu-block %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10)) +11620 $check-mu-function:end: +11621 # . restore registers +11622 58/pop-to-eax +11623 # . epilogue +11624 89/<- %esp 5/r32/ebp +11625 5d/pop-to-ebp +11626 c3/return +11627 +11628 check-mu-block: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11629 # . prologue +11630 55/push-ebp +11631 89/<- %ebp 4/r32/esp +11632 # . save registers +11633 50/push-eax +11634 # eax = block +11635 8b/-> *(ebp+8) 0/r32/eax +11636 # var stmts/eax: (addr list stmt) = lookup(block->statements) +11637 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax +11638 # +11639 { +11640 $check-mu-block:check-empty: +11641 3d/compare-eax-and 0/imm32 +11642 0f 84/jump-if-= break/disp32 +11643 # emit block->statements +11644 (check-mu-stmt-list %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11645 } +11646 $check-mu-block:end: +11647 # . restore registers +11648 58/pop-to-eax +11649 # . epilogue +11650 89/<- %esp 5/r32/ebp +11651 5d/pop-to-ebp +11652 c3/return +11653 +11654 check-mu-stmt-list: # stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11655 # . prologue +11656 55/push-ebp +11657 89/<- %ebp 4/r32/esp +11658 # . save registers +11659 50/push-eax +11660 56/push-esi +11661 # esi = stmts +11662 8b/-> *(ebp+8) 6/r32/esi +11663 { +11664 $check-mu-stmt-list:loop: +11665 81 7/subop/compare %esi 0/imm32 +11666 0f 84/jump-if-= break/disp32 +11667 # var curr-stmt/eax: (addr stmt) = lookup(stmts->value) +11668 (lookup *esi *(esi+4)) # List-value List-value => eax +11669 { +11670 $check-mu-stmt-list:check-for-block: +11671 81 7/subop/compare *eax 0/imm32/block # Stmt-tag +11672 75/jump-if-!= break/disp8 +11673 $check-mu-stmt-list:block: +11674 (check-mu-block %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11675 eb/jump $check-mu-stmt-list:continue/disp8 +11676 } +11677 { +11678 $check-mu-stmt-list:check-for-stmt1: +11679 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag +11680 0f 85/jump-if-!= break/disp32 +11681 $check-mu-stmt-list:stmt1: +11682 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11683 eb/jump $check-mu-stmt-list:continue/disp8 +11684 } +11685 { +11686 $check-mu-stmt-list:check-for-reg-var-def: +11687 81 7/subop/compare *eax 3/imm32/reg-var-def # Stmt-tag +11688 0f 85/jump-if-!= break/disp32 +11689 $check-mu-stmt-list:reg-var-def: +11690 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11691 eb/jump $check-mu-stmt-list:continue/disp8 +11692 } +11693 $check-mu-stmt-list:continue: +11694 # TODO: raise an error on unrecognized Stmt-tag +11695 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax +11696 89/<- %esi 0/r32/eax +11697 e9/jump loop/disp32 +11698 } +11699 $check-mu-stmt-list:end: +11700 # . restore registers +11701 5e/pop-to-esi +11702 58/pop-to-eax +11703 # . epilogue +11704 89/<- %esp 5/r32/ebp +11705 5d/pop-to-ebp +11706 c3/return +11707 +11708 check-mu-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11709 # . prologue +11710 55/push-ebp +11711 89/<- %ebp 4/r32/esp +11712 # . save registers +11713 50/push-eax +11714 # - if stmt's operation matches a primitive, check against it +11715 (has-primitive-name? *(ebp+8)) # => eax +11716 3d/compare-eax-and 0/imm32/false +11717 { +11718 74/jump-if-= break/disp8 +11719 (check-mu-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11720 e9/jump $check-mu-stmt:end/disp32 +11721 } +11722 # - otherwise find a function to check against +11723 # var f/eax: (addr function) = lookup(*Program->functions) +11724 (lookup *_Program-functions *_Program-functions->payload) # => eax +11725 (find-matching-function %eax *(ebp+8)) # => eax +11726 3d/compare-eax-and 0/imm32 +11727 { +11728 74/jump-if-= break/disp8 +11729 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11730 eb/jump $check-mu-stmt:end/disp8 +11731 } +11732 # var f/eax: (addr function) = lookup(*Program->signatures) +11733 (lookup *_Program-signatures *_Program-signatures->payload) # => eax +11734 (find-matching-function %eax *(ebp+8)) # => eax +11735 3d/compare-eax-and 0/imm32 +11736 { +11737 74/jump-if-= break/disp8 +11738 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11739 eb/jump $check-mu-stmt:end/disp8 +11740 } +11741 # - otherwise abort +11742 e9/jump $check-mu-stmt:unknown-call/disp32 +11743 $check-mu-stmt:end: +11744 # . restore registers +11745 58/pop-to-eax +11746 # . epilogue +11747 89/<- %esp 5/r32/ebp +11748 5d/pop-to-ebp +11749 c3/return +11750 +11751 $check-mu-stmt:unknown-call: +11752 (write-buffered *(ebp+0x10) "unknown function '") +11753 8b/-> *(ebp+8) 0/r32/eax +11754 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +11755 (write-buffered *(ebp+0x10) %eax) +11756 (write-buffered *(ebp+0x10) "'\n") +11757 (flush *(ebp+0x10)) +11758 (stop *(ebp+0x14) 1) +11759 # never gets here +11760 +11761 has-primitive-name?: # stmt: (addr stmt) -> result/eax: boolean +11762 # . prologue +11763 55/push-ebp +11764 89/<- %ebp 4/r32/esp +11765 # . save registers +11766 51/push-ecx +11767 56/push-esi +11768 # var name/esi: (addr array byte) = lookup(stmt->operation) +11769 8b/-> *(ebp+8) 6/r32/esi +11770 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +11771 89/<- %esi 0/r32/eax +11772 # if (name == "get") return true +11773 (string-equal? %esi "get") # => eax +11774 3d/compare-eax-and 0/imm32/false +11775 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11776 # if (name == "index") return true +11777 (string-equal? %esi "index") # => eax +11778 3d/compare-eax-and 0/imm32/false +11779 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11780 # if (name == "length") return true +11781 (string-equal? %esi "length") # => eax +11782 3d/compare-eax-and 0/imm32/false +11783 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11784 # if (name == "compute-offset") return true +11785 (string-equal? %esi "compute-offset") # => eax +11786 3d/compare-eax-and 0/imm32/false +11787 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11788 # if (name == "allocate") return true +11789 (string-equal? %esi "allocate") # => eax +11790 3d/compare-eax-and 0/imm32/false +11791 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11792 # if (name == "populate") return true +11793 (string-equal? %esi "populate") # => eax +11794 3d/compare-eax-and 0/imm32/false +11795 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11796 # if (name == "populate-stream") return true +11797 (string-equal? %esi "populate-stream") # => eax +11798 3d/compare-eax-and 0/imm32/false +11799 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11800 # if (name == "read-from-stream") return true +11801 (string-equal? %esi "read-from-stream") # => eax +11802 3d/compare-eax-and 0/imm32/false +11803 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11804 # if (name == "write-to-stream") return true +11805 (string-equal? %esi "write-to-stream") # => eax +11806 3d/compare-eax-and 0/imm32/false +11807 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +11808 # var curr/ecx: (addr primitive) = Primitives +11809 b9/copy-to-ecx Primitives/imm32 +11810 { +11811 $has-primitive-name?:loop: +11812 # if (curr == null) break +11813 81 7/subop/compare %ecx 0/imm32 +11814 74/jump-if-= break/disp8 +11815 # if (primitive->name == name) return true +11816 (lookup *ecx *(ecx+4)) # Primitive-name Primitive-name => eax +11817 (string-equal? %esi %eax) # => eax +11818 3d/compare-eax-and 0/imm32/false +11819 75/jump-if-!= $has-primitive-name?:end/disp8 +11820 $has-primitive-name?:next-primitive: +11821 # curr = curr->next +11822 (lookup *(ecx+0x38) *(ecx+0x3c)) # Primitive-next Primitive-next => eax +11823 89/<- %ecx 0/r32/eax +11824 # +11825 e9/jump loop/disp32 11826 } -11827 # if (op == "populate") check-mu-populate-stmt -11828 { -11829 (string-equal? %ecx "populate") # => eax -11830 3d/compare-eax-and 0/imm32/false -11831 74/jump-if-= break/disp8 -11832 (check-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11833 e9/jump $check-mu-primitive:end/disp32 -11834 } -11835 # if (op == "populate-stream") check-mu-populate-stream-stmt -11836 { -11837 (string-equal? %ecx "populate-stream") # => eax -11838 3d/compare-eax-and 0/imm32/false -11839 74/jump-if-= break/disp8 -11840 (check-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11841 e9/jump $check-mu-primitive:end/disp32 -11842 } -11843 # if (op == "read-from-stream") check-mu-read-from-stream-stmt -11844 { -11845 (string-equal? %ecx "read-from-stream") # => eax -11846 3d/compare-eax-and 0/imm32/false -11847 74/jump-if-= break/disp8 -11848 (check-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11849 e9/jump $check-mu-primitive:end/disp32 -11850 } -11851 # if (op == "write-to-stream") check-mu-write-to-stream-stmt -11852 { -11853 (string-equal? %ecx "write-to-stream") # => eax -11854 3d/compare-eax-and 0/imm32/false -11855 74/jump-if-= break/disp8 -11856 (check-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11857 e9/jump $check-mu-primitive:end/disp32 -11858 } -11859 # otherwise check-numberlike-stmt -11860 (check-mu-numberlike-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11861 $check-mu-primitive:end: -11862 # . restore registers -11863 59/pop-to-ecx -11864 58/pop-to-eax -11865 # . epilogue -11866 89/<- %esp 5/r32/ebp -11867 5d/pop-to-ebp -11868 c3/return -11869 -11870 # by default, Mu primitives should only operate on 'number-like' types -11871 check-mu-numberlike-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11872 # . prologue -11873 55/push-ebp -11874 89/<- %ebp 4/r32/esp -11875 # . save registers -11876 50/push-eax -11877 51/push-ecx -11878 56/push-esi -11879 # esi = stmt -11880 8b/-> *(ebp+8) 6/r32/esi -11881 # var gas/ecx: int = 2 -11882 b9/copy-to-ecx 2/imm32 -11883 # - check at most 1 output -11884 # var output/eax: (addr stmt-var) = stmt->outputs -11885 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -11886 { -11887 3d/compare-eax-and 0/imm32 -11888 74/jump-if-= break/disp8 -11889 $check-mu-numberlike-primitive:output: -11890 (check-mu-numberlike-output %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11891 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -11892 3d/compare-eax-and 0/imm32 -11893 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-outputs/disp32 -11894 # check output is in a register -11895 # --gas -11896 49/decrement-ecx -11897 } -11898 # - check first inout -11899 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -11900 { -11901 3d/compare-eax-and 0/imm32 -11902 0f 84/jump-if-= $check-mu-numberlike-primitive:end/disp32 -11903 $check-mu-numberlike-primitive:first-inout: -11904 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11905 # --gas -11906 49/decrement-ecx -11907 } -11908 # - check second inout -11909 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -11910 { -11911 3d/compare-eax-and 0/imm32 -11912 74/jump-if-= $check-mu-numberlike-primitive:end/disp8 -11913 $check-mu-numberlike-primitive:second-inout: -11914 # is a second inout allowed? -11915 81 7/subop/compare %ecx 0/imm32 -11916 0f 84/jump-if-= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 -11917 $check-mu-numberlike-primitive:second-inout-permitted: -11918 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -11919 } -11920 $check-mu-numberlike-primitive:third-inout: -11921 # if there's a third arg, raise an error -11922 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next -11923 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 -11924 $check-mu-numberlike-primitive:end: -11925 # . restore registers -11926 5e/pop-to-esi -11927 59/pop-to-ecx -11928 58/pop-to-eax -11929 # . epilogue -11930 89/<- %esp 5/r32/ebp -11931 5d/pop-to-ebp -11932 c3/return -11933 -11934 $check-mu-numberlike-primitive:error-too-many-inouts: -11935 (write-buffered *(ebp+0x10) "fn ") -11936 8b/-> *(ebp+0xc) 0/r32/eax -11937 (lookup *eax *(eax+4)) # Function-name Function-name => eax -11938 (write-buffered *(ebp+0x10) %eax) -11939 (write-buffered *(ebp+0x10) ": stmt ") -11940 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -11941 (write-buffered *(ebp+0x10) %eax) -11942 (write-buffered *(ebp+0x10) ": too many inouts; most primitives support at most two arguments, across inouts and outputs\n") -11943 (flush *(ebp+0x10)) -11944 (stop *(ebp+0x14) 1) -11945 # never gets here -11946 -11947 $check-mu-numberlike-primitive:error-too-many-outputs: -11948 (write-buffered *(ebp+0x10) "fn ") -11949 8b/-> *(ebp+0xc) 0/r32/eax -11950 (lookup *eax *(eax+4)) # Function-name Function-name => eax -11951 (write-buffered *(ebp+0x10) %eax) -11952 (write-buffered *(ebp+0x10) ": stmt ") -11953 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -11954 (write-buffered *(ebp+0x10) %eax) -11955 (write-buffered *(ebp+0x10) ": too many outputs; most primitives support at most one output\n") -11956 (flush *(ebp+0x10)) -11957 (stop *(ebp+0x14) 1) -11958 # never gets here -11959 -11960 check-mu-numberlike-arg: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -11961 # . prologue -11962 55/push-ebp -11963 89/<- %ebp 4/r32/esp -11964 # . save registers -11965 50/push-eax -11966 56/push-esi -11967 # var t/esi: (addr type-tree) = lookup(v->value->type) -11968 8b/-> *(ebp+8) 0/r32/eax -11969 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -11970 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -11971 89/<- %esi 0/r32/eax -11972 $check-mu-numberlike-arg:check-literal: -11973 # if t is an int, return -11974 (is-simple-mu-type? %esi 0) # literal => eax -11975 3d/compare-eax-and 0/imm32/false -11976 75/jump-if-!= $check-mu-numberlike-arg:end/disp8 -11977 $check-mu-numberlike-arg:check-addr: -11978 # if t is an addr and v is dereferenced, return -11979 { -11980 (is-mu-addr-type? %esi) # => eax -11981 3d/compare-eax-and 0/imm32/false +11827 # return null +11828 b8/copy-to-eax 0/imm32 +11829 $has-primitive-name?:end: +11830 # . restore registers +11831 5e/pop-to-esi +11832 59/pop-to-ecx +11833 # . epilogue +11834 89/<- %esp 5/r32/ebp +11835 5d/pop-to-ebp +11836 c3/return +11837 +11838 check-mu-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11839 # . prologue +11840 55/push-ebp +11841 89/<- %ebp 4/r32/esp +11842 # . save registers +11843 50/push-eax +11844 51/push-ecx +11845 # var op/ecx: (addr array byte) = lookup(stmt->operation) +11846 8b/-> *(ebp+8) 0/r32/eax +11847 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +11848 89/<- %ecx 0/r32/eax +11849 # if (op == "copy") check-mu-copy-stmt +11850 { +11851 (string-equal? %ecx "copy") # => eax +11852 3d/compare-eax-and 0/imm32/false +11853 74/jump-if-= break/disp8 +11854 (check-mu-copy-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11855 e9/jump $check-mu-primitive:end/disp32 +11856 } +11857 # if (op == "copy-to") check-mu-copy-to-stmt +11858 { +11859 (string-equal? %ecx "copy-to") # => eax +11860 3d/compare-eax-and 0/imm32/false +11861 74/jump-if-= break/disp8 +11862 (check-mu-copy-to-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11863 e9/jump $check-mu-primitive:end/disp32 +11864 } +11865 # if (op == "compare") check-mu-compare-stmt +11866 { +11867 (string-equal? %ecx "compare") # => eax +11868 3d/compare-eax-and 0/imm32/false +11869 74/jump-if-= break/disp8 +11870 (check-mu-compare-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11871 e9/jump $check-mu-primitive:end/disp32 +11872 } +11873 # if (op == "address") check-mu-address-stmt +11874 { +11875 (string-equal? %ecx "address") # => eax +11876 3d/compare-eax-and 0/imm32/false +11877 74/jump-if-= break/disp8 +11878 (check-mu-address-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11879 e9/jump $check-mu-primitive:end/disp32 +11880 } +11881 # if (op == "get") check-mu-get-stmt +11882 { +11883 (string-equal? %ecx "get") # => eax +11884 3d/compare-eax-and 0/imm32/false +11885 74/jump-if-= break/disp8 +11886 (check-mu-get-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11887 e9/jump $check-mu-primitive:end/disp32 +11888 } +11889 # if (op == "index") check-mu-index-stmt +11890 { +11891 (string-equal? %ecx "index") # => eax +11892 3d/compare-eax-and 0/imm32/false +11893 74/jump-if-= break/disp8 +11894 (check-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11895 e9/jump $check-mu-primitive:end/disp32 +11896 } +11897 # if (op == "length") check-mu-length-stmt +11898 { +11899 (string-equal? %ecx "length") # => eax +11900 3d/compare-eax-and 0/imm32/false +11901 74/jump-if-= break/disp8 +11902 (check-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11903 e9/jump $check-mu-primitive:end/disp32 +11904 } +11905 # if (op == "compute-offset") check-mu-compute-offset-stmt +11906 { +11907 (string-equal? %ecx "compute-offset") # => eax +11908 3d/compare-eax-and 0/imm32/false +11909 74/jump-if-= break/disp8 +11910 (check-mu-compute-offset-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11911 e9/jump $check-mu-primitive:end/disp32 +11912 } +11913 # if (op == "allocate") check-mu-allocate-stmt +11914 { +11915 (string-equal? %ecx "allocate") # => eax +11916 3d/compare-eax-and 0/imm32/false +11917 74/jump-if-= break/disp8 +11918 (check-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11919 e9/jump $check-mu-primitive:end/disp32 +11920 } +11921 # if (op == "populate") check-mu-populate-stmt +11922 { +11923 (string-equal? %ecx "populate") # => eax +11924 3d/compare-eax-and 0/imm32/false +11925 74/jump-if-= break/disp8 +11926 (check-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11927 e9/jump $check-mu-primitive:end/disp32 +11928 } +11929 # if (op == "populate-stream") check-mu-populate-stream-stmt +11930 { +11931 (string-equal? %ecx "populate-stream") # => eax +11932 3d/compare-eax-and 0/imm32/false +11933 74/jump-if-= break/disp8 +11934 (check-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11935 e9/jump $check-mu-primitive:end/disp32 +11936 } +11937 # if (op == "read-from-stream") check-mu-read-from-stream-stmt +11938 { +11939 (string-equal? %ecx "read-from-stream") # => eax +11940 3d/compare-eax-and 0/imm32/false +11941 74/jump-if-= break/disp8 +11942 (check-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11943 e9/jump $check-mu-primitive:end/disp32 +11944 } +11945 # if (op == "write-to-stream") check-mu-write-to-stream-stmt +11946 { +11947 (string-equal? %ecx "write-to-stream") # => eax +11948 3d/compare-eax-and 0/imm32/false +11949 74/jump-if-= break/disp8 +11950 (check-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11951 e9/jump $check-mu-primitive:end/disp32 +11952 } +11953 # otherwise check-numberlike-stmt +11954 (check-mu-numberlike-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11955 $check-mu-primitive:end: +11956 # . restore registers +11957 59/pop-to-ecx +11958 58/pop-to-eax +11959 # . epilogue +11960 89/<- %esp 5/r32/ebp +11961 5d/pop-to-ebp +11962 c3/return +11963 +11964 # by default, Mu primitives should only operate on 'number-like' types +11965 check-mu-numberlike-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +11966 # . prologue +11967 55/push-ebp +11968 89/<- %ebp 4/r32/esp +11969 # . save registers +11970 50/push-eax +11971 51/push-ecx +11972 56/push-esi +11973 # esi = stmt +11974 8b/-> *(ebp+8) 6/r32/esi +11975 # var gas/ecx: int = 2 +11976 b9/copy-to-ecx 2/imm32 +11977 # - check at most 1 output +11978 # var output/eax: (addr stmt-var) = stmt->outputs +11979 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +11980 { +11981 3d/compare-eax-and 0/imm32 11982 74/jump-if-= break/disp8 -11983 8b/-> *(ebp+8) 0/r32/eax -11984 8b/-> *(eax+0x10) 0/r32/eax -11985 3d/compare-eax-and 0/imm32/false -11986 75/jump-if-!= $check-mu-numberlike-arg:end/disp8 -11987 } -11988 $check-mu-numberlike-arg:output-checks: -11989 (check-mu-numberlike-output *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18)) -11990 $check-mu-numberlike-arg:end: -11991 # . restore registers -11992 5e/pop-to-esi -11993 58/pop-to-eax -11994 # . epilogue -11995 89/<- %esp 5/r32/ebp -11996 5d/pop-to-ebp -11997 c3/return -11998 -11999 check-mu-numberlike-output: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12000 # . prologue -12001 55/push-ebp -12002 89/<- %ebp 4/r32/esp -12003 # . save registers -12004 50/push-eax -12005 56/push-esi -12006 # var t/esi: (addr type-tree) = lookup(v->value->type) -12007 8b/-> *(ebp+8) 0/r32/eax -12008 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12009 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12010 89/<- %esi 0/r32/eax -12011 $check-mu-numberlike-output:check-int: -12012 # if t is an int, return -12013 (is-simple-mu-type? %esi 1) # int => eax -12014 3d/compare-eax-and 0/imm32/false -12015 75/jump-if-!= $check-mu-numberlike-output:end/disp8 -12016 $check-mu-numberlike-output:check-boolean: -12017 # if t is a boolean, return -12018 (is-simple-mu-type? %esi 5) # boolean => eax -12019 3d/compare-eax-and 0/imm32/false -12020 75/jump-if-!= $check-mu-numberlike-output:end/disp8 -12021 $check-mu-numberlike-output:check-byte: -12022 # if t is a byte, return -12023 (is-simple-mu-type? %esi 8) # byte => eax -12024 3d/compare-eax-and 0/imm32/false -12025 75/jump-if-!= $check-mu-numberlike-output:end/disp8 -12026 e9/jump $check-mu-numberlike-output:fail/disp32 -12027 $check-mu-numberlike-output:end: -12028 # . restore registers -12029 5e/pop-to-esi -12030 58/pop-to-eax -12031 # . epilogue -12032 89/<- %esp 5/r32/ebp -12033 5d/pop-to-ebp -12034 c3/return -12035 -12036 $check-mu-numberlike-output:fail: -12037 # otherwise raise an error -12038 (write-buffered *(ebp+0x14) "fn ") -12039 8b/-> *(ebp+0x10) 0/r32/eax -12040 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12041 (write-buffered *(ebp+0x14) %eax) -12042 (write-buffered *(ebp+0x14) ": stmt ") +11983 $check-mu-numberlike-primitive:output: +11984 (check-mu-numberlike-output %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11985 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +11986 3d/compare-eax-and 0/imm32 +11987 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-outputs/disp32 +11988 # check output is in a register +11989 # --gas +11990 49/decrement-ecx +11991 } +11992 # - check first inout +11993 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +11994 { +11995 3d/compare-eax-and 0/imm32 +11996 0f 84/jump-if-= $check-mu-numberlike-primitive:end/disp32 +11997 $check-mu-numberlike-primitive:first-inout: +11998 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +11999 # --gas +12000 49/decrement-ecx +12001 } +12002 # - check second inout +12003 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12004 { +12005 3d/compare-eax-and 0/imm32 +12006 74/jump-if-= $check-mu-numberlike-primitive:end/disp8 +12007 $check-mu-numberlike-primitive:second-inout: +12008 # is a second inout allowed? +12009 81 7/subop/compare %ecx 0/imm32 +12010 0f 84/jump-if-= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 +12011 $check-mu-numberlike-primitive:second-inout-permitted: +12012 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +12013 } +12014 $check-mu-numberlike-primitive:third-inout: +12015 # if there's a third arg, raise an error +12016 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next +12017 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 +12018 $check-mu-numberlike-primitive:end: +12019 # . restore registers +12020 5e/pop-to-esi +12021 59/pop-to-ecx +12022 58/pop-to-eax +12023 # . epilogue +12024 89/<- %esp 5/r32/ebp +12025 5d/pop-to-ebp +12026 c3/return +12027 +12028 $check-mu-numberlike-primitive:error-too-many-inouts: +12029 (write-buffered *(ebp+0x10) "fn ") +12030 8b/-> *(ebp+0xc) 0/r32/eax +12031 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12032 (write-buffered *(ebp+0x10) %eax) +12033 (write-buffered *(ebp+0x10) ": stmt ") +12034 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +12035 (write-buffered *(ebp+0x10) %eax) +12036 (write-buffered *(ebp+0x10) ": too many inouts; most primitives support at most two arguments, across inouts and outputs\n") +12037 (flush *(ebp+0x10)) +12038 (stop *(ebp+0x14) 1) +12039 # never gets here +12040 +12041 $check-mu-numberlike-primitive:error-too-many-outputs: +12042 (write-buffered *(ebp+0x10) "fn ") 12043 8b/-> *(ebp+0xc) 0/r32/eax -12044 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -12045 (write-buffered *(ebp+0x14) %eax) -12046 (write-buffered *(ebp+0x14) ": only non-addr scalar args permitted\n") -12047 (flush *(ebp+0x14)) -12048 (stop *(ebp+0x18) 1) -12049 # never gets here -12050 -12051 check-mu-copy-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12052 # . prologue -12053 55/push-ebp -12054 89/<- %ebp 4/r32/esp -12055 # . save registers -12056 $check-mu-copy-stmt:end: -12057 # . restore registers -12058 # . epilogue -12059 89/<- %esp 5/r32/ebp -12060 5d/pop-to-ebp -12061 c3/return -12062 -12063 check-mu-copy-to-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12064 # . prologue -12065 55/push-ebp -12066 89/<- %ebp 4/r32/esp -12067 # . save registers -12068 $check-mu-copy-to-stmt:end: -12069 # . restore registers -12070 # . epilogue -12071 89/<- %esp 5/r32/ebp -12072 5d/pop-to-ebp -12073 c3/return -12074 -12075 check-mu-compare-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12076 # . prologue -12077 55/push-ebp -12078 89/<- %ebp 4/r32/esp -12079 # . save registers -12080 $check-mu-compare-stmt:end: -12081 # . restore registers -12082 # . epilogue -12083 89/<- %esp 5/r32/ebp -12084 5d/pop-to-ebp -12085 c3/return -12086 -12087 check-mu-address-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12088 # . prologue -12089 55/push-ebp -12090 89/<- %ebp 4/r32/esp -12091 # . save registers -12092 $check-mu-address-stmt:end: -12093 # . restore registers -12094 # . epilogue -12095 89/<- %esp 5/r32/ebp -12096 5d/pop-to-ebp -12097 c3/return -12098 -12099 check-mu-get-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12100 # . prologue -12101 55/push-ebp -12102 89/<- %ebp 4/r32/esp -12103 # . save registers -12104 50/push-eax -12105 51/push-ecx -12106 52/push-edx -12107 53/push-ebx -12108 56/push-esi -12109 57/push-edi -12110 # esi = stmt -12111 8b/-> *(ebp+8) 6/r32/esi -12112 # - check for 0 inouts -12113 # var base/ecx: (addr var) = stmt->inouts->value -12114 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12115 3d/compare-eax-and 0/imm32/false -12116 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 -12117 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12118 89/<- %ecx 0/r32/eax -12119 $check-mu-get-stmt:check-base: -12120 # - check base type -12121 # if it's an 'addr', check that it's in a register -12122 # var base-type/ebx: (addr type-tree) = lookup(base->type) -12123 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -12124 89/<- %ebx 0/r32/eax -12125 { -12126 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -12127 0f 85/jump-if-!= break/disp32 -12128 $check-mu-get-stmt:base-is-compound: -12129 # if (type->left != addr) break -12130 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -12131 (is-simple-mu-type? %eax 2) # => eax -12132 3d/compare-eax-and 0/imm32/false -12133 74/jump-if-= break/disp8 -12134 $check-mu-get-stmt:base-is-addr: -12135 # now check for register -12136 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -12137 0f 84/jump-if-= $check-mu-get-stmt:error-base-type-addr-but-not-register/disp32 -12138 $check-mu-get-stmt:base-is-addr-in-register: -12139 # type->left is now an addr; skip it -12140 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -12141 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -12142 0f 85/jump-if-!= $check-mu-get-stmt:error-bad-base/disp32 -12143 $check-mu-get-stmt:base-is-addr-to-atom-in-register: -12144 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -12145 89/<- %ebx 0/r32/eax -12146 } -12147 $check-mu-get-stmt:check-base-typeinfo: -12148 # ensure type is a container -12149 # var base-type-id/ebx: type-id = base-type->value -12150 8b/-> *(ebx+4) 3/r32/ebx # Type-tree-value -12151 (is-container? %ebx) # => eax -12152 3d/compare-eax-and 0/imm32/false -12153 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32 -12154 # var base-typeinfo/edx: (addr typeinfo) = find-typeinfo(base-type-id) -12155 # . var container/ecx: (handle typeinfo) -12156 68/push 0/imm32 -12157 68/push 0/imm32 -12158 89/<- %ecx 4/r32/esp -12159 # . -12160 (find-typeinfo %ebx %ecx) -12161 (lookup *ecx *(ecx+4)) # => eax -12162 # . reclaim container -12163 81 0/subop/add %esp 8/imm32 -12164 # . -12165 89/<- %edx 0/r32/eax -12166 # var offset/ecx: (addr stmt-var) = stmt->inouts->next -12167 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12168 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12169 89/<- %ecx 0/r32/eax -12170 # - check for 1 inout -12171 3d/compare-eax-and 0/imm32/false -12172 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 -12173 # var offset/ecx: (addr var) = lookup(offset->value) -12174 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12175 89/<- %ecx 0/r32/eax -12176 # - check for valid field -12177 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized # Var-offset -12178 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32 -12179 # - check for too many inouts -12180 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12181 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12182 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12183 3d/compare-eax-and 0/imm32/false -12184 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32 -12185 # var output/edi: (addr var) = stmt->outputs->value -12186 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -12187 # - check for 0 outputs -12188 3d/compare-eax-and 0/imm32/false -12189 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32 -12190 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12191 89/<- %edi 0/r32/eax -12192 $check-mu-get-stmt:check-output-type: -12193 # - check output type -12194 # must be in register -12195 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -12196 3d/compare-eax-and 0/imm32 -12197 0f 84/jump-if-= $check-mu-get-stmt:error-output-not-in-register/disp32 -12198 # must have a non-atomic type -12199 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -12200 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -12201 0f 85/jump-if-!= $check-mu-get-stmt:error-output-type-not-address/disp32 -12202 # type must start with (addr ...) -12203 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -12204 (is-simple-mu-type? %eax 2) # => eax -12205 3d/compare-eax-and 0/imm32/false -12206 0f 84/jump-if-= $check-mu-get-stmt:error-output-type-not-address/disp32 -12207 $check-mu-get-stmt:check-output-type-match: -12208 # payload of addr type must match 'type' definition -12209 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -12210 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -12211 # if (payload->right == null) payload = payload->left -12212 81 7/subop/compare *(eax+0xc) 0/imm32/null # Type-tree-right -12213 { -12214 75/jump-if-!= break/disp8 -12215 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -12216 } -12217 89/<- %edi 0/r32/eax -12218 # . var output-name/ecx: (addr array byte) -12219 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -12220 89/<- %ecx 0/r32/eax -12221 # . var base-typeinfo-entry/eax: (addr handle typeinfo-entry) -12222 (lookup *(edx+4) *(edx+8)) # Typeinfo-fields Typeinfo-fields => eax -12223 (get %eax %ecx 0x10) # => eax -12224 # . -12225 (lookup *eax *(eax+4)) # => eax -12226 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -12227 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12228 # . -12229 (type-equal? %edi %eax) # => eax -12230 3d/compare-eax-and 0/imm32/false -12231 0f 84/jump-if-= $check-mu-get-stmt:error-bad-output-type/disp32 -12232 # - check for too many outputs -12233 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -12234 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12235 3d/compare-eax-and 0/imm32/false -12236 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32 -12237 $check-mu-get-stmt:end: -12238 # . restore registers -12239 5f/pop-to-edi -12240 5e/pop-to-esi -12241 5b/pop-to-ebx -12242 5a/pop-to-edx -12243 59/pop-to-ecx -12244 58/pop-to-eax -12245 # . epilogue -12246 89/<- %esp 5/r32/ebp -12247 5d/pop-to-ebp -12248 c3/return -12249 -12250 $check-mu-get-stmt:error-too-few-inouts: -12251 (write-buffered *(ebp+0x10) "fn ") -12252 8b/-> *(ebp+0xc) 0/r32/eax -12253 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12254 (write-buffered *(ebp+0x10) %eax) -12255 (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n") -12256 (flush *(ebp+0x10)) -12257 (stop *(ebp+0x14) 1) -12258 # never gets here -12259 -12260 $check-mu-get-stmt:error-too-many-inouts: -12261 (write-buffered *(ebp+0x10) "fn ") -12262 8b/-> *(ebp+0xc) 0/r32/eax -12263 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12264 (write-buffered *(ebp+0x10) %eax) -12265 (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n") -12266 (flush *(ebp+0x10)) -12267 (stop *(ebp+0x14) 1) -12268 # never gets here -12269 -12270 $check-mu-get-stmt:error-too-few-outputs: -12271 (write-buffered *(ebp+0x10) "fn ") -12272 8b/-> *(ebp+0xc) 0/r32/eax -12273 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12274 (write-buffered *(ebp+0x10) %eax) -12275 (write-buffered *(ebp+0x10) ": stmt get: must have an output\n") -12276 (flush *(ebp+0x10)) -12277 (stop *(ebp+0x14) 1) -12278 # never gets here -12279 -12280 $check-mu-get-stmt:error-too-many-outputs: -12281 (write-buffered *(ebp+0x10) "fn ") -12282 8b/-> *(ebp+0xc) 0/r32/eax -12283 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12284 (write-buffered *(ebp+0x10) %eax) -12285 (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n") -12286 (flush *(ebp+0x10)) -12287 (stop *(ebp+0x14) 1) -12288 # never gets here -12289 -12290 $check-mu-get-stmt:error-bad-base: -12291 # error("fn " fn ": stmt get: var '" base->name "' must have a 'type' definition\n") -12292 (write-buffered *(ebp+0x10) "fn ") -12293 8b/-> *(ebp+0xc) 0/r32/eax -12294 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12295 (write-buffered *(ebp+0x10) %eax) -12296 (write-buffered *(ebp+0x10) ": stmt get: var '") -12297 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12298 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12299 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12300 (write-buffered *(ebp+0x10) %eax) -12301 (write-buffered *(ebp+0x10) "' must have a 'type' definition\n") -12302 (flush *(ebp+0x10)) -12303 (stop *(ebp+0x14) 1) -12304 # never gets here -12305 -12306 $check-mu-get-stmt:error-base-type-addr-but-not-register: -12307 (write-buffered *(ebp+0x10) "fn ") -12308 8b/-> *(ebp+0xc) 0/r32/eax -12309 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12310 (write-buffered *(ebp+0x10) %eax) -12311 (write-buffered *(ebp+0x10) ": stmt get: var '") -12312 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12313 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12314 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12315 (write-buffered *(ebp+0x10) %eax) -12316 (write-buffered *(ebp+0x10) "' is an 'addr' type, and so must live in a register\n") -12317 (flush *(ebp+0x10)) -12318 (stop *(ebp+0x14) 1) -12319 # never gets here -12320 -12321 $check-mu-get-stmt:error-bad-field: -12322 # error("fn " fn ": stmt get: type " type " has no member called '" curr->name "'\n") -12323 (write-buffered *(ebp+0x10) "fn ") -12324 8b/-> *(ebp+0xc) 0/r32/eax -12325 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12326 (write-buffered *(ebp+0x10) %eax) -12327 (write-buffered *(ebp+0x10) ": stmt get: type '") -12328 # . write(Type-id->data[tmp]) -12329 bf/copy-to-edi Type-id/imm32 -12330 (write-buffered *(ebp+0x10) *(edi+ebx<<2+0xc)) -12331 # . -12332 (write-buffered *(ebp+0x10) "' has no member called '") -12333 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -12334 (write-buffered *(ebp+0x10) %eax) -12335 (write-buffered *(ebp+0x10) "'\n") -12336 (flush *(ebp+0x10)) -12337 (stop *(ebp+0x14) 1) -12338 # never gets here -12339 -12340 $check-mu-get-stmt:error-output-not-in-register: -12341 (write-buffered *(ebp+0x10) "fn ") -12342 8b/-> *(ebp+0xc) 0/r32/eax -12343 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12344 (write-buffered *(ebp+0x10) %eax) -12345 (write-buffered *(ebp+0x10) ": stmt get: output '") -12346 (lookup *edi *(edi+4)) # Var-name Var-name => eax -12347 (write-buffered *(ebp+0x10) %eax) -12348 (write-buffered *(ebp+0x10) "' is not in a register\n") -12349 (flush *(ebp+0x10)) -12350 (stop *(ebp+0x14) 1) -12351 # never gets here -12352 -12353 $check-mu-get-stmt:error-output-type-not-address: -12354 (write-buffered *(ebp+0x10) "fn ") -12355 8b/-> *(ebp+0xc) 0/r32/eax -12356 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12357 (write-buffered *(ebp+0x10) %eax) -12358 (write-buffered *(ebp+0x10) ": stmt get: output must be an address\n") -12359 (flush *(ebp+0x10)) -12360 (stop *(ebp+0x14) 1) -12361 # never gets here -12362 -12363 $check-mu-get-stmt:error-bad-output-type: -12364 (write-buffered *(ebp+0x10) "fn ") -12365 8b/-> *(ebp+0xc) 0/r32/eax -12366 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12367 (write-buffered *(ebp+0x10) %eax) -12368 (write-buffered *(ebp+0x10) ": stmt get: wrong output type for member '") -12369 (write-buffered *(ebp+0x10) %ecx) -12370 (write-buffered *(ebp+0x10) "' of type '") -12371 bf/copy-to-edi Type-id/imm32 -12372 (write-buffered *(ebp+0x10) *(edi+ebx<<2+0xc)) -12373 (write-buffered *(ebp+0x10) "'\n") -12374 (flush *(ebp+0x10)) -12375 (stop *(ebp+0x14) 1) -12376 # never gets here -12377 -12378 check-mu-index-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12379 # . prologue -12380 55/push-ebp -12381 89/<- %ebp 4/r32/esp -12382 # . save registers -12383 $check-mu-index-stmt:end: -12384 # . restore registers -12385 # . epilogue -12386 89/<- %esp 5/r32/ebp -12387 5d/pop-to-ebp -12388 c3/return -12389 -12390 check-mu-length-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12391 # . prologue -12392 55/push-ebp -12393 89/<- %ebp 4/r32/esp -12394 # . save registers -12395 $check-mu-length-stmt:end: -12396 # . restore registers -12397 # . epilogue -12398 89/<- %esp 5/r32/ebp -12399 5d/pop-to-ebp -12400 c3/return -12401 -12402 check-mu-compute-offset-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12403 # . prologue -12404 55/push-ebp -12405 89/<- %ebp 4/r32/esp -12406 # . save registers -12407 $check-mu-compute-offset-stmt:end: -12408 # . restore registers -12409 # . epilogue -12410 89/<- %esp 5/r32/ebp -12411 5d/pop-to-ebp -12412 c3/return -12413 -12414 check-mu-allocate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12415 # . prologue -12416 55/push-ebp -12417 89/<- %ebp 4/r32/esp -12418 # . save registers -12419 $check-mu-allocate-stmt:end: -12420 # . restore registers -12421 # . epilogue -12422 89/<- %esp 5/r32/ebp -12423 5d/pop-to-ebp -12424 c3/return -12425 -12426 check-mu-populate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12427 # . prologue -12428 55/push-ebp -12429 89/<- %ebp 4/r32/esp -12430 # . save registers -12431 $check-mu-populate-stmt:end: -12432 # . restore registers -12433 # . epilogue -12434 89/<- %esp 5/r32/ebp -12435 5d/pop-to-ebp -12436 c3/return -12437 -12438 check-mu-populate-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12439 # . prologue -12440 55/push-ebp -12441 89/<- %ebp 4/r32/esp -12442 # . save registers -12443 $check-mu-populate-stream-stmt:end: -12444 # . restore registers -12445 # . epilogue -12446 89/<- %esp 5/r32/ebp -12447 5d/pop-to-ebp -12448 c3/return -12449 -12450 check-mu-read-from-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12451 # . prologue -12452 55/push-ebp -12453 89/<- %ebp 4/r32/esp -12454 # . save registers -12455 $check-mu-read-from-stream-stmt:end: -12456 # . restore registers -12457 # . epilogue -12458 89/<- %esp 5/r32/ebp -12459 5d/pop-to-ebp -12460 c3/return -12461 -12462 check-mu-write-to-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12463 # . prologue -12464 55/push-ebp -12465 89/<- %ebp 4/r32/esp -12466 # . save registers -12467 $check-mu-write-to-stream-stmt:end: -12468 # . restore registers -12469 # . epilogue -12470 89/<- %esp 5/r32/ebp -12471 5d/pop-to-ebp -12472 c3/return -12473 -12474 check-mu-call: # stmt: (addr stmt), callee: (addr function), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -12475 # . prologue -12476 55/push-ebp -12477 89/<- %ebp 4/r32/esp -12478 # var type-parameters: (addr table (handle array byte) (addr type-tree) 8) -12479 68/push 0/imm32 -12480 # var type-parameters-storage: (table (handle array byte) (addr type-tree) 8) -12481 81 5/subop/subtract %esp 0x60/imm32 -12482 68/push 0x60/imm32/size -12483 68/push 0/imm32/read -12484 68/push 0/imm32/write -12485 # save a pointer to type-parameters-storage at type-parameters -12486 89/<- *(ebp-4) 4/r32/esp -12487 (clear-stream *(ebp-4)) +12044 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12045 (write-buffered *(ebp+0x10) %eax) +12046 (write-buffered *(ebp+0x10) ": stmt ") +12047 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +12048 (write-buffered *(ebp+0x10) %eax) +12049 (write-buffered *(ebp+0x10) ": too many outputs; most primitives support at most one output\n") +12050 (flush *(ebp+0x10)) +12051 (stop *(ebp+0x14) 1) +12052 # never gets here +12053 +12054 check-mu-numberlike-arg: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12055 # . prologue +12056 55/push-ebp +12057 89/<- %ebp 4/r32/esp +12058 # . save registers +12059 50/push-eax +12060 56/push-esi +12061 # var t/esi: (addr type-tree) = lookup(v->value->type) +12062 8b/-> *(ebp+8) 0/r32/eax +12063 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12064 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12065 89/<- %esi 0/r32/eax +12066 $check-mu-numberlike-arg:check-literal: +12067 # if t is an int, return +12068 (is-simple-mu-type? %esi 0) # literal => eax +12069 3d/compare-eax-and 0/imm32/false +12070 75/jump-if-!= $check-mu-numberlike-arg:end/disp8 +12071 $check-mu-numberlike-arg:check-addr: +12072 # if t is an addr and v is dereferenced, return +12073 { +12074 (is-mu-addr-type? %esi) # => eax +12075 3d/compare-eax-and 0/imm32/false +12076 74/jump-if-= break/disp8 +12077 8b/-> *(ebp+8) 0/r32/eax +12078 8b/-> *(eax+0x10) 0/r32/eax +12079 3d/compare-eax-and 0/imm32/false +12080 75/jump-if-!= $check-mu-numberlike-arg:end/disp8 +12081 } +12082 $check-mu-numberlike-arg:output-checks: +12083 (check-mu-numberlike-output *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18)) +12084 $check-mu-numberlike-arg:end: +12085 # . restore registers +12086 5e/pop-to-esi +12087 58/pop-to-eax +12088 # . epilogue +12089 89/<- %esp 5/r32/ebp +12090 5d/pop-to-ebp +12091 c3/return +12092 +12093 check-mu-numberlike-output: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12094 # . prologue +12095 55/push-ebp +12096 89/<- %ebp 4/r32/esp +12097 # . save registers +12098 50/push-eax +12099 56/push-esi +12100 # var t/esi: (addr type-tree) = lookup(v->value->type) +12101 8b/-> *(ebp+8) 0/r32/eax +12102 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12103 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12104 89/<- %esi 0/r32/eax +12105 $check-mu-numberlike-output:check-int: +12106 # if t is an int, return +12107 (is-simple-mu-type? %esi 1) # int => eax +12108 3d/compare-eax-and 0/imm32/false +12109 75/jump-if-!= $check-mu-numberlike-output:end/disp8 +12110 $check-mu-numberlike-output:check-boolean: +12111 # if t is a boolean, return +12112 (is-simple-mu-type? %esi 5) # boolean => eax +12113 3d/compare-eax-and 0/imm32/false +12114 75/jump-if-!= $check-mu-numberlike-output:end/disp8 +12115 $check-mu-numberlike-output:check-byte: +12116 # if t is a byte, return +12117 (is-simple-mu-type? %esi 8) # byte => eax +12118 3d/compare-eax-and 0/imm32/false +12119 75/jump-if-!= $check-mu-numberlike-output:end/disp8 +12120 e9/jump $check-mu-numberlike-output:fail/disp32 +12121 $check-mu-numberlike-output:end: +12122 # . restore registers +12123 5e/pop-to-esi +12124 58/pop-to-eax +12125 # . epilogue +12126 89/<- %esp 5/r32/ebp +12127 5d/pop-to-ebp +12128 c3/return +12129 +12130 $check-mu-numberlike-output:fail: +12131 # otherwise raise an error +12132 (write-buffered *(ebp+0x14) "fn ") +12133 8b/-> *(ebp+0x10) 0/r32/eax +12134 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12135 (write-buffered *(ebp+0x14) %eax) +12136 (write-buffered *(ebp+0x14) ": stmt ") +12137 8b/-> *(ebp+0xc) 0/r32/eax +12138 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +12139 (write-buffered *(ebp+0x14) %eax) +12140 (write-buffered *(ebp+0x14) ": only non-addr scalar args permitted\n") +12141 (flush *(ebp+0x14)) +12142 (stop *(ebp+0x18) 1) +12143 # never gets here +12144 +12145 check-mu-copy-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12146 # . prologue +12147 55/push-ebp +12148 89/<- %ebp 4/r32/esp +12149 # . save registers +12150 $check-mu-copy-stmt:end: +12151 # . restore registers +12152 # . epilogue +12153 89/<- %esp 5/r32/ebp +12154 5d/pop-to-ebp +12155 c3/return +12156 +12157 check-mu-copy-to-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12158 # . prologue +12159 55/push-ebp +12160 89/<- %ebp 4/r32/esp +12161 # . save registers +12162 $check-mu-copy-to-stmt:end: +12163 # . restore registers +12164 # . epilogue +12165 89/<- %esp 5/r32/ebp +12166 5d/pop-to-ebp +12167 c3/return +12168 +12169 check-mu-compare-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12170 # . prologue +12171 55/push-ebp +12172 89/<- %ebp 4/r32/esp +12173 # . save registers +12174 $check-mu-compare-stmt:end: +12175 # . restore registers +12176 # . epilogue +12177 89/<- %esp 5/r32/ebp +12178 5d/pop-to-ebp +12179 c3/return +12180 +12181 check-mu-address-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12182 # . prologue +12183 55/push-ebp +12184 89/<- %ebp 4/r32/esp +12185 # . save registers +12186 $check-mu-address-stmt:end: +12187 # . restore registers +12188 # . epilogue +12189 89/<- %esp 5/r32/ebp +12190 5d/pop-to-ebp +12191 c3/return +12192 +12193 check-mu-get-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12194 # . prologue +12195 55/push-ebp +12196 89/<- %ebp 4/r32/esp +12197 # . save registers +12198 50/push-eax +12199 51/push-ecx +12200 52/push-edx +12201 53/push-ebx +12202 56/push-esi +12203 57/push-edi +12204 # esi = stmt +12205 8b/-> *(ebp+8) 6/r32/esi +12206 # - check for 0 inouts +12207 # var base/ecx: (addr var) = stmt->inouts->value +12208 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12209 3d/compare-eax-and 0/imm32/false +12210 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 +12211 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12212 89/<- %ecx 0/r32/eax +12213 $check-mu-get-stmt:check-base: +12214 # - check base type +12215 # if it's an 'addr', check that it's in a register +12216 # var base-type/ebx: (addr type-tree) = lookup(base->type) +12217 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +12218 89/<- %ebx 0/r32/eax +12219 { +12220 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +12221 0f 85/jump-if-!= break/disp32 +12222 $check-mu-get-stmt:base-is-compound: +12223 # if (type->left != addr) break +12224 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +12225 (is-simple-mu-type? %eax 2) # => eax +12226 3d/compare-eax-and 0/imm32/false +12227 74/jump-if-= break/disp8 +12228 $check-mu-get-stmt:base-is-addr: +12229 # now check for register +12230 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +12231 0f 84/jump-if-= $check-mu-get-stmt:error-base-type-addr-but-not-register/disp32 +12232 $check-mu-get-stmt:base-is-addr-in-register: +12233 # type->left is now an addr; skip it +12234 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +12235 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +12236 0f 85/jump-if-!= $check-mu-get-stmt:error-bad-base/disp32 +12237 $check-mu-get-stmt:base-is-addr-to-atom-in-register: +12238 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +12239 89/<- %ebx 0/r32/eax +12240 } +12241 $check-mu-get-stmt:check-base-typeinfo: +12242 # ensure type is a container +12243 # var base-type-id/ebx: type-id = base-type->value +12244 8b/-> *(ebx+4) 3/r32/ebx # Type-tree-value +12245 (is-container? %ebx) # => eax +12246 3d/compare-eax-and 0/imm32/false +12247 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32 +12248 # var base-typeinfo/edx: (addr typeinfo) = find-typeinfo(base-type-id) +12249 # . var container/ecx: (handle typeinfo) +12250 68/push 0/imm32 +12251 68/push 0/imm32 +12252 89/<- %ecx 4/r32/esp +12253 # . +12254 (find-typeinfo %ebx %ecx) +12255 (lookup *ecx *(ecx+4)) # => eax +12256 # . reclaim container +12257 81 0/subop/add %esp 8/imm32 +12258 # . +12259 89/<- %edx 0/r32/eax +12260 # var offset/ecx: (addr stmt-var) = stmt->inouts->next +12261 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12262 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12263 89/<- %ecx 0/r32/eax +12264 # - check for 1 inout +12265 3d/compare-eax-and 0/imm32/false +12266 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 +12267 # var offset/ecx: (addr var) = lookup(offset->value) +12268 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12269 89/<- %ecx 0/r32/eax +12270 # - check for valid field +12271 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized # Var-offset +12272 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32 +12273 # - check for too many inouts +12274 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12275 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12276 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12277 3d/compare-eax-and 0/imm32/false +12278 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32 +12279 # var output/edi: (addr var) = stmt->outputs->value +12280 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +12281 # - check for 0 outputs +12282 3d/compare-eax-and 0/imm32/false +12283 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32 +12284 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12285 89/<- %edi 0/r32/eax +12286 $check-mu-get-stmt:check-output-type: +12287 # - check output type +12288 # must be in register +12289 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +12290 3d/compare-eax-and 0/imm32 +12291 0f 84/jump-if-= $check-mu-get-stmt:error-output-not-in-register/disp32 +12292 # must have a non-atomic type +12293 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +12294 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +12295 0f 85/jump-if-!= $check-mu-get-stmt:error-output-type-not-address/disp32 +12296 # type must start with (addr ...) +12297 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +12298 (is-simple-mu-type? %eax 2) # => eax +12299 3d/compare-eax-and 0/imm32/false +12300 0f 84/jump-if-= $check-mu-get-stmt:error-output-type-not-address/disp32 +12301 $check-mu-get-stmt:check-output-type-match: +12302 # payload of addr type must match 'type' definition +12303 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +12304 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +12305 # if (payload->right == null) payload = payload->left +12306 81 7/subop/compare *(eax+0xc) 0/imm32/null # Type-tree-right +12307 { +12308 75/jump-if-!= break/disp8 +12309 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +12310 } +12311 89/<- %edi 0/r32/eax +12312 # . var output-name/ecx: (addr array byte) +12313 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +12314 89/<- %ecx 0/r32/eax +12315 # . var base-typeinfo-entry/eax: (addr handle typeinfo-entry) +12316 (lookup *(edx+4) *(edx+8)) # Typeinfo-fields Typeinfo-fields => eax +12317 (get %eax %ecx 0x10) # => eax +12318 # . +12319 (lookup *eax *(eax+4)) # => eax +12320 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +12321 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12322 # . +12323 (type-equal? %edi %eax) # => eax +12324 3d/compare-eax-and 0/imm32/false +12325 0f 84/jump-if-= $check-mu-get-stmt:error-bad-output-type/disp32 +12326 # - check for too many outputs +12327 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +12328 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12329 3d/compare-eax-and 0/imm32/false +12330 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32 +12331 $check-mu-get-stmt:end: +12332 # . restore registers +12333 5f/pop-to-edi +12334 5e/pop-to-esi +12335 5b/pop-to-ebx +12336 5a/pop-to-edx +12337 59/pop-to-ecx +12338 58/pop-to-eax +12339 # . epilogue +12340 89/<- %esp 5/r32/ebp +12341 5d/pop-to-ebp +12342 c3/return +12343 +12344 $check-mu-get-stmt:error-too-few-inouts: +12345 (write-buffered *(ebp+0x10) "fn ") +12346 8b/-> *(ebp+0xc) 0/r32/eax +12347 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12348 (write-buffered *(ebp+0x10) %eax) +12349 (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n") +12350 (flush *(ebp+0x10)) +12351 (stop *(ebp+0x14) 1) +12352 # never gets here +12353 +12354 $check-mu-get-stmt:error-too-many-inouts: +12355 (write-buffered *(ebp+0x10) "fn ") +12356 8b/-> *(ebp+0xc) 0/r32/eax +12357 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12358 (write-buffered *(ebp+0x10) %eax) +12359 (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n") +12360 (flush *(ebp+0x10)) +12361 (stop *(ebp+0x14) 1) +12362 # never gets here +12363 +12364 $check-mu-get-stmt:error-too-few-outputs: +12365 (write-buffered *(ebp+0x10) "fn ") +12366 8b/-> *(ebp+0xc) 0/r32/eax +12367 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12368 (write-buffered *(ebp+0x10) %eax) +12369 (write-buffered *(ebp+0x10) ": stmt get: must have an output\n") +12370 (flush *(ebp+0x10)) +12371 (stop *(ebp+0x14) 1) +12372 # never gets here +12373 +12374 $check-mu-get-stmt:error-too-many-outputs: +12375 (write-buffered *(ebp+0x10) "fn ") +12376 8b/-> *(ebp+0xc) 0/r32/eax +12377 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12378 (write-buffered *(ebp+0x10) %eax) +12379 (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n") +12380 (flush *(ebp+0x10)) +12381 (stop *(ebp+0x14) 1) +12382 # never gets here +12383 +12384 $check-mu-get-stmt:error-bad-base: +12385 # error("fn " fn ": stmt get: var '" base->name "' must have a 'type' definition\n") +12386 (write-buffered *(ebp+0x10) "fn ") +12387 8b/-> *(ebp+0xc) 0/r32/eax +12388 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12389 (write-buffered *(ebp+0x10) %eax) +12390 (write-buffered *(ebp+0x10) ": stmt get: var '") +12391 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12392 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12393 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12394 (write-buffered *(ebp+0x10) %eax) +12395 (write-buffered *(ebp+0x10) "' must have a 'type' definition\n") +12396 (flush *(ebp+0x10)) +12397 (stop *(ebp+0x14) 1) +12398 # never gets here +12399 +12400 $check-mu-get-stmt:error-base-type-addr-but-not-register: +12401 (write-buffered *(ebp+0x10) "fn ") +12402 8b/-> *(ebp+0xc) 0/r32/eax +12403 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12404 (write-buffered *(ebp+0x10) %eax) +12405 (write-buffered *(ebp+0x10) ": stmt get: var '") +12406 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12407 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12408 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12409 (write-buffered *(ebp+0x10) %eax) +12410 (write-buffered *(ebp+0x10) "' is an 'addr' type, and so must live in a register\n") +12411 (flush *(ebp+0x10)) +12412 (stop *(ebp+0x14) 1) +12413 # never gets here +12414 +12415 $check-mu-get-stmt:error-bad-field: +12416 # error("fn " fn ": stmt get: type " type " has no member called '" curr->name "'\n") +12417 (write-buffered *(ebp+0x10) "fn ") +12418 8b/-> *(ebp+0xc) 0/r32/eax +12419 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12420 (write-buffered *(ebp+0x10) %eax) +12421 (write-buffered *(ebp+0x10) ": stmt get: type '") +12422 # . write(Type-id->data[tmp]) +12423 bf/copy-to-edi Type-id/imm32 +12424 (write-buffered *(ebp+0x10) *(edi+ebx<<2+0xc)) +12425 # . +12426 (write-buffered *(ebp+0x10) "' has no member called '") +12427 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +12428 (write-buffered *(ebp+0x10) %eax) +12429 (write-buffered *(ebp+0x10) "'\n") +12430 (flush *(ebp+0x10)) +12431 (stop *(ebp+0x14) 1) +12432 # never gets here +12433 +12434 $check-mu-get-stmt:error-output-not-in-register: +12435 (write-buffered *(ebp+0x10) "fn ") +12436 8b/-> *(ebp+0xc) 0/r32/eax +12437 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12438 (write-buffered *(ebp+0x10) %eax) +12439 (write-buffered *(ebp+0x10) ": stmt get: output '") +12440 (lookup *edi *(edi+4)) # Var-name Var-name => eax +12441 (write-buffered *(ebp+0x10) %eax) +12442 (write-buffered *(ebp+0x10) "' is not in a register\n") +12443 (flush *(ebp+0x10)) +12444 (stop *(ebp+0x14) 1) +12445 # never gets here +12446 +12447 $check-mu-get-stmt:error-output-type-not-address: +12448 (write-buffered *(ebp+0x10) "fn ") +12449 8b/-> *(ebp+0xc) 0/r32/eax +12450 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12451 (write-buffered *(ebp+0x10) %eax) +12452 (write-buffered *(ebp+0x10) ": stmt get: output must be an address\n") +12453 (flush *(ebp+0x10)) +12454 (stop *(ebp+0x14) 1) +12455 # never gets here +12456 +12457 $check-mu-get-stmt:error-bad-output-type: +12458 (write-buffered *(ebp+0x10) "fn ") +12459 8b/-> *(ebp+0xc) 0/r32/eax +12460 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12461 (write-buffered *(ebp+0x10) %eax) +12462 (write-buffered *(ebp+0x10) ": stmt get: wrong output type for member '") +12463 (write-buffered *(ebp+0x10) %ecx) +12464 (write-buffered *(ebp+0x10) "' of type '") +12465 bf/copy-to-edi Type-id/imm32 +12466 (write-buffered *(ebp+0x10) *(edi+ebx<<2+0xc)) +12467 (write-buffered *(ebp+0x10) "'\n") +12468 (flush *(ebp+0x10)) +12469 (stop *(ebp+0x14) 1) +12470 # never gets here +12471 +12472 check-mu-index-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12473 # . prologue +12474 55/push-ebp +12475 89/<- %ebp 4/r32/esp +12476 # . save registers +12477 $check-mu-index-stmt:end: +12478 # . restore registers +12479 # . epilogue +12480 89/<- %esp 5/r32/ebp +12481 5d/pop-to-ebp +12482 c3/return +12483 +12484 check-mu-length-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12485 # . prologue +12486 55/push-ebp +12487 89/<- %ebp 4/r32/esp 12488 # . save registers -12489 50/push-eax -12490 51/push-ecx -12491 52/push-edx -12492 53/push-ebx -12493 56/push-esi -12494 57/push-edi -12495 # esi = stmt -12496 8b/-> *(ebp+8) 6/r32/esi -12497 # edi = callee -12498 8b/-> *(ebp+0xc) 7/r32/edi -12499 # var inouts/ecx: (addr stmt-var) = lookup(stmt->inouts) -12500 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12501 89/<- %ecx 0/r32/eax -12502 # var expected/edx: (addr list var) = lookup(f->inouts) -12503 (lookup *(edi+8) *(edi+0xc)) # Function-inouts Function-inouts => eax -12504 89/<- %edx 0/r32/eax -12505 { -12506 $check-mu-call:check-for-inouts: -12507 # if (inouts == 0) break -12508 81 7/subop/compare %ecx 0/imm32 -12509 0f 84/jump-if-= break/disp32 -12510 # if (expected == 0) error -12511 81 7/subop/compare %edx 0/imm32 -12512 0f 84/jump-if-= break/disp32 -12513 $check-mu-call:check-inout-type: -12514 # var v/eax: (addr v) = lookup(inouts->value) -12515 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12516 # var t/ebx: (addr type-tree) = lookup(v->type) -12517 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12518 89/<- %ebx 0/r32/eax -12519 # if (inouts->is-deref?) t = t->right # TODO: check that t->left is an addr -12520 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -12521 { -12522 74/jump-if-= break/disp8 -12523 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -12524 89/<- %ebx 0/r32/eax -12525 # if t->right is null, t = t->left -12526 81 7/subop/compare *(ebx+0xc) 0/imm32 # Type-tree-right -12527 75/jump-if-!= break/disp8 -12528 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -12529 89/<- %ebx 0/r32/eax -12530 } -12531 # var v2/eax: (addr v) = lookup(expected->value) -12532 (lookup *edx *(edx+4)) # List-value List-value => eax -12533 # var t2/eax: (addr type-tree) = lookup(v2->type) -12534 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12535 # if (t != t2) error -12536 (type-match? %eax %ebx *(ebp-4)) # => eax -12537 3d/compare-eax-and 0/imm32/false -12538 { -12539 0f 85/jump-if-!= break/disp32 -12540 (write-buffered *(ebp+0x14) "fn ") -12541 8b/-> *(ebp+0x10) 0/r32/eax -12542 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12543 (write-buffered *(ebp+0x14) %eax) -12544 (write-buffered *(ebp+0x14) ": call ") -12545 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12546 (write-buffered *(ebp+0x14) %eax) -12547 (write-buffered *(ebp+0x14) ": type for inout '") -12548 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12549 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12550 (write-buffered *(ebp+0x14) %eax) -12551 (write-buffered *(ebp+0x14) "' is not right\n") -12552 (flush *(ebp+0x14)) -12553 (stop *(ebp+0x18) 1) -12554 } -12555 $check-mu-call:continue-to-next-inout: -12556 # inouts = lookup(inouts->next) -12557 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -12558 89/<- %ecx 0/r32/eax -12559 # expected = lookup(expected->next) -12560 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -12561 89/<- %edx 0/r32/eax -12562 # -12563 e9/jump loop/disp32 -12564 } -12565 $check-mu-call:check-inout-count: -12566 # if (inouts == expected) proceed -12567 39/compare %ecx 2/r32/edx -12568 { -12569 0f 84/jump-if-= break/disp32 -12570 # exactly one of the two is null -12571 # if (inouts == 0) error("too many inouts") -12572 { -12573 81 7/subop/compare %ecx 0/imm32 -12574 0f 84/jump-if-= break/disp32 -12575 (write-buffered *(ebp+0x14) "fn ") -12576 8b/-> *(ebp+0x10) 0/r32/eax -12577 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12578 (write-buffered *(ebp+0x14) %eax) -12579 (write-buffered *(ebp+0x14) ": call ") -12580 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12581 (write-buffered *(ebp+0x14) %eax) -12582 (write-buffered *(ebp+0x14) ": too many inouts\n") -12583 (flush *(ebp+0x14)) -12584 (stop *(ebp+0x18) 1) -12585 } -12586 # if (expected == 0) error("too few inouts") -12587 { -12588 81 7/subop/compare %edx 0/imm32 -12589 0f 84/jump-if-= break/disp32 -12590 (write-buffered *(ebp+0x14) "fn ") -12591 8b/-> *(ebp+0x10) 0/r32/eax -12592 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12593 (write-buffered *(ebp+0x14) %eax) -12594 (write-buffered *(ebp+0x14) ": call ") -12595 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12596 (write-buffered *(ebp+0x14) %eax) -12597 (write-buffered *(ebp+0x14) ": too few inouts\n") -12598 (flush *(ebp+0x14)) -12599 (stop *(ebp+0x18) 1) -12600 } -12601 } -12602 $check-mu-call:check-outputs: -12603 # var outputs/ecx: (addr stmt-var) = lookup(stmt->outputs) -12604 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -12605 89/<- %ecx 0/r32/eax -12606 # var expected/edx: (addr list var) = lookup(f->outputs) -12607 (lookup *(edi+0x10) *(edi+0x14)) # Function-outputs Function-outputs => eax -12608 89/<- %edx 0/r32/eax -12609 { -12610 $check-mu-call:check-for-outputs: -12611 # if (outputs == 0) break -12612 81 7/subop/compare %ecx 0/imm32 -12613 0f 84/jump-if-= break/disp32 -12614 # if (expected == 0) error -12615 81 7/subop/compare %edx 0/imm32 -12616 0f 84/jump-if-= break/disp32 -12617 $check-mu-call:check-output-type: -12618 # var v/eax: (addr v) = lookup(outputs->value) -12619 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12620 # var t/ebx: (addr type-tree) = lookup(v->type) -12621 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12622 89/<- %ebx 0/r32/eax -12623 # if (outputs->is-deref?) t = t->right # TODO: check that t->left is an addr -12624 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -12625 { -12626 74/jump-if-= break/disp8 -12627 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -12628 89/<- %ebx 0/r32/eax -12629 } -12630 # var v2/eax: (addr v) = lookup(expected->value) -12631 (lookup *edx *(edx+4)) # List-value List-value => eax -12632 # var t2/eax: (addr type-tree) = lookup(v2->type) -12633 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -12634 # if (t != t2) error -12635 (type-match? %eax %ebx *(ebp-4)) # => eax -12636 3d/compare-eax-and 0/imm32/false -12637 { -12638 0f 85/jump-if-!= break/disp32 -12639 (write-buffered *(ebp+0x14) "fn ") -12640 8b/-> *(ebp+0x10) 0/r32/eax -12641 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12642 (write-buffered *(ebp+0x14) %eax) -12643 (write-buffered *(ebp+0x14) ": call ") -12644 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12645 (write-buffered *(ebp+0x14) %eax) -12646 (write-buffered *(ebp+0x14) ": type for output '") -12647 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12648 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12649 (write-buffered *(ebp+0x14) %eax) -12650 (write-buffered *(ebp+0x14) "' is not right\n") -12651 (flush *(ebp+0x14)) -12652 (stop *(ebp+0x18) 1) -12653 } -12654 $check-mu-call:check-output-register: -12655 # var v/eax: (addr v) = lookup(outputs->value) -12656 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12657 # var r/ebx: (addr array byte) = lookup(v->register) -12658 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax -12659 89/<- %ebx 0/r32/eax -12660 # var v2/eax: (addr v) = lookup(expected->value) -12661 (lookup *edx *(edx+4)) # Stmt-var-value Stmt-var-value => eax -12662 # var r2/eax: (addr array byte) = lookup(v2->register) -12663 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax -12664 # if (r != r2) error -12665 (string-equal? %eax %ebx) # => eax -12666 3d/compare-eax-and 0/imm32/false -12667 { -12668 0f 85/jump-if-!= break/disp32 +12489 $check-mu-length-stmt:end: +12490 # . restore registers +12491 # . epilogue +12492 89/<- %esp 5/r32/ebp +12493 5d/pop-to-ebp +12494 c3/return +12495 +12496 check-mu-compute-offset-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12497 # . prologue +12498 55/push-ebp +12499 89/<- %ebp 4/r32/esp +12500 # . save registers +12501 $check-mu-compute-offset-stmt:end: +12502 # . restore registers +12503 # . epilogue +12504 89/<- %esp 5/r32/ebp +12505 5d/pop-to-ebp +12506 c3/return +12507 +12508 check-mu-allocate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12509 # . prologue +12510 55/push-ebp +12511 89/<- %ebp 4/r32/esp +12512 # . save registers +12513 $check-mu-allocate-stmt:end: +12514 # . restore registers +12515 # . epilogue +12516 89/<- %esp 5/r32/ebp +12517 5d/pop-to-ebp +12518 c3/return +12519 +12520 check-mu-populate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12521 # . prologue +12522 55/push-ebp +12523 89/<- %ebp 4/r32/esp +12524 # . save registers +12525 $check-mu-populate-stmt:end: +12526 # . restore registers +12527 # . epilogue +12528 89/<- %esp 5/r32/ebp +12529 5d/pop-to-ebp +12530 c3/return +12531 +12532 check-mu-populate-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12533 # . prologue +12534 55/push-ebp +12535 89/<- %ebp 4/r32/esp +12536 # . save registers +12537 $check-mu-populate-stream-stmt:end: +12538 # . restore registers +12539 # . epilogue +12540 89/<- %esp 5/r32/ebp +12541 5d/pop-to-ebp +12542 c3/return +12543 +12544 check-mu-read-from-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12545 # . prologue +12546 55/push-ebp +12547 89/<- %ebp 4/r32/esp +12548 # . save registers +12549 $check-mu-read-from-stream-stmt:end: +12550 # . restore registers +12551 # . epilogue +12552 89/<- %esp 5/r32/ebp +12553 5d/pop-to-ebp +12554 c3/return +12555 +12556 check-mu-write-to-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12557 # . prologue +12558 55/push-ebp +12559 89/<- %ebp 4/r32/esp +12560 # . save registers +12561 $check-mu-write-to-stream-stmt:end: +12562 # . restore registers +12563 # . epilogue +12564 89/<- %esp 5/r32/ebp +12565 5d/pop-to-ebp +12566 c3/return +12567 +12568 check-mu-call: # stmt: (addr stmt), callee: (addr function), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +12569 # . prologue +12570 55/push-ebp +12571 89/<- %ebp 4/r32/esp +12572 # var type-parameters: (addr table (handle array byte) (addr type-tree) 8) +12573 68/push 0/imm32 +12574 # var type-parameters-storage: (table (handle array byte) (addr type-tree) 8) +12575 81 5/subop/subtract %esp 0x60/imm32 +12576 68/push 0x60/imm32/size +12577 68/push 0/imm32/read +12578 68/push 0/imm32/write +12579 # save a pointer to type-parameters-storage at type-parameters +12580 89/<- *(ebp-4) 4/r32/esp +12581 (clear-stream *(ebp-4)) +12582 # . save registers +12583 50/push-eax +12584 51/push-ecx +12585 52/push-edx +12586 53/push-ebx +12587 56/push-esi +12588 57/push-edi +12589 # esi = stmt +12590 8b/-> *(ebp+8) 6/r32/esi +12591 # edi = callee +12592 8b/-> *(ebp+0xc) 7/r32/edi +12593 # var inouts/ecx: (addr stmt-var) = lookup(stmt->inouts) +12594 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12595 89/<- %ecx 0/r32/eax +12596 # var expected/edx: (addr list var) = lookup(f->inouts) +12597 (lookup *(edi+8) *(edi+0xc)) # Function-inouts Function-inouts => eax +12598 89/<- %edx 0/r32/eax +12599 { +12600 $check-mu-call:check-for-inouts: +12601 # if (inouts == 0) break +12602 81 7/subop/compare %ecx 0/imm32 +12603 0f 84/jump-if-= break/disp32 +12604 # if (expected == 0) error +12605 81 7/subop/compare %edx 0/imm32 +12606 0f 84/jump-if-= break/disp32 +12607 $check-mu-call:check-inout-type: +12608 # var v/eax: (addr v) = lookup(inouts->value) +12609 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12610 # var t/ebx: (addr type-tree) = lookup(v->type) +12611 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12612 89/<- %ebx 0/r32/eax +12613 # if (inouts->is-deref?) t = t->right # TODO: check that t->left is an addr +12614 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +12615 { +12616 74/jump-if-= break/disp8 +12617 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +12618 89/<- %ebx 0/r32/eax +12619 # if t->right is null, t = t->left +12620 81 7/subop/compare *(ebx+0xc) 0/imm32 # Type-tree-right +12621 75/jump-if-!= break/disp8 +12622 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +12623 89/<- %ebx 0/r32/eax +12624 } +12625 # var v2/eax: (addr v) = lookup(expected->value) +12626 (lookup *edx *(edx+4)) # List-value List-value => eax +12627 # var t2/eax: (addr type-tree) = lookup(v2->type) +12628 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12629 # if (t != t2) error +12630 (type-match? %eax %ebx *(ebp-4)) # => eax +12631 3d/compare-eax-and 0/imm32/false +12632 { +12633 0f 85/jump-if-!= break/disp32 +12634 (write-buffered *(ebp+0x14) "fn ") +12635 8b/-> *(ebp+0x10) 0/r32/eax +12636 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12637 (write-buffered *(ebp+0x14) %eax) +12638 (write-buffered *(ebp+0x14) ": call ") +12639 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12640 (write-buffered *(ebp+0x14) %eax) +12641 (write-buffered *(ebp+0x14) ": type for inout '") +12642 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12643 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12644 (write-buffered *(ebp+0x14) %eax) +12645 (write-buffered *(ebp+0x14) "' is not right\n") +12646 (flush *(ebp+0x14)) +12647 (stop *(ebp+0x18) 1) +12648 } +12649 $check-mu-call:continue-to-next-inout: +12650 # inouts = lookup(inouts->next) +12651 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +12652 89/<- %ecx 0/r32/eax +12653 # expected = lookup(expected->next) +12654 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +12655 89/<- %edx 0/r32/eax +12656 # +12657 e9/jump loop/disp32 +12658 } +12659 $check-mu-call:check-inout-count: +12660 # if (inouts == expected) proceed +12661 39/compare %ecx 2/r32/edx +12662 { +12663 0f 84/jump-if-= break/disp32 +12664 # exactly one of the two is null +12665 # if (inouts == 0) error("too many inouts") +12666 { +12667 81 7/subop/compare %ecx 0/imm32 +12668 0f 84/jump-if-= break/disp32 12669 (write-buffered *(ebp+0x14) "fn ") 12670 8b/-> *(ebp+0x10) 0/r32/eax 12671 (lookup *eax *(eax+4)) # Function-name Function-name => eax @@ -12128,2809 +12118,2809 @@ if ('onhashchange' in window) { 12673 (write-buffered *(ebp+0x14) ": call ") 12674 (lookup *edi *(edi+4)) # Function-name Function-name => eax 12675 (write-buffered *(ebp+0x14) %eax) -12676 (write-buffered *(ebp+0x14) ": register for output '") -12677 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12678 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12679 (write-buffered *(ebp+0x14) %eax) -12680 (write-buffered *(ebp+0x14) "' is not right\n") -12681 (flush *(ebp+0x14)) -12682 (stop *(ebp+0x18) 1) -12683 } -12684 $check-mu-call:continue-to-next-output: -12685 # outputs = lookup(outputs->next) -12686 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -12687 89/<- %ecx 0/r32/eax -12688 # expected = lookup(expected->next) -12689 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -12690 89/<- %edx 0/r32/eax -12691 # -12692 e9/jump loop/disp32 -12693 } -12694 $check-mu-call:check-output-count: -12695 # if (outputs == expected) proceed -12696 39/compare %ecx 2/r32/edx -12697 { -12698 0f 84/jump-if-= break/disp32 -12699 # exactly one of the two is null -12700 # if (outputs == 0) error("too many outputs") -12701 { -12702 81 7/subop/compare %ecx 0/imm32 -12703 0f 84/jump-if-= break/disp32 -12704 (write-buffered *(ebp+0x14) "fn ") -12705 8b/-> *(ebp+0x10) 0/r32/eax -12706 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12707 (write-buffered *(ebp+0x14) %eax) -12708 (write-buffered *(ebp+0x14) ": call ") -12709 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12710 (write-buffered *(ebp+0x14) %eax) -12711 (write-buffered *(ebp+0x14) ": too many outputs\n") -12712 (flush *(ebp+0x14)) -12713 (stop *(ebp+0x18) 1) -12714 } -12715 # if (expected == 0) error("too few outputs") -12716 { -12717 81 7/subop/compare %edx 0/imm32 -12718 0f 84/jump-if-= break/disp32 -12719 (write-buffered *(ebp+0x14) "fn ") -12720 8b/-> *(ebp+0x10) 0/r32/eax -12721 (lookup *eax *(eax+4)) # Function-name Function-name => eax -12722 (write-buffered *(ebp+0x14) %eax) -12723 (write-buffered *(ebp+0x14) ": call ") -12724 (lookup *edi *(edi+4)) # Function-name Function-name => eax -12725 (write-buffered *(ebp+0x14) %eax) -12726 (write-buffered *(ebp+0x14) ": too few outputs\n") -12727 (flush *(ebp+0x14)) -12728 (stop *(ebp+0x18) 1) -12729 } -12730 } -12731 $check-mu-call:end: -12732 # . restore registers -12733 5f/pop-to-edi -12734 5e/pop-to-esi -12735 5b/pop-to-ebx -12736 5a/pop-to-edx -12737 59/pop-to-ecx -12738 58/pop-to-eax -12739 # . reclaim locals exclusively on the stack -12740 81 0/subop/add %esp 0x70/imm32 -12741 # . epilogue -12742 89/<- %esp 5/r32/ebp -12743 5d/pop-to-ebp -12744 c3/return -12745 -12746 # like type-equal? but takes literals into account -12747 type-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -12748 # . prologue -12749 55/push-ebp -12750 89/<- %ebp 4/r32/esp -12751 # if (call == literal) return true # TODO: more precise -12752 (is-simple-mu-type? *(ebp+0xc) 0) # literal => eax -12753 3d/compare-eax-and 0/imm32/false -12754 b8/copy-to-eax 1/imm32/true -12755 75/jump-if-!= $type-match?:end/disp8 -12756 $type-match?:baseline: -12757 # otherwise fall back -12758 (type-component-match? *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax -12759 $type-match?:end: -12760 # . epilogue -12761 89/<- %esp 5/r32/ebp -12762 5d/pop-to-ebp -12763 c3/return -12764 -12765 type-component-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -12766 # . prologue -12767 55/push-ebp -12768 89/<- %ebp 4/r32/esp -12769 # . save registers -12770 51/push-ecx -12771 52/push-edx -12772 53/push-ebx -12773 # ecx = def -12774 8b/-> *(ebp+8) 1/r32/ecx -12775 # edx = call -12776 8b/-> *(ebp+0xc) 2/r32/edx -12777 $type-component-match?:compare-addr: -12778 # if (def == call) return true -12779 8b/-> %ecx 0/r32/eax # Var-type -12780 39/compare %edx 0/r32/eax # Var-type -12781 b8/copy-to-eax 1/imm32/true -12782 0f 84/jump-if-= $type-component-match?:end/disp32 -12783 # if def is a type parameter, return true -12784 { -12785 $type-component-match?:check-type-parameter: -12786 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -12787 74/jump-if-= break/disp8 -12788 81 7/subop/compare *(ecx+4) 0xa/imm32/type-parameter # Type-tree-value -12789 75/jump-if-!= break/disp8 -12790 $type-component-match?:type-parameter: -12791 (type-parameter-match? *(ecx+8) *(ecx+0xc) %edx *(ebp+0x10)) # => eax -12792 e9/jump $type-component-match?:end/disp32 -12793 } -12794 $type-component-match?:compare-atom-state: -12795 # if (def->is-atom? != call->is-atom?) return false -12796 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom -12797 39/compare *edx 3/r32/ebx # Type-tree-is-atom -12798 b8/copy-to-eax 0/imm32/false -12799 0f 85/jump-if-!= $type-component-match?:end/disp32 -12800 # if def->is-atom? return (def->value == call->value) -12801 { -12802 $type-component-match?:check-atom: -12803 81 7/subop/compare %ebx 0/imm32/false -12804 74/jump-if-= break/disp8 -12805 $type-component-match?:is-atom: -12806 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value -12807 39/compare *(edx+4) 0/r32/eax # Type-tree-value -12808 0f 94/set-if-= %al -12809 81 4/subop/and %eax 0xff/imm32 -12810 e9/jump $type-component-match?:end/disp32 -12811 } -12812 $type-component-match?:check-left: -12813 # if (!type-component-match?(def->left, call->left)) return false -12814 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -12815 89/<- %ebx 0/r32/eax -12816 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -12817 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax -12818 3d/compare-eax-and 0/imm32/false -12819 74/jump-if-= $type-component-match?:end/disp8 -12820 $type-component-match?:check-right: -12821 # return type-component-match?(def->right, call->right) -12822 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -12823 89/<- %ebx 0/r32/eax -12824 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -12825 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax -12826 $type-component-match?:end: -12827 # . restore registers -12828 5b/pop-to-ebx -12829 5a/pop-to-edx -12830 59/pop-to-ecx -12831 # . epilogue -12832 89/<- %esp 5/r32/ebp -12833 5d/pop-to-ebp -12834 c3/return -12835 -12836 type-parameter-match?: # type-parameter-name: (handle array byte), type: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -12837 # . prologue -12838 55/push-ebp -12839 89/<- %ebp 4/r32/esp -12840 # . save registers -12841 51/push-ecx -12842 # -12843 (get-or-insert-handle *(ebp+0x14) *(ebp+8) *(ebp+0xc) 0xc) # => eax -12844 # if parameter wasn't saved, save it -12845 { -12846 81 7/subop/compare *eax 0/imm32 -12847 75/jump-if-!= break/disp8 -12848 8b/-> *(ebp+0x10) 1/r32/ecx -12849 89/<- *eax 1/r32/ecx -12850 } -12851 # -12852 (type-equal? *(ebp+0x10) *eax) # => eax -12853 $type-parameter-match?:end: -12854 # . restore registers -12855 59/pop-to-ecx -12856 # . epilogue -12857 89/<- %esp 5/r32/ebp -12858 5d/pop-to-ebp -12859 c3/return -12860 -12861 size-of: # v: (addr var) -> result/eax: int -12862 # . prologue -12863 55/push-ebp -12864 89/<- %ebp 4/r32/esp -12865 # . save registers -12866 51/push-ecx -12867 # var t/ecx: (addr type-tree) = lookup(v->type) +12676 (write-buffered *(ebp+0x14) ": too many inouts\n") +12677 (flush *(ebp+0x14)) +12678 (stop *(ebp+0x18) 1) +12679 } +12680 # if (expected == 0) error("too few inouts") +12681 { +12682 81 7/subop/compare %edx 0/imm32 +12683 0f 84/jump-if-= break/disp32 +12684 (write-buffered *(ebp+0x14) "fn ") +12685 8b/-> *(ebp+0x10) 0/r32/eax +12686 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12687 (write-buffered *(ebp+0x14) %eax) +12688 (write-buffered *(ebp+0x14) ": call ") +12689 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12690 (write-buffered *(ebp+0x14) %eax) +12691 (write-buffered *(ebp+0x14) ": too few inouts\n") +12692 (flush *(ebp+0x14)) +12693 (stop *(ebp+0x18) 1) +12694 } +12695 } +12696 $check-mu-call:check-outputs: +12697 # var outputs/ecx: (addr stmt-var) = lookup(stmt->outputs) +12698 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +12699 89/<- %ecx 0/r32/eax +12700 # var expected/edx: (addr list var) = lookup(f->outputs) +12701 (lookup *(edi+0x10) *(edi+0x14)) # Function-outputs Function-outputs => eax +12702 89/<- %edx 0/r32/eax +12703 { +12704 $check-mu-call:check-for-outputs: +12705 # if (outputs == 0) break +12706 81 7/subop/compare %ecx 0/imm32 +12707 0f 84/jump-if-= break/disp32 +12708 # if (expected == 0) error +12709 81 7/subop/compare %edx 0/imm32 +12710 0f 84/jump-if-= break/disp32 +12711 $check-mu-call:check-output-type: +12712 # var v/eax: (addr v) = lookup(outputs->value) +12713 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12714 # var t/ebx: (addr type-tree) = lookup(v->type) +12715 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12716 89/<- %ebx 0/r32/eax +12717 # if (outputs->is-deref?) t = t->right # TODO: check that t->left is an addr +12718 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +12719 { +12720 74/jump-if-= break/disp8 +12721 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +12722 89/<- %ebx 0/r32/eax +12723 } +12724 # var v2/eax: (addr v) = lookup(expected->value) +12725 (lookup *edx *(edx+4)) # List-value List-value => eax +12726 # var t2/eax: (addr type-tree) = lookup(v2->type) +12727 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +12728 # if (t != t2) error +12729 (type-match? %eax %ebx *(ebp-4)) # => eax +12730 3d/compare-eax-and 0/imm32/false +12731 { +12732 0f 85/jump-if-!= break/disp32 +12733 (write-buffered *(ebp+0x14) "fn ") +12734 8b/-> *(ebp+0x10) 0/r32/eax +12735 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12736 (write-buffered *(ebp+0x14) %eax) +12737 (write-buffered *(ebp+0x14) ": call ") +12738 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12739 (write-buffered *(ebp+0x14) %eax) +12740 (write-buffered *(ebp+0x14) ": type for output '") +12741 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12742 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12743 (write-buffered *(ebp+0x14) %eax) +12744 (write-buffered *(ebp+0x14) "' is not right\n") +12745 (flush *(ebp+0x14)) +12746 (stop *(ebp+0x18) 1) +12747 } +12748 $check-mu-call:check-output-register: +12749 # var v/eax: (addr v) = lookup(outputs->value) +12750 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12751 # var r/ebx: (addr array byte) = lookup(v->register) +12752 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax +12753 89/<- %ebx 0/r32/eax +12754 # var v2/eax: (addr v) = lookup(expected->value) +12755 (lookup *edx *(edx+4)) # Stmt-var-value Stmt-var-value => eax +12756 # var r2/eax: (addr array byte) = lookup(v2->register) +12757 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax +12758 # if (r != r2) error +12759 (string-equal? %eax %ebx) # => eax +12760 3d/compare-eax-and 0/imm32/false +12761 { +12762 0f 85/jump-if-!= break/disp32 +12763 (write-buffered *(ebp+0x14) "fn ") +12764 8b/-> *(ebp+0x10) 0/r32/eax +12765 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12766 (write-buffered *(ebp+0x14) %eax) +12767 (write-buffered *(ebp+0x14) ": call ") +12768 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12769 (write-buffered *(ebp+0x14) %eax) +12770 (write-buffered *(ebp+0x14) ": register for output '") +12771 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12772 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12773 (write-buffered *(ebp+0x14) %eax) +12774 (write-buffered *(ebp+0x14) "' is not right\n") +12775 (flush *(ebp+0x14)) +12776 (stop *(ebp+0x18) 1) +12777 } +12778 $check-mu-call:continue-to-next-output: +12779 # outputs = lookup(outputs->next) +12780 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +12781 89/<- %ecx 0/r32/eax +12782 # expected = lookup(expected->next) +12783 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +12784 89/<- %edx 0/r32/eax +12785 # +12786 e9/jump loop/disp32 +12787 } +12788 $check-mu-call:check-output-count: +12789 # if (outputs == expected) proceed +12790 39/compare %ecx 2/r32/edx +12791 { +12792 0f 84/jump-if-= break/disp32 +12793 # exactly one of the two is null +12794 # if (outputs == 0) error("too many outputs") +12795 { +12796 81 7/subop/compare %ecx 0/imm32 +12797 0f 84/jump-if-= break/disp32 +12798 (write-buffered *(ebp+0x14) "fn ") +12799 8b/-> *(ebp+0x10) 0/r32/eax +12800 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12801 (write-buffered *(ebp+0x14) %eax) +12802 (write-buffered *(ebp+0x14) ": call ") +12803 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12804 (write-buffered *(ebp+0x14) %eax) +12805 (write-buffered *(ebp+0x14) ": too many outputs\n") +12806 (flush *(ebp+0x14)) +12807 (stop *(ebp+0x18) 1) +12808 } +12809 # if (expected == 0) error("too few outputs") +12810 { +12811 81 7/subop/compare %edx 0/imm32 +12812 0f 84/jump-if-= break/disp32 +12813 (write-buffered *(ebp+0x14) "fn ") +12814 8b/-> *(ebp+0x10) 0/r32/eax +12815 (lookup *eax *(eax+4)) # Function-name Function-name => eax +12816 (write-buffered *(ebp+0x14) %eax) +12817 (write-buffered *(ebp+0x14) ": call ") +12818 (lookup *edi *(edi+4)) # Function-name Function-name => eax +12819 (write-buffered *(ebp+0x14) %eax) +12820 (write-buffered *(ebp+0x14) ": too few outputs\n") +12821 (flush *(ebp+0x14)) +12822 (stop *(ebp+0x18) 1) +12823 } +12824 } +12825 $check-mu-call:end: +12826 # . restore registers +12827 5f/pop-to-edi +12828 5e/pop-to-esi +12829 5b/pop-to-ebx +12830 5a/pop-to-edx +12831 59/pop-to-ecx +12832 58/pop-to-eax +12833 # . reclaim locals exclusively on the stack +12834 81 0/subop/add %esp 0x70/imm32 +12835 # . epilogue +12836 89/<- %esp 5/r32/ebp +12837 5d/pop-to-ebp +12838 c3/return +12839 +12840 # like type-equal? but takes literals into account +12841 type-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +12842 # . prologue +12843 55/push-ebp +12844 89/<- %ebp 4/r32/esp +12845 # if (call == literal) return true # TODO: more precise +12846 (is-simple-mu-type? *(ebp+0xc) 0) # literal => eax +12847 3d/compare-eax-and 0/imm32/false +12848 b8/copy-to-eax 1/imm32/true +12849 75/jump-if-!= $type-match?:end/disp8 +12850 $type-match?:baseline: +12851 # otherwise fall back +12852 (type-component-match? *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax +12853 $type-match?:end: +12854 # . epilogue +12855 89/<- %esp 5/r32/ebp +12856 5d/pop-to-ebp +12857 c3/return +12858 +12859 type-component-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +12860 # . prologue +12861 55/push-ebp +12862 89/<- %ebp 4/r32/esp +12863 # . save registers +12864 51/push-ecx +12865 52/push-edx +12866 53/push-ebx +12867 # ecx = def 12868 8b/-> *(ebp+8) 1/r32/ecx -12869 #? (write-buffered Stderr "size-of ") -12870 #? (write-int32-hex-buffered Stderr %ecx) -12871 #? (write-buffered Stderr Newline) -12872 #? (write-buffered Stderr "type allocid: ") -12873 #? (write-int32-hex-buffered Stderr *(ecx+8)) -12874 #? (write-buffered Stderr Newline) -12875 #? (flush Stderr) -12876 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -12877 89/<- %ecx 0/r32/eax -12878 # if is-mu-array?(t) return size-of-array(t) -12879 { -12880 (is-mu-array? %ecx) # => eax -12881 3d/compare-eax-and 0/imm32/false -12882 74/jump-if-= break/disp8 -12883 (size-of-array %ecx) # => eax -12884 eb/jump $size-of:end/disp8 -12885 } -12886 # if is-mu-stream?(t) return size-of-stream(t) -12887 { -12888 (is-mu-stream? %ecx) # => eax -12889 3d/compare-eax-and 0/imm32/false -12890 74/jump-if-= break/disp8 -12891 (size-of-stream %ecx) # => eax -12892 eb/jump $size-of:end/disp8 -12893 } -12894 # if (!t->is-atom?) t = lookup(t->left) -12895 { -12896 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -12897 75/jump-if-!= break/disp8 +12869 # edx = call +12870 8b/-> *(ebp+0xc) 2/r32/edx +12871 $type-component-match?:compare-addr: +12872 # if (def == call) return true +12873 8b/-> %ecx 0/r32/eax # Var-type +12874 39/compare %edx 0/r32/eax # Var-type +12875 b8/copy-to-eax 1/imm32/true +12876 0f 84/jump-if-= $type-component-match?:end/disp32 +12877 # if def is a type parameter, just check in type-parameters +12878 { +12879 $type-component-match?:check-type-parameter: +12880 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +12881 74/jump-if-= break/disp8 +12882 81 7/subop/compare *(ecx+4) 0xa/imm32/type-parameter # Type-tree-value +12883 75/jump-if-!= break/disp8 +12884 $type-component-match?:type-parameter: +12885 (type-parameter-match? *(ecx+8) *(ecx+0xc) %edx *(ebp+0x10)) # => eax +12886 e9/jump $type-component-match?:end/disp32 +12887 } +12888 # if def is a list containing just a type parameter, just check in type-parameters +12889 { +12890 $type-component-match?:check-list-type-parameter: +12891 # if def is a list.. +12892 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +12893 75/jump-if-!= break/disp8 +12894 # ..that's a singleton +12895 81 7/subop/compare *(ecx+0xc) 0/imm32 # Type-tree-left +12896 75/jump-if-!= break/disp8 +12897 # ..and whose head is a type parameter 12898 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -12899 89/<- %ecx 0/r32/eax -12900 } -12901 # TODO: assert t->is-atom? -12902 (size-of-type-id *(ecx+4)) # Type-tree-value => eax -12903 $size-of:end: -12904 # . restore registers -12905 59/pop-to-ecx -12906 # . epilogue -12907 89/<- %esp 5/r32/ebp -12908 5d/pop-to-ebp -12909 c3/return -12910 -12911 size-of-deref: # v: (addr var) -> result/eax: int -12912 # . prologue -12913 55/push-ebp -12914 89/<- %ebp 4/r32/esp -12915 # . save registers -12916 51/push-ecx -12917 # var t/ecx: (addr type-tree) = lookup(v->type) -12918 8b/-> *(ebp+8) 1/r32/ecx -12919 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -12920 89/<- %ecx 0/r32/eax -12921 # TODO: assert(t is an addr) -12922 # t = lookup(t->right) -12923 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -12924 89/<- %ecx 0/r32/eax -12925 # if is-mu-array?(t) return size-of-array(t) -12926 { -12927 (is-mu-array? %ecx) # => eax -12928 3d/compare-eax-and 0/imm32/false -12929 74/jump-if-= break/disp8 -12930 (size-of-array %ecx) # => eax -12931 eb/jump $size-of-deref:end/disp8 -12932 } -12933 # if is-mu-stream?(t) return size-of-stream(t) -12934 { -12935 (is-mu-stream? %ecx) # => eax -12936 3d/compare-eax-and 0/imm32/false -12937 74/jump-if-= break/disp8 -12938 (size-of-stream %ecx) # => eax -12939 eb/jump $size-of-deref:end/disp8 -12940 } -12941 # if (!t->is-atom?) t = lookup(t->left) -12942 { -12943 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -12944 75/jump-if-!= break/disp8 -12945 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -12946 89/<- %ecx 0/r32/eax -12947 } -12948 # TODO: assert t->is-atom? -12949 (size-of-type-id *(ecx+4)) # Type-tree-value => eax -12950 $size-of-deref:end: -12951 # . restore registers -12952 59/pop-to-ecx -12953 # . epilogue -12954 89/<- %esp 5/r32/ebp -12955 5d/pop-to-ebp -12956 c3/return -12957 -12958 is-mu-array?: # t: (addr type-tree) -> result/eax: boolean -12959 # . prologue -12960 55/push-ebp -12961 89/<- %ebp 4/r32/esp -12962 # . save registers -12963 51/push-ecx -12964 # ecx = t -12965 8b/-> *(ebp+8) 1/r32/ecx -12966 # if t->is-atom?, return false -12967 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -12968 75/jump-if-!= $is-mu-array?:return-false/disp8 -12969 # if !t->left->is-atom?, return false -12970 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -12971 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -12972 74/jump-if-= $is-mu-array?:return-false/disp8 -12973 # return t->left->value == array -12974 81 7/subop/compare *(eax+4) 3/imm32/array-type-id # Type-tree-value -12975 0f 94/set-if-= %al -12976 81 4/subop/and %eax 0xff/imm32 -12977 eb/jump $is-mu-array?:end/disp8 -12978 $is-mu-array?:return-false: -12979 b8/copy-to-eax 0/imm32/false -12980 $is-mu-array?:end: -12981 # . restore registers -12982 59/pop-to-ecx -12983 # . epilogue -12984 89/<- %esp 5/r32/ebp -12985 5d/pop-to-ebp -12986 c3/return -12987 -12988 # size of a statically allocated array where the size is part of the type expression -12989 size-of-array: # a: (addr type-tree) -> result/eax: int -12990 # . prologue -12991 55/push-ebp -12992 89/<- %ebp 4/r32/esp -12993 # . save registers -12994 51/push-ecx -12995 52/push-edx -12996 # -12997 8b/-> *(ebp+8) 1/r32/ecx -12998 # TODO: assert that a->left is 'array' -12999 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -13000 89/<- %ecx 0/r32/eax -13001 # var elem-type/edx: type-id = a->right->left->value -13002 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -13003 8b/-> *(eax+4) 2/r32/edx # Type-tree-value -13004 # TODO: assert that a->right->right->left->value == size -13005 # var array-size/ecx: int = a->right->right->left->value-size -13006 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -13007 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -13008 8b/-> *(eax+8) 1/r32/ecx # Type-tree-value-size -13009 # return 4 + array-size * size-of(elem-type) -13010 (size-of-type-id-as-array-element %edx) # => eax -13011 f7 4/subop/multiply-into-eax %ecx -13012 05/add-to-eax 4/imm32 # for array size -13013 $size-of-array:end: -13014 # . restore registers -13015 5a/pop-to-edx -13016 59/pop-to-ecx -13017 # . epilogue -13018 89/<- %esp 5/r32/ebp -13019 5d/pop-to-ebp -13020 c3/return -13021 -13022 is-mu-stream?: # t: (addr type-tree) -> result/eax: boolean -13023 # . prologue -13024 55/push-ebp -13025 89/<- %ebp 4/r32/esp -13026 # . save registers -13027 51/push-ecx -13028 # ecx = t -13029 8b/-> *(ebp+8) 1/r32/ecx -13030 # if t->is-atom?, return false -13031 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -13032 75/jump-if-!= $is-mu-stream?:return-false/disp8 -13033 # if !t->left->is-atom?, return false -13034 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -13035 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -13036 74/jump-if-= $is-mu-stream?:return-false/disp8 -13037 # return t->left->value == stream -13038 81 7/subop/compare *(eax+4) 0xb/imm32/stream-type-id # Type-tree-value -13039 0f 94/set-if-= %al -13040 81 4/subop/and %eax 0xff/imm32 -13041 eb/jump $is-mu-stream?:end/disp8 -13042 $is-mu-stream?:return-false: -13043 b8/copy-to-eax 0/imm32/false -13044 $is-mu-stream?:end: -13045 # . restore registers -13046 59/pop-to-ecx -13047 # . epilogue -13048 89/<- %esp 5/r32/ebp -13049 5d/pop-to-ebp -13050 c3/return -13051 -13052 # size of a statically allocated stream where the size is part of the type expression -13053 size-of-stream: # a: (addr type-tree) -> result/eax: int -13054 # . prologue -13055 55/push-ebp -13056 89/<- %ebp 4/r32/esp -13057 # -13058 (size-of-array *(ebp+8)) # assumes we ignore the actual type name 'array' in the type -13059 05/add-to-eax 8/imm32 # for read/write pointers -13060 $size-of-stream:end: -13061 # . epilogue -13062 89/<- %esp 5/r32/ebp -13063 5d/pop-to-ebp -13064 c3/return -13065 -13066 size-of-type-id: # t: type-id -> result/eax: int -13067 # . prologue -13068 55/push-ebp -13069 89/<- %ebp 4/r32/esp -13070 # . save registers -13071 51/push-ecx -13072 # var out/ecx: (handle typeinfo) -13073 68/push 0/imm32 -13074 68/push 0/imm32 -13075 89/<- %ecx 4/r32/esp -13076 # eax = t -13077 8b/-> *(ebp+8) 0/r32/eax -13078 # if t is a literal, return 0 -13079 3d/compare-eax-and 0/imm32 -13080 0f 84/jump-if-= $size-of-type-id:end/disp32 # eax changes type from type-id to int -13081 # if t is a byte, return 4 (because we don't really support non-multiples of 4) -13082 3d/compare-eax-and 8/imm32/byte -13083 { -13084 75/jump-if-!= break/disp8 -13085 b8/copy-to-eax 4/imm32 -13086 eb/jump $size-of-type-id:end/disp8 -13087 } -13088 # if t is a handle, return 8 -13089 3d/compare-eax-and 4/imm32/handle -13090 { -13091 75/jump-if-!= break/disp8 -13092 b8/copy-to-eax 8/imm32 -13093 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int -13094 } -13095 # if t is a user-defined type, return its size -13096 # TODO: support non-atom type -13097 (find-typeinfo %eax %ecx) -13098 { -13099 81 7/subop/compare *ecx 0/imm32 -13100 74/jump-if-= break/disp8 -13101 $size-of-type-id:user-defined: -13102 (lookup *ecx *(ecx+4)) # => eax -13103 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes -13104 eb/jump $size-of-type-id:end/disp8 -13105 } -13106 # otherwise return the word size -13107 b8/copy-to-eax 4/imm32 -13108 $size-of-type-id:end: -13109 # . reclaim locals -13110 81 0/subop/add %esp 8/imm32 -13111 # . restore registers -13112 59/pop-to-ecx -13113 # . epilogue -13114 89/<- %esp 5/r32/ebp -13115 5d/pop-to-ebp -13116 c3/return -13117 -13118 type-equal?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean -13119 # . prologue -13120 55/push-ebp -13121 89/<- %ebp 4/r32/esp -13122 # . save registers -13123 51/push-ecx -13124 52/push-edx -13125 53/push-ebx -13126 # ecx = a -13127 8b/-> *(ebp+8) 1/r32/ecx -13128 # edx = b -13129 8b/-> *(ebp+0xc) 2/r32/edx -13130 $type-equal?:compare-addr: -13131 # if (a == b) return true -13132 8b/-> %ecx 0/r32/eax # Var-type -13133 39/compare %edx 0/r32/eax # Var-type -13134 b8/copy-to-eax 1/imm32/true -13135 0f 84/jump-if-= $type-equal?:end/disp32 -13136 $type-equal?:compare-atom-state: -13137 # if (a->is-atom? != b->is-atom?) return false -13138 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom -13139 39/compare *edx 3/r32/ebx # Type-tree-is-atom -13140 b8/copy-to-eax 0/imm32/false -13141 0f 85/jump-if-!= $type-equal?:end/disp32 -13142 # if a->is-atom? return (a->value == b->value) -13143 { -13144 $type-equal?:check-atom: -13145 81 7/subop/compare %ebx 0/imm32/false -13146 74/jump-if-= break/disp8 -13147 $type-equal?:is-atom: -13148 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value -13149 39/compare *(edx+4) 0/r32/eax # Type-tree-value -13150 0f 94/set-if-= %al -13151 81 4/subop/and %eax 0xff/imm32 -13152 e9/jump $type-equal?:end/disp32 -13153 } -13154 $type-equal?:check-left: -13155 # if (!type-equal?(a->left, b->left)) return false -13156 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -13157 89/<- %ebx 0/r32/eax -13158 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -13159 (type-equal? %eax %ebx) # => eax -13160 3d/compare-eax-and 0/imm32/false -13161 74/jump-if-= $type-equal?:end/disp8 -13162 $type-equal?:check-right: -13163 # return type-equal?(a->right, b->right) -13164 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -13165 89/<- %ebx 0/r32/eax -13166 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -13167 (type-equal? %eax %ebx) # => eax -13168 $type-equal?:end: -13169 # . restore registers -13170 5b/pop-to-ebx -13171 5a/pop-to-edx -13172 59/pop-to-ecx -13173 # . epilogue -13174 89/<- %esp 5/r32/ebp -13175 5d/pop-to-ebp -13176 c3/return -13177 -13178 ####################################################### -13179 # Code-generation -13180 ####################################################### -13181 -13182 == data -13183 -13184 # Global state added to each var record when performing code-generation. -13185 Curr-local-stack-offset: # (addr int) -13186 0/imm32 -13187 -13188 == code -13189 -13190 emit-subx: # out: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) -13191 # . prologue -13192 55/push-ebp -13193 89/<- %ebp 4/r32/esp -13194 # . save registers -13195 50/push-eax -13196 # var curr/eax: (addr function) = *Program->functions -13197 (lookup *_Program-functions *_Program-functions->payload) # => eax -13198 { -13199 # if (curr == null) break -13200 3d/compare-eax-and 0/imm32 -13201 0f 84/jump-if-= break/disp32 -13202 (emit-subx-function *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) -13203 # curr = lookup(curr->next) -13204 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax -13205 e9/jump loop/disp32 -13206 } -13207 $emit-subx:end: -13208 # . restore registers -13209 58/pop-to-eax -13210 # . epilogue -13211 89/<- %esp 5/r32/ebp -13212 5d/pop-to-ebp -13213 c3/return -13214 -13215 emit-subx-function: # out: (addr buffered-file), f: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -13216 # . prologue -13217 55/push-ebp -13218 89/<- %ebp 4/r32/esp -13219 # some preprocessing -13220 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) -13221 # . save registers -13222 50/push-eax -13223 51/push-ecx -13224 52/push-edx -13225 # initialize some global state -13226 c7 0/subop/copy *Curr-block-depth 1/imm32 # Important: keep this in sync with the parse phase -13227 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 -13228 # ecx = f -13229 8b/-> *(ebp+0xc) 1/r32/ecx -13230 # var vars/edx: (stack (addr var) 256) -13231 81 5/subop/subtract %esp 0xc00/imm32 -13232 68/push 0xc00/imm32/size -13233 68/push 0/imm32/top -13234 89/<- %edx 4/r32/esp -13235 # var name/eax: (addr array byte) = lookup(f->name) -13236 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -13237 # -13238 (write-buffered *(ebp+8) %eax) -13239 (write-buffered *(ebp+8) ":\n") -13240 (emit-subx-prologue *(ebp+8)) -13241 # var body/eax: (addr block) = lookup(f->body) -13242 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax -13243 # -13244 (emit-subx-block *(ebp+8) %eax %edx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -13245 (emit-subx-epilogue *(ebp+8)) -13246 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have -13247 # been cleaned up -13248 $emit-subx-function:end: -13249 # . reclaim locals -13250 81 0/subop/add %esp 0xc08/imm32 -13251 # . restore registers -13252 5a/pop-to-edx -13253 59/pop-to-ecx -13254 58/pop-to-eax -13255 # . epilogue -13256 89/<- %esp 5/r32/ebp -13257 5d/pop-to-ebp -13258 c3/return -13259 -13260 populate-mu-type-offsets-in-inouts: # f: (addr function) -13261 # . prologue -13262 55/push-ebp -13263 89/<- %ebp 4/r32/esp -13264 # . save registers -13265 50/push-eax -13266 51/push-ecx -13267 52/push-edx -13268 53/push-ebx -13269 57/push-edi -13270 # var next-offset/edx: int = 8 -13271 ba/copy-to-edx 8/imm32 -13272 # var curr/ecx: (addr list var) = lookup(f->inouts) -13273 8b/-> *(ebp+8) 1/r32/ecx -13274 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax -13275 89/<- %ecx 0/r32/eax -13276 { -13277 $populate-mu-type-offsets-in-inouts:loop: -13278 81 7/subop/compare %ecx 0/imm32 -13279 74/jump-if-= break/disp8 -13280 # var v/ebx: (addr var) = lookup(curr->value) -13281 (lookup *ecx *(ecx+4)) # List-value List-value => eax -13282 89/<- %ebx 0/r32/eax -13283 #? (lookup *ebx *(ebx+4)) -13284 #? (write-buffered Stderr "setting offset of fn inout ") -13285 #? (write-buffered Stderr %eax) -13286 #? (write-buffered Stderr "@") -13287 #? (write-int32-hex-buffered Stderr %ebx) -13288 #? (write-buffered Stderr " to ") -13289 #? (write-int32-hex-buffered Stderr %edx) -13290 #? (write-buffered Stderr Newline) -13291 #? (flush Stderr) -13292 # v->offset = next-offset -13293 89/<- *(ebx+0x14) 2/r32/edx # Var-offset -13294 # next-offset += size-of(v) -13295 (size-of %ebx) # => eax -13296 01/add-to %edx 0/r32/eax -13297 # curr = lookup(curr->next) -13298 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -13299 89/<- %ecx 0/r32/eax -13300 # -13301 eb/jump loop/disp8 -13302 } -13303 $populate-mu-type-offsets-in-inouts:end: -13304 # . restore registers -13305 5f/pop-to-edi -13306 5b/pop-to-ebx -13307 5a/pop-to-edx -13308 59/pop-to-ecx -13309 58/pop-to-eax -13310 # . epilogue -13311 89/<- %esp 5/r32/ebp -13312 5d/pop-to-ebp -13313 c3/return -13314 -13315 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -13316 # . prologue -13317 55/push-ebp -13318 89/<- %ebp 4/r32/esp -13319 # . save registers -13320 50/push-eax -13321 51/push-ecx -13322 53/push-ebx -13323 56/push-esi -13324 # esi = stmts -13325 8b/-> *(ebp+0xc) 6/r32/esi -13326 # -13327 { -13328 $emit-subx-stmt-list:loop: -13329 81 7/subop/compare %esi 0/imm32 -13330 0f 84/jump-if-= break/disp32 -13331 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) -13332 (lookup *esi *(esi+4)) # List-value List-value => eax -13333 89/<- %ecx 0/r32/eax -13334 { -13335 $emit-subx-stmt-list:check-for-block: -13336 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag -13337 75/jump-if-!= break/disp8 -13338 $emit-subx-stmt-list:block: -13339 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -13340 } -13341 { -13342 $emit-subx-stmt-list:check-for-stmt: -13343 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag -13344 0f 85/jump-if-!= break/disp32 -13345 $emit-subx-stmt-list:stmt1: -13346 { -13347 (is-mu-branch? %ecx) # => eax -13348 3d/compare-eax-and 0/imm32/false -13349 0f 84/jump-if-= break/disp32 -13350 $emit-subx-stmt-list:branch-stmt: -13351 +-- 27 lines: # unconditional loops ----------------------------------------------------------------------------------------------------------------------------------------------------- -13378 +-- 16 lines: # unconditional breaks ---------------------------------------------------------------------------------------------------------------------------------------------------- -13394 +-- 38 lines: # simple conditional branches without a target ---------------------------------------------------------------------------------------------------------------------------- -13432 +-- 19 lines: # conditional branches with an explicit target ---------------------------------------------------------------------------------------------------------------------------- -13451 } -13452 $emit-subx-stmt-list:1-to-1: -13453 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) -13454 e9/jump $emit-subx-stmt-list:continue/disp32 -13455 } -13456 { -13457 $emit-subx-stmt-list:check-for-var-def: -13458 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag -13459 75/jump-if-!= break/disp8 -13460 $emit-subx-stmt-list:var-def: -13461 (emit-subx-var-def *(ebp+8) %ecx) -13462 (push *(ebp+0x10) *(ecx+4)) # Vardef-var -13463 (push *(ebp+0x10) *(ecx+8)) # Vardef-var -13464 (push *(ebp+0x10) 0) # Live-var-register-spilled = 0 for vars on the stack -13465 # -13466 eb/jump $emit-subx-stmt-list:continue/disp8 -13467 } -13468 { -13469 $emit-subx-stmt-list:check-for-reg-var-def: -13470 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag -13471 0f 85/jump-if-!= break/disp32 -13472 $emit-subx-stmt-list:reg-var-def: -13473 # TODO: ensure that there's exactly one output -13474 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -13475 # emit the instruction as usual -13476 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) -13477 # -13478 eb/jump $emit-subx-stmt-list:continue/disp8 -13479 } -13480 $emit-subx-stmt-list:continue: -13481 # TODO: raise an error on unrecognized Stmt-tag -13482 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax -13483 89/<- %esi 0/r32/eax -13484 e9/jump loop/disp32 -13485 } -13486 $emit-subx-stmt-list:emit-cleanup: -13487 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) -13488 $emit-subx-stmt-list:clean-up: -13489 (clean-up-blocks *(ebp+0x10) *Curr-block-depth *(ebp+0x14)) -13490 $emit-subx-stmt-list:end: -13491 # . restore registers -13492 5e/pop-to-esi -13493 5b/pop-to-ebx -13494 59/pop-to-ecx -13495 58/pop-to-eax -13496 # . epilogue -13497 89/<- %esp 5/r32/ebp -13498 5d/pop-to-ebp -13499 c3/return -13500 -13501 # 'later-stmts' includes 'stmt', but will behave the same even without it; reg-var-def stmts are guaranteed not to write to function outputs. -13502 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)), later-stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -13503 # . prologue -13504 55/push-ebp -13505 89/<- %ebp 4/r32/esp -13506 # . save registers -13507 50/push-eax -13508 51/push-ecx -13509 52/push-edx -13510 # ecx = stmt -13511 8b/-> *(ebp+0xc) 1/r32/ecx -13512 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) -13513 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax -13514 # TODO: assert !sv->is-deref? -13515 # var v/ecx: (addr var) = lookup(sv->value) -13516 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -13517 89/<- %ecx 0/r32/eax -13518 # v->block-depth = *Curr-block-depth -13519 8b/-> *Curr-block-depth 0/r32/eax -13520 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -13521 #? (write-buffered Stderr "var ") -13522 #? (lookup *ecx *(ecx+4)) -13523 #? (write-buffered Stderr %eax) -13524 #? (write-buffered Stderr " at depth ") -13525 #? (write-int32-hex-buffered Stderr *(ecx+0x10)) -13526 #? (write-buffered Stderr Newline) -13527 #? (flush Stderr) -13528 # ensure that v is in a register -13529 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -13530 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 -13531 # var emit-spill?/edx: boolean = not-yet-spilled-this-block? && will-not-write-some-register?(fn) -13532 (not-yet-spilled-this-block? %ecx *(ebp+0x10)) # => eax -13533 89/<- %edx 0/r32/eax -13534 3d/compare-eax-and 0/imm32/false -13535 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 -13536 (will-not-write-some-register? %ecx *(ebp+0x14) *(ebp+0x18)) # => eax -13537 89/<- %edx 0/r32/eax -13538 # check emit-spill? -13539 3d/compare-eax-and 0/imm32/false -13540 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 -13541 # TODO: assert(size-of(output) == 4) -13542 # *Curr-local-stack-offset -= 4 -13543 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 -13544 # emit spill -13545 (emit-indent *(ebp+8) *Curr-block-depth) -13546 (write-buffered *(ebp+8) "ff 6/subop/push %") -13547 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -13548 (write-buffered *(ebp+8) %eax) -13549 (write-buffered *(ebp+8) Newline) -13550 $push-output-and-maybe-emit-spill:push: -13551 8b/-> *(ebp+0xc) 1/r32/ecx -13552 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax -13553 # push(vars, {sv->value, emit-spill?}) -13554 (push *(ebp+0x10) *eax) # Stmt-var-value -13555 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value -13556 (push *(ebp+0x10) %edx) -13557 $push-output-and-maybe-emit-spill:end: -13558 # . restore registers -13559 5a/pop-to-edx -13560 59/pop-to-ecx -13561 58/pop-to-eax -13562 # . epilogue -13563 89/<- %esp 5/r32/ebp -13564 5d/pop-to-ebp -13565 c3/return -13566 -13567 $push-output-and-maybe-emit-spill:abort: -13568 # error("var '" var->name "' initialized from an instruction must live in a register\n") -13569 (write-buffered *(ebp+0x1c) "var '") -13570 (write-buffered *(ebp+0x1c) *eax) # Var-name -13571 (write-buffered *(ebp+0x1c) "' initialized from an instruction must live in a register\n") -13572 (flush *(ebp+0x1c)) -13573 (stop *(ebp+0x20) 1) -13574 # never gets here -13575 -13576 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack live-var) -13577 # . prologue -13578 55/push-ebp -13579 89/<- %ebp 4/r32/esp -13580 # . save registers -13581 50/push-eax -13582 51/push-ecx -13583 # ecx = stmt -13584 8b/-> *(ebp+0xc) 1/r32/ecx -13585 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name -13586 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -13587 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -13588 (lookup *eax *(eax+4)) # Var-name Var-name => eax -13589 # clean up until target block -13590 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) -13591 # emit jump to target block -13592 (emit-indent *(ebp+8) *Curr-block-depth) -13593 (write-buffered *(ebp+8) "e9/jump ") -13594 (write-buffered *(ebp+8) %eax) -13595 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -13596 (string-starts-with? %eax "break") -13597 3d/compare-eax-and 0/imm32/false -13598 { -13599 74/jump-if-= break/disp8 -13600 (write-buffered *(ebp+8) ":break/disp32\n") -13601 } -13602 3d/compare-eax-and 0/imm32/false # just in case the function call modified flags -13603 { -13604 75/jump-if-!= break/disp8 -13605 (write-buffered *(ebp+8) ":loop/disp32\n") -13606 } -13607 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: -13608 # . restore registers -13609 59/pop-to-ecx -13610 58/pop-to-eax -13611 # . epilogue -13612 89/<- %esp 5/r32/ebp -13613 5d/pop-to-ebp -13614 c3/return -13615 -13616 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean -13617 # . prologue -13618 55/push-ebp -13619 89/<- %ebp 4/r32/esp -13620 # . save registers +12899 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +12900 74/jump-if-= break/disp8 +12901 81 7/subop/compare *(eax+4) 0xa/imm32/type-parameter # Type-tree-value +12902 75/jump-if-!= break/disp8 +12903 $type-component-match?:list-type-parameter: +12904 (type-parameter-match? *(eax+8) *(eax+0xc) %edx *(ebp+0x10)) # => eax +12905 e9/jump $type-component-match?:end/disp32 +12906 } +12907 $type-component-match?:compare-atom-state: +12908 # if (def->is-atom? != call->is-atom?) return false +12909 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom +12910 39/compare *edx 3/r32/ebx # Type-tree-is-atom +12911 b8/copy-to-eax 0/imm32/false +12912 0f 85/jump-if-!= $type-component-match?:end/disp32 +12913 # if def->is-atom? return (def->value == call->value) +12914 { +12915 $type-component-match?:check-atom: +12916 81 7/subop/compare %ebx 0/imm32/false +12917 74/jump-if-= break/disp8 +12918 $type-component-match?:is-atom: +12919 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value +12920 39/compare *(edx+4) 0/r32/eax # Type-tree-value +12921 0f 94/set-if-= %al +12922 81 4/subop/and %eax 0xff/imm32 +12923 e9/jump $type-component-match?:end/disp32 +12924 } +12925 $type-component-match?:check-left: +12926 # if (!type-component-match?(def->left, call->left)) return false +12927 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +12928 89/<- %ebx 0/r32/eax +12929 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +12930 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax +12931 3d/compare-eax-and 0/imm32/false +12932 74/jump-if-= $type-component-match?:end/disp8 +12933 $type-component-match?:check-right: +12934 # return type-component-match?(def->right, call->right) +12935 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +12936 89/<- %ebx 0/r32/eax +12937 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +12938 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax +12939 $type-component-match?:end: +12940 # . restore registers +12941 5b/pop-to-ebx +12942 5a/pop-to-edx +12943 59/pop-to-ecx +12944 # . epilogue +12945 89/<- %esp 5/r32/ebp +12946 5d/pop-to-ebp +12947 c3/return +12948 +12949 type-parameter-match?: # type-parameter-name: (handle array byte), type: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +12950 # . prologue +12951 55/push-ebp +12952 89/<- %ebp 4/r32/esp +12953 # . save registers +12954 51/push-ecx +12955 # +12956 (get-or-insert-handle *(ebp+0x14) *(ebp+8) *(ebp+0xc) 0xc) # => eax +12957 # if parameter wasn't saved, save it +12958 { +12959 81 7/subop/compare *eax 0/imm32 +12960 75/jump-if-!= break/disp8 +12961 8b/-> *(ebp+0x10) 1/r32/ecx +12962 89/<- *eax 1/r32/ecx +12963 } +12964 # +12965 (type-equal? *(ebp+0x10) *eax) # => eax +12966 $type-parameter-match?:end: +12967 # . restore registers +12968 59/pop-to-ecx +12969 # . epilogue +12970 89/<- %esp 5/r32/ebp +12971 5d/pop-to-ebp +12972 c3/return +12973 +12974 size-of: # v: (addr var) -> result/eax: int +12975 # . prologue +12976 55/push-ebp +12977 89/<- %ebp 4/r32/esp +12978 # . save registers +12979 51/push-ecx +12980 # var t/ecx: (addr type-tree) = lookup(v->type) +12981 8b/-> *(ebp+8) 1/r32/ecx +12982 #? (write-buffered Stderr "size-of ") +12983 #? (write-int32-hex-buffered Stderr %ecx) +12984 #? (write-buffered Stderr Newline) +12985 #? (write-buffered Stderr "type allocid: ") +12986 #? (write-int32-hex-buffered Stderr *(ecx+8)) +12987 #? (write-buffered Stderr Newline) +12988 #? (flush Stderr) +12989 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +12990 89/<- %ecx 0/r32/eax +12991 # if is-mu-array?(t) return size-of-array(t) +12992 { +12993 (is-mu-array? %ecx) # => eax +12994 3d/compare-eax-and 0/imm32/false +12995 74/jump-if-= break/disp8 +12996 (size-of-array %ecx) # => eax +12997 eb/jump $size-of:end/disp8 +12998 } +12999 # if is-mu-stream?(t) return size-of-stream(t) +13000 { +13001 (is-mu-stream? %ecx) # => eax +13002 3d/compare-eax-and 0/imm32/false +13003 74/jump-if-= break/disp8 +13004 (size-of-stream %ecx) # => eax +13005 eb/jump $size-of:end/disp8 +13006 } +13007 # if (!t->is-atom?) t = lookup(t->left) +13008 { +13009 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +13010 75/jump-if-!= break/disp8 +13011 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13012 89/<- %ecx 0/r32/eax +13013 } +13014 # TODO: assert t->is-atom? +13015 (size-of-type-id *(ecx+4)) # Type-tree-value => eax +13016 $size-of:end: +13017 # . restore registers +13018 59/pop-to-ecx +13019 # . epilogue +13020 89/<- %esp 5/r32/ebp +13021 5d/pop-to-ebp +13022 c3/return +13023 +13024 size-of-deref: # v: (addr var) -> result/eax: int +13025 # . prologue +13026 55/push-ebp +13027 89/<- %ebp 4/r32/esp +13028 # . save registers +13029 51/push-ecx +13030 # var t/ecx: (addr type-tree) = lookup(v->type) +13031 8b/-> *(ebp+8) 1/r32/ecx +13032 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +13033 89/<- %ecx 0/r32/eax +13034 # TODO: assert(t is an addr) +13035 # t = lookup(t->right) +13036 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +13037 89/<- %ecx 0/r32/eax +13038 # if is-mu-array?(t) return size-of-array(t) +13039 { +13040 (is-mu-array? %ecx) # => eax +13041 3d/compare-eax-and 0/imm32/false +13042 74/jump-if-= break/disp8 +13043 (size-of-array %ecx) # => eax +13044 eb/jump $size-of-deref:end/disp8 +13045 } +13046 # if is-mu-stream?(t) return size-of-stream(t) +13047 { +13048 (is-mu-stream? %ecx) # => eax +13049 3d/compare-eax-and 0/imm32/false +13050 74/jump-if-= break/disp8 +13051 (size-of-stream %ecx) # => eax +13052 eb/jump $size-of-deref:end/disp8 +13053 } +13054 # if (!t->is-atom?) t = lookup(t->left) +13055 { +13056 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +13057 75/jump-if-!= break/disp8 +13058 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13059 89/<- %ecx 0/r32/eax +13060 } +13061 # TODO: assert t->is-atom? +13062 (size-of-type-id *(ecx+4)) # Type-tree-value => eax +13063 $size-of-deref:end: +13064 # . restore registers +13065 59/pop-to-ecx +13066 # . epilogue +13067 89/<- %esp 5/r32/ebp +13068 5d/pop-to-ebp +13069 c3/return +13070 +13071 is-mu-array?: # t: (addr type-tree) -> result/eax: boolean +13072 # . prologue +13073 55/push-ebp +13074 89/<- %ebp 4/r32/esp +13075 # . save registers +13076 51/push-ecx +13077 # ecx = t +13078 8b/-> *(ebp+8) 1/r32/ecx +13079 # if t->is-atom?, return false +13080 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +13081 75/jump-if-!= $is-mu-array?:return-false/disp8 +13082 # if !t->left->is-atom?, return false +13083 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13084 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +13085 74/jump-if-= $is-mu-array?:return-false/disp8 +13086 # return t->left->value == array +13087 81 7/subop/compare *(eax+4) 3/imm32/array-type-id # Type-tree-value +13088 0f 94/set-if-= %al +13089 81 4/subop/and %eax 0xff/imm32 +13090 eb/jump $is-mu-array?:end/disp8 +13091 $is-mu-array?:return-false: +13092 b8/copy-to-eax 0/imm32/false +13093 $is-mu-array?:end: +13094 # . restore registers +13095 59/pop-to-ecx +13096 # . epilogue +13097 89/<- %esp 5/r32/ebp +13098 5d/pop-to-ebp +13099 c3/return +13100 +13101 # size of a statically allocated array where the size is part of the type expression +13102 size-of-array: # a: (addr type-tree) -> result/eax: int +13103 # . prologue +13104 55/push-ebp +13105 89/<- %ebp 4/r32/esp +13106 # . save registers +13107 51/push-ecx +13108 52/push-edx +13109 # +13110 8b/-> *(ebp+8) 1/r32/ecx +13111 # TODO: assert that a->left is 'array' +13112 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +13113 89/<- %ecx 0/r32/eax +13114 # var elem-type/edx: type-id = a->right->left->value +13115 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13116 8b/-> *(eax+4) 2/r32/edx # Type-tree-value +13117 # TODO: assert that a->right->right->left->value == size +13118 # var array-size/ecx: int = a->right->right->left->value-size +13119 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +13120 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +13121 8b/-> *(eax+8) 1/r32/ecx # Type-tree-value-size +13122 # return 4 + array-size * size-of(elem-type) +13123 (size-of-type-id-as-array-element %edx) # => eax +13124 f7 4/subop/multiply-into-eax %ecx +13125 05/add-to-eax 4/imm32 # for array size +13126 $size-of-array:end: +13127 # . restore registers +13128 5a/pop-to-edx +13129 59/pop-to-ecx +13130 # . epilogue +13131 89/<- %esp 5/r32/ebp +13132 5d/pop-to-ebp +13133 c3/return +13134 +13135 is-mu-stream?: # t: (addr type-tree) -> result/eax: boolean +13136 # . prologue +13137 55/push-ebp +13138 89/<- %ebp 4/r32/esp +13139 # . save registers +13140 51/push-ecx +13141 # ecx = t +13142 8b/-> *(ebp+8) 1/r32/ecx +13143 # if t->is-atom?, return false +13144 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +13145 75/jump-if-!= $is-mu-stream?:return-false/disp8 +13146 # if !t->left->is-atom?, return false +13147 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13148 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +13149 74/jump-if-= $is-mu-stream?:return-false/disp8 +13150 # return t->left->value == stream +13151 81 7/subop/compare *(eax+4) 0xb/imm32/stream-type-id # Type-tree-value +13152 0f 94/set-if-= %al +13153 81 4/subop/and %eax 0xff/imm32 +13154 eb/jump $is-mu-stream?:end/disp8 +13155 $is-mu-stream?:return-false: +13156 b8/copy-to-eax 0/imm32/false +13157 $is-mu-stream?:end: +13158 # . restore registers +13159 59/pop-to-ecx +13160 # . epilogue +13161 89/<- %esp 5/r32/ebp +13162 5d/pop-to-ebp +13163 c3/return +13164 +13165 # size of a statically allocated stream where the size is part of the type expression +13166 size-of-stream: # a: (addr type-tree) -> result/eax: int +13167 # . prologue +13168 55/push-ebp +13169 89/<- %ebp 4/r32/esp +13170 # +13171 (size-of-array *(ebp+8)) # assumes we ignore the actual type name 'array' in the type +13172 05/add-to-eax 8/imm32 # for read/write pointers +13173 $size-of-stream:end: +13174 # . epilogue +13175 89/<- %esp 5/r32/ebp +13176 5d/pop-to-ebp +13177 c3/return +13178 +13179 size-of-type-id: # t: type-id -> result/eax: int +13180 # . prologue +13181 55/push-ebp +13182 89/<- %ebp 4/r32/esp +13183 # . save registers +13184 51/push-ecx +13185 # var out/ecx: (handle typeinfo) +13186 68/push 0/imm32 +13187 68/push 0/imm32 +13188 89/<- %ecx 4/r32/esp +13189 # eax = t +13190 8b/-> *(ebp+8) 0/r32/eax +13191 # if t is a literal, return 0 +13192 3d/compare-eax-and 0/imm32 +13193 0f 84/jump-if-= $size-of-type-id:end/disp32 # eax changes type from type-id to int +13194 # if t is a byte, return 4 (because we don't really support non-multiples of 4) +13195 3d/compare-eax-and 8/imm32/byte +13196 { +13197 75/jump-if-!= break/disp8 +13198 b8/copy-to-eax 4/imm32 +13199 eb/jump $size-of-type-id:end/disp8 +13200 } +13201 # if t is a handle, return 8 +13202 3d/compare-eax-and 4/imm32/handle +13203 { +13204 75/jump-if-!= break/disp8 +13205 b8/copy-to-eax 8/imm32 +13206 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int +13207 } +13208 # if t is a user-defined type, return its size +13209 # TODO: support non-atom type +13210 (find-typeinfo %eax %ecx) +13211 { +13212 81 7/subop/compare *ecx 0/imm32 +13213 74/jump-if-= break/disp8 +13214 $size-of-type-id:user-defined: +13215 (lookup *ecx *(ecx+4)) # => eax +13216 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes +13217 eb/jump $size-of-type-id:end/disp8 +13218 } +13219 # otherwise return the word size +13220 b8/copy-to-eax 4/imm32 +13221 $size-of-type-id:end: +13222 # . reclaim locals +13223 81 0/subop/add %esp 8/imm32 +13224 # . restore registers +13225 59/pop-to-ecx +13226 # . epilogue +13227 89/<- %esp 5/r32/ebp +13228 5d/pop-to-ebp +13229 c3/return +13230 +13231 type-equal?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean +13232 # . prologue +13233 55/push-ebp +13234 89/<- %ebp 4/r32/esp +13235 # . save registers +13236 51/push-ecx +13237 52/push-edx +13238 53/push-ebx +13239 # ecx = a +13240 8b/-> *(ebp+8) 1/r32/ecx +13241 # edx = b +13242 8b/-> *(ebp+0xc) 2/r32/edx +13243 $type-equal?:compare-addr: +13244 # if (a == b) return true +13245 8b/-> %ecx 0/r32/eax # Var-type +13246 39/compare %edx 0/r32/eax # Var-type +13247 b8/copy-to-eax 1/imm32/true +13248 0f 84/jump-if-= $type-equal?:end/disp32 +13249 $type-equal?:compare-atom-state: +13250 # if (a->is-atom? != b->is-atom?) return false +13251 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom +13252 39/compare *edx 3/r32/ebx # Type-tree-is-atom +13253 b8/copy-to-eax 0/imm32/false +13254 0f 85/jump-if-!= $type-equal?:end/disp32 +13255 # if a->is-atom? return (a->value == b->value) +13256 { +13257 $type-equal?:check-atom: +13258 81 7/subop/compare %ebx 0/imm32/false +13259 74/jump-if-= break/disp8 +13260 $type-equal?:is-atom: +13261 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value +13262 39/compare *(edx+4) 0/r32/eax # Type-tree-value +13263 0f 94/set-if-= %al +13264 81 4/subop/and %eax 0xff/imm32 +13265 e9/jump $type-equal?:end/disp32 +13266 } +13267 $type-equal?:check-left: +13268 # if (!type-equal?(a->left, b->left)) return false +13269 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +13270 89/<- %ebx 0/r32/eax +13271 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +13272 (type-equal? %eax %ebx) # => eax +13273 3d/compare-eax-and 0/imm32/false +13274 74/jump-if-= $type-equal?:end/disp8 +13275 $type-equal?:check-right: +13276 # return type-equal?(a->right, b->right) +13277 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +13278 89/<- %ebx 0/r32/eax +13279 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +13280 (type-equal? %eax %ebx) # => eax +13281 $type-equal?:end: +13282 # . restore registers +13283 5b/pop-to-ebx +13284 5a/pop-to-edx +13285 59/pop-to-ecx +13286 # . epilogue +13287 89/<- %esp 5/r32/ebp +13288 5d/pop-to-ebp +13289 c3/return +13290 +13291 ####################################################### +13292 # Code-generation +13293 ####################################################### +13294 +13295 == data +13296 +13297 # Global state added to each var record when performing code-generation. +13298 Curr-local-stack-offset: # (addr int) +13299 0/imm32 +13300 +13301 == code +13302 +13303 emit-subx: # out: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) +13304 # . prologue +13305 55/push-ebp +13306 89/<- %ebp 4/r32/esp +13307 # . save registers +13308 50/push-eax +13309 # var curr/eax: (addr function) = *Program->functions +13310 (lookup *_Program-functions *_Program-functions->payload) # => eax +13311 { +13312 # if (curr == null) break +13313 3d/compare-eax-and 0/imm32 +13314 0f 84/jump-if-= break/disp32 +13315 (emit-subx-function *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) +13316 # curr = lookup(curr->next) +13317 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax +13318 e9/jump loop/disp32 +13319 } +13320 $emit-subx:end: +13321 # . restore registers +13322 58/pop-to-eax +13323 # . epilogue +13324 89/<- %esp 5/r32/ebp +13325 5d/pop-to-ebp +13326 c3/return +13327 +13328 emit-subx-function: # out: (addr buffered-file), f: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +13329 # . prologue +13330 55/push-ebp +13331 89/<- %ebp 4/r32/esp +13332 # some preprocessing +13333 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) +13334 # . save registers +13335 50/push-eax +13336 51/push-ecx +13337 52/push-edx +13338 # initialize some global state +13339 c7 0/subop/copy *Curr-block-depth 1/imm32 # Important: keep this in sync with the parse phase +13340 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 +13341 # ecx = f +13342 8b/-> *(ebp+0xc) 1/r32/ecx +13343 # var vars/edx: (stack (addr var) 256) +13344 81 5/subop/subtract %esp 0xc00/imm32 +13345 68/push 0xc00/imm32/size +13346 68/push 0/imm32/top +13347 89/<- %edx 4/r32/esp +13348 # var name/eax: (addr array byte) = lookup(f->name) +13349 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +13350 # +13351 (write-buffered *(ebp+8) %eax) +13352 (write-buffered *(ebp+8) ":\n") +13353 (emit-subx-prologue *(ebp+8)) +13354 # var body/eax: (addr block) = lookup(f->body) +13355 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax +13356 # +13357 (emit-subx-block *(ebp+8) %eax %edx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +13358 (emit-subx-epilogue *(ebp+8)) +13359 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have +13360 # been cleaned up +13361 $emit-subx-function:end: +13362 # . reclaim locals +13363 81 0/subop/add %esp 0xc08/imm32 +13364 # . restore registers +13365 5a/pop-to-edx +13366 59/pop-to-ecx +13367 58/pop-to-eax +13368 # . epilogue +13369 89/<- %esp 5/r32/ebp +13370 5d/pop-to-ebp +13371 c3/return +13372 +13373 populate-mu-type-offsets-in-inouts: # f: (addr function) +13374 # . prologue +13375 55/push-ebp +13376 89/<- %ebp 4/r32/esp +13377 # . save registers +13378 50/push-eax +13379 51/push-ecx +13380 52/push-edx +13381 53/push-ebx +13382 57/push-edi +13383 # var next-offset/edx: int = 8 +13384 ba/copy-to-edx 8/imm32 +13385 # var curr/ecx: (addr list var) = lookup(f->inouts) +13386 8b/-> *(ebp+8) 1/r32/ecx +13387 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax +13388 89/<- %ecx 0/r32/eax +13389 { +13390 $populate-mu-type-offsets-in-inouts:loop: +13391 81 7/subop/compare %ecx 0/imm32 +13392 74/jump-if-= break/disp8 +13393 # var v/ebx: (addr var) = lookup(curr->value) +13394 (lookup *ecx *(ecx+4)) # List-value List-value => eax +13395 89/<- %ebx 0/r32/eax +13396 #? (lookup *ebx *(ebx+4)) +13397 #? (write-buffered Stderr "setting offset of fn inout ") +13398 #? (write-buffered Stderr %eax) +13399 #? (write-buffered Stderr "@") +13400 #? (write-int32-hex-buffered Stderr %ebx) +13401 #? (write-buffered Stderr " to ") +13402 #? (write-int32-hex-buffered Stderr %edx) +13403 #? (write-buffered Stderr Newline) +13404 #? (flush Stderr) +13405 # v->offset = next-offset +13406 89/<- *(ebx+0x14) 2/r32/edx # Var-offset +13407 # next-offset += size-of(v) +13408 (size-of %ebx) # => eax +13409 01/add-to %edx 0/r32/eax +13410 # curr = lookup(curr->next) +13411 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +13412 89/<- %ecx 0/r32/eax +13413 # +13414 eb/jump loop/disp8 +13415 } +13416 $populate-mu-type-offsets-in-inouts:end: +13417 # . restore registers +13418 5f/pop-to-edi +13419 5b/pop-to-ebx +13420 5a/pop-to-edx +13421 59/pop-to-ecx +13422 58/pop-to-eax +13423 # . epilogue +13424 89/<- %esp 5/r32/ebp +13425 5d/pop-to-ebp +13426 c3/return +13427 +13428 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +13429 # . prologue +13430 55/push-ebp +13431 89/<- %ebp 4/r32/esp +13432 # . save registers +13433 50/push-eax +13434 51/push-ecx +13435 53/push-ebx +13436 56/push-esi +13437 # esi = stmts +13438 8b/-> *(ebp+0xc) 6/r32/esi +13439 # +13440 { +13441 $emit-subx-stmt-list:loop: +13442 81 7/subop/compare %esi 0/imm32 +13443 0f 84/jump-if-= break/disp32 +13444 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) +13445 (lookup *esi *(esi+4)) # List-value List-value => eax +13446 89/<- %ecx 0/r32/eax +13447 { +13448 $emit-subx-stmt-list:check-for-block: +13449 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag +13450 75/jump-if-!= break/disp8 +13451 $emit-subx-stmt-list:block: +13452 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +13453 } +13454 { +13455 $emit-subx-stmt-list:check-for-stmt: +13456 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag +13457 0f 85/jump-if-!= break/disp32 +13458 $emit-subx-stmt-list:stmt1: +13459 { +13460 (is-mu-branch? %ecx) # => eax +13461 3d/compare-eax-and 0/imm32/false +13462 0f 84/jump-if-= break/disp32 +13463 $emit-subx-stmt-list:branch-stmt: +13464 +-- 27 lines: # unconditional loops ----------------------------------------------------------------------------------------------------------------------------------------------------- +13491 +-- 16 lines: # unconditional breaks ---------------------------------------------------------------------------------------------------------------------------------------------------- +13507 +-- 38 lines: # simple conditional branches without a target ---------------------------------------------------------------------------------------------------------------------------- +13545 +-- 19 lines: # conditional branches with an explicit target ---------------------------------------------------------------------------------------------------------------------------- +13564 } +13565 $emit-subx-stmt-list:1-to-1: +13566 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) +13567 e9/jump $emit-subx-stmt-list:continue/disp32 +13568 } +13569 { +13570 $emit-subx-stmt-list:check-for-var-def: +13571 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag +13572 75/jump-if-!= break/disp8 +13573 $emit-subx-stmt-list:var-def: +13574 (emit-subx-var-def *(ebp+8) %ecx) +13575 (push *(ebp+0x10) *(ecx+4)) # Vardef-var +13576 (push *(ebp+0x10) *(ecx+8)) # Vardef-var +13577 (push *(ebp+0x10) 0) # Live-var-register-spilled = 0 for vars on the stack +13578 # +13579 eb/jump $emit-subx-stmt-list:continue/disp8 +13580 } +13581 { +13582 $emit-subx-stmt-list:check-for-reg-var-def: +13583 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag +13584 0f 85/jump-if-!= break/disp32 +13585 $emit-subx-stmt-list:reg-var-def: +13586 # TODO: ensure that there's exactly one output +13587 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +13588 # emit the instruction as usual +13589 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) +13590 # +13591 eb/jump $emit-subx-stmt-list:continue/disp8 +13592 } +13593 $emit-subx-stmt-list:continue: +13594 # TODO: raise an error on unrecognized Stmt-tag +13595 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax +13596 89/<- %esi 0/r32/eax +13597 e9/jump loop/disp32 +13598 } +13599 $emit-subx-stmt-list:emit-cleanup: +13600 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) +13601 $emit-subx-stmt-list:clean-up: +13602 (clean-up-blocks *(ebp+0x10) *Curr-block-depth *(ebp+0x14)) +13603 $emit-subx-stmt-list:end: +13604 # . restore registers +13605 5e/pop-to-esi +13606 5b/pop-to-ebx +13607 59/pop-to-ecx +13608 58/pop-to-eax +13609 # . epilogue +13610 89/<- %esp 5/r32/ebp +13611 5d/pop-to-ebp +13612 c3/return +13613 +13614 # 'later-stmts' includes 'stmt', but will behave the same even without it; reg-var-def stmts are guaranteed not to write to function outputs. +13615 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)), later-stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +13616 # . prologue +13617 55/push-ebp +13618 89/<- %ebp 4/r32/esp +13619 # . save registers +13620 50/push-eax 13621 51/push-ecx -13622 # ecx = lookup(stmt->operation) -13623 8b/-> *(ebp+8) 1/r32/ecx -13624 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -13625 89/<- %ecx 0/r32/eax -13626 # if (stmt->operation starts with "loop") return true -13627 (string-starts-with? %ecx "loop") # => eax -13628 3d/compare-eax-and 0/imm32/false -13629 75/jump-if-not-equal $is-mu-branch?:end/disp8 -13630 # otherwise return (stmt->operation starts with "break") -13631 (string-starts-with? %ecx "break") # => eax -13632 $is-mu-branch?:end: -13633 # . restore registers -13634 59/pop-to-ecx -13635 # . epilogue -13636 89/<- %esp 5/r32/ebp -13637 5d/pop-to-ebp -13638 c3/return -13639 -13640 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) -13641 # . prologue -13642 55/push-ebp -13643 89/<- %ebp 4/r32/esp -13644 # . save registers -13645 50/push-eax -13646 # eax = stmt -13647 8b/-> *(ebp+0xc) 0/r32/eax -13648 # -13649 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -13650 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) -13651 (emit-indent *(ebp+8) *Curr-block-depth) -13652 (lookup *eax *(eax+4)) # => eax -13653 (write-buffered *(ebp+8) %eax) -13654 (write-buffered *(ebp+8) " break/disp32\n") -13655 $emit-reverse-break:end: -13656 # . restore registers -13657 58/pop-to-eax -13658 # . epilogue -13659 89/<- %esp 5/r32/ebp -13660 5d/pop-to-ebp -13661 c3/return -13662 -13663 == data -13664 -13665 # Table from Mu branch instructions to the reverse SubX opcodes for them. -13666 Reverse-branch: # (table (handle array byte) (handle array byte)) -13667 # a table is a stream -13668 0x140/imm32/write -13669 0/imm32/read -13670 0x140/imm32/size -13671 # data -13672 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 -13673 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 -13674 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 -13675 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 -13676 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 -13677 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 -13678 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 -13679 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 -13680 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -13681 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -13682 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 -13683 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 -13684 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -13685 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -13686 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -13687 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -13688 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -13689 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -13690 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -13691 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -13692 -13693 == code -13694 -13695 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack live-var), depth: int, label-suffix: (addr array byte) -13696 # . prologue -13697 55/push-ebp -13698 89/<- %ebp 4/r32/esp -13699 # . save registers -13700 50/push-eax -13701 51/push-ecx -13702 52/push-edx -13703 53/push-ebx -13704 56/push-esi -13705 # ecx = vars -13706 8b/-> *(ebp+0xc) 1/r32/ecx -13707 # var eax: int = vars->top -13708 8b/-> *ecx 0/r32/eax -13709 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -13710 8d/copy-address *(ecx+eax-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -13711 # var min/ecx: (addr handle var) = vars->data -13712 8d/copy-address *(ecx+8) 1/r32/ecx -13713 # edx = depth -13714 8b/-> *(ebp+0x10) 2/r32/edx -13715 { -13716 $emit-unconditional-jump-to-depth:loop: -13717 # if (curr < min) break -13718 39/compare %esi 1/r32/ecx -13719 0f 82/jump-if-addr< break/disp32 -13720 # var v/ebx: (addr var) = lookup(*curr) -13721 (lookup *esi *(esi+4)) # => eax -13722 89/<- %ebx 0/r32/eax -13723 # if (v->block-depth < until-block-depth) break -13724 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -13725 0f 8c/jump-if-< break/disp32 -13726 { -13727 $emit-unconditional-jump-to-depth:check: -13728 # if v->block-depth != until-block-depth, continue -13729 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -13730 0f 85/jump-if-!= break/disp32 -13731 $emit-unconditional-jump-to-depth:depth-found: -13732 # if v is not a literal, continue -13733 (size-of %ebx) # => eax -13734 3d/compare-eax-and 0/imm32 -13735 0f 85/jump-if-!= break/disp32 -13736 $emit-unconditional-jump-to-depth:label-found: -13737 # emit unconditional jump, then return -13738 (emit-indent *(ebp+8) *Curr-block-depth) -13739 (write-buffered *(ebp+8) "e9/jump ") -13740 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -13741 (write-buffered *(ebp+8) %eax) -13742 (write-buffered *(ebp+8) ":") -13743 (write-buffered *(ebp+8) *(ebp+0x14)) -13744 (write-buffered *(ebp+8) "/disp32\n") -13745 eb/jump $emit-unconditional-jump-to-depth:end/disp8 -13746 } -13747 # curr -= 12 -13748 81 5/subop/subtract %esi 0xc/imm32 -13749 e9/jump loop/disp32 -13750 } -13751 # TODO: error if no label at 'depth' was found -13752 $emit-unconditional-jump-to-depth:end: -13753 # . restore registers -13754 5e/pop-to-esi -13755 5b/pop-to-ebx -13756 5a/pop-to-edx -13757 59/pop-to-ecx -13758 58/pop-to-eax -13759 # . epilogue -13760 89/<- %esp 5/r32/ebp -13761 5d/pop-to-ebp -13762 c3/return -13763 -13764 # emit clean-up code for 'vars' until some block depth -13765 # doesn't actually modify 'vars' so we need traverse manually inside the stack -13766 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack live-var), until-block-depth: int -13767 # . prologue -13768 55/push-ebp -13769 89/<- %ebp 4/r32/esp -13770 # . save registers -13771 50/push-eax -13772 51/push-ecx -13773 52/push-edx -13774 53/push-ebx -13775 56/push-esi -13776 #? (write-buffered Stderr "--- cleanup\n") -13777 #? (flush Stderr) -13778 # ecx = vars -13779 8b/-> *(ebp+0xc) 1/r32/ecx -13780 # var esi: int = vars->top -13781 8b/-> *ecx 6/r32/esi -13782 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -13783 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -13784 # var min/ecx: (addr handle var) = vars->data -13785 81 0/subop/add %ecx 8/imm32 -13786 # edx = until-block-depth -13787 8b/-> *(ebp+0x10) 2/r32/edx -13788 { -13789 $emit-cleanup-code-until-depth:loop: -13790 # if (curr < min) break -13791 39/compare %esi 1/r32/ecx -13792 0f 82/jump-if-addr< break/disp32 -13793 # var v/ebx: (addr var) = lookup(*curr) -13794 (lookup *esi *(esi+4)) # => eax -13795 89/<- %ebx 0/r32/eax -13796 #? (lookup *ebx *(ebx+4)) # Var-name -13797 #? (write-buffered Stderr "var ") -13798 #? (write-buffered Stderr %eax) -13799 #? (write-buffered Stderr Newline) -13800 #? (flush Stderr) -13801 # if (v->block-depth < until-block-depth) break -13802 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -13803 0f 8c/jump-if-< break/disp32 -13804 # if v is in a register -13805 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -13806 { -13807 0f 84/jump-if-= break/disp32 -13808 { -13809 $emit-cleanup-code-until-depth:check-for-previous-spill: -13810 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled -13811 3d/compare-eax-and 0/imm32/false -13812 74/jump-if-= break/disp8 -13813 $emit-cleanup-code-until-depth:reclaim-var-in-register: -13814 (emit-indent *(ebp+8) *Curr-block-depth) -13815 (write-buffered *(ebp+8) "8f 0/subop/pop %") -13816 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -13817 (write-buffered *(ebp+8) %eax) -13818 (write-buffered *(ebp+8) Newline) -13819 } -13820 eb/jump $emit-cleanup-code-until-depth:continue/disp8 -13821 } -13822 # otherwise v is on the stack -13823 { -13824 75/jump-if-!= break/disp8 -13825 $emit-cleanup-code-until-depth:var-on-stack: -13826 (size-of %ebx) # => eax -13827 # don't emit code for labels -13828 3d/compare-eax-and 0/imm32 -13829 74/jump-if-= break/disp8 -13830 $emit-cleanup-code-until-depth:reclaim-var-on-stack: -13831 (emit-indent *(ebp+8) *Curr-block-depth) -13832 (write-buffered *(ebp+8) "81 0/subop/add %esp ") -13833 (write-int32-hex-buffered *(ebp+8) %eax) -13834 (write-buffered *(ebp+8) "/imm32\n") -13835 } -13836 $emit-cleanup-code-until-depth:continue: -13837 # curr -= 12 -13838 81 5/subop/subtract %esi 0xc/imm32 -13839 e9/jump loop/disp32 -13840 } -13841 $emit-cleanup-code-until-depth:end: -13842 # . restore registers -13843 5e/pop-to-esi -13844 5b/pop-to-ebx -13845 5a/pop-to-edx -13846 59/pop-to-ecx -13847 58/pop-to-eax -13848 # . epilogue -13849 89/<- %esp 5/r32/ebp -13850 5d/pop-to-ebp -13851 c3/return -13852 -13853 # emit clean-up code for 'vars' until a given label is encountered -13854 # doesn't actually modify 'vars' so we need traverse manually inside the stack -13855 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack live-var), until-block-label: (addr array byte) -13856 # . prologue -13857 55/push-ebp -13858 89/<- %ebp 4/r32/esp -13859 # . save registers -13860 50/push-eax -13861 51/push-ecx -13862 52/push-edx -13863 53/push-ebx -13864 # ecx = vars -13865 8b/-> *(ebp+0xc) 1/r32/ecx -13866 # var eax: int = vars->top -13867 8b/-> *ecx 0/r32/eax -13868 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] -13869 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size -13870 # var min/ecx: (addr handle var) = vars->data -13871 81 0/subop/add %ecx 8/imm32 -13872 { -13873 $emit-cleanup-code-until-target:loop: -13874 # if (curr < min) break -13875 39/compare %edx 1/r32/ecx -13876 0f 82/jump-if-addr< break/disp32 -13877 # var v/ebx: (handle var) = lookup(*curr) -13878 (lookup *edx *(edx+4)) # => eax -13879 89/<- %ebx 0/r32/eax -13880 # if (v->name == until-block-label) break -13881 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -13882 (string-equal? %eax *(ebp+0x10)) # => eax -13883 3d/compare-eax-and 0/imm32/false -13884 0f 85/jump-if-!= break/disp32 -13885 # if v is in a register -13886 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -13887 { -13888 0f 84/jump-if-= break/disp32 -13889 { -13890 $emit-cleanup-code-until-target:check-for-previous-spill: -13891 8b/-> *(edx+8) 0/r32/eax # Live-var-register-spilled -13892 3d/compare-eax-and 0/imm32/false -13893 74/jump-if-= break/disp8 -13894 $emit-cleanup-code-until-target:reclaim-var-in-register: -13895 (emit-indent *(ebp+8) *Curr-block-depth) -13896 (write-buffered *(ebp+8) "8f 0/subop/pop %") -13897 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -13898 (write-buffered *(ebp+8) %eax) -13899 (write-buffered *(ebp+8) Newline) -13900 } -13901 eb/jump $emit-cleanup-code-until-target:continue/disp8 -13902 } -13903 # otherwise v is on the stack -13904 { -13905 75/jump-if-!= break/disp8 -13906 $emit-cleanup-code-until-target:reclaim-var-on-stack: -13907 (size-of %ebx) # => eax -13908 # don't emit code for labels -13909 3d/compare-eax-and 0/imm32 -13910 74/jump-if-= break/disp8 -13911 # -13912 (emit-indent *(ebp+8) *Curr-block-depth) -13913 (write-buffered *(ebp+8) "81 0/subop/add %esp ") -13914 (write-int32-hex-buffered *(ebp+8) %eax) -13915 (write-buffered *(ebp+8) "/imm32\n") -13916 } -13917 $emit-cleanup-code-until-target:continue: -13918 # curr -= 12 -13919 81 5/subop/subtract %edx 0xc/imm32 -13920 e9/jump loop/disp32 -13921 } -13922 $emit-cleanup-code-until-target:end: -13923 # . restore registers -13924 5b/pop-to-ebx -13925 5a/pop-to-edx -13926 59/pop-to-ecx -13927 58/pop-to-eax -13928 # . epilogue -13929 89/<- %esp 5/r32/ebp -13930 5d/pop-to-ebp -13931 c3/return -13932 -13933 # Return true if there isn't a variable in 'vars' with the same block-depth -13934 # and register as 'v'. -13935 # 'v' is guaranteed not to be within 'vars'. -13936 not-yet-spilled-this-block?: # v: (addr var), vars: (addr stack live-var) -> result/eax: boolean -13937 # . prologue -13938 55/push-ebp -13939 89/<- %ebp 4/r32/esp -13940 # . save registers -13941 51/push-ecx -13942 52/push-edx -13943 53/push-ebx -13944 56/push-esi -13945 57/push-edi -13946 # ecx = vars -13947 8b/-> *(ebp+0xc) 1/r32/ecx -13948 # var eax: int = vars->top -13949 8b/-> *ecx 0/r32/eax -13950 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] -13951 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size -13952 # var min/ecx: (addr handle var) = vars->data -13953 8d/copy-address *(ecx+8) 1/r32/ecx -13954 # var depth/ebx: int = v->block-depth -13955 8b/-> *(ebp+8) 3/r32/ebx -13956 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth -13957 # var needle/esi: (addr array byte) = v->register -13958 8b/-> *(ebp+8) 6/r32/esi -13959 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -13960 89/<- %esi 0/r32/eax -13961 { -13962 $not-yet-spilled-this-block?:loop: -13963 # if (curr < min) break -13964 39/compare %edx 1/r32/ecx -13965 0f 82/jump-if-addr< break/disp32 -13966 # var cand/edi: (addr var) = lookup(*curr) -13967 (lookup *edx *(edx+4)) # => eax -13968 89/<- %edi 0/r32/eax -13969 # if (cand->block-depth < depth) break -13970 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth -13971 0f 8c/jump-if-< break/disp32 -13972 # var cand-reg/edi: (array array byte) = cand->reg -13973 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -13974 89/<- %edi 0/r32/eax -13975 # if (cand-reg == null) continue -13976 { -13977 $not-yet-spilled-this-block?:check-reg: -13978 81 7/subop/compare %edi 0/imm32 -13979 0f 84/jump-if-= break/disp32 -13980 # if (cand-reg == needle) return true -13981 (string-equal? %esi %edi) # => eax -13982 3d/compare-eax-and 0/imm32/false -13983 74/jump-if-= break/disp8 -13984 $not-yet-spilled-this-block?:return-false: -13985 b8/copy-to-eax 0/imm32/false -13986 eb/jump $not-yet-spilled-this-block?:end/disp8 -13987 } -13988 $not-yet-spilled-this-block?:continue: -13989 # curr -= 12 -13990 81 5/subop/subtract %edx 0xc/imm32 -13991 e9/jump loop/disp32 -13992 } -13993 $not-yet-spilled-this-block?:return-true: -13994 # return true -13995 b8/copy-to-eax 1/imm32/true -13996 $not-yet-spilled-this-block?:end: -13997 # . restore registers -13998 5f/pop-to-edi -13999 5e/pop-to-esi -14000 5b/pop-to-ebx -14001 5a/pop-to-edx -14002 59/pop-to-ecx -14003 # . epilogue -14004 89/<- %esp 5/r32/ebp -14005 5d/pop-to-ebp -14006 c3/return -14007 -14008 # could the register of 'v' ever be written to by one of the vars in fn-outputs? -14009 will-not-write-some-register?: # v: (addr var), stmts: (addr list stmt), fn: (addr function) -> result/eax: boolean -14010 # . prologue -14011 55/push-ebp -14012 89/<- %ebp 4/r32/esp -14013 # eax = v -14014 8b/-> *(ebp+8) 0/r32/eax -14015 # var reg/eax: (addr array byte) = lookup(v->register) -14016 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -14017 # var target/eax: (addr var) = find-register(fn-outputs, reg) -14018 (find-register *(ebp+0x10) %eax) # => eax -14019 # if (target == 0) return true -14020 { -14021 3d/compare-eax-and 0/imm32 -14022 75/jump-if-!= break/disp8 -14023 b8/copy-to-eax 1/imm32/true -14024 eb/jump $will-not-write-some-register?:end/disp8 -14025 } -14026 # return !assigns-in-stmts?(stmts, target) -14027 (assigns-in-stmts? *(ebp+0xc) %eax) # => eax -14028 3d/compare-eax-and 0/imm32/false -14029 # assume: true = 1, so no need to mask with 0x000000ff -14030 0f 94/set-if-= %al -14031 $will-not-write-some-register?:end: -14032 # . epilogue -14033 89/<- %esp 5/r32/ebp -14034 5d/pop-to-ebp -14035 c3/return -14036 -14037 # return fn output with matching register -14038 # always returns false if 'reg' is null -14039 find-register: # fn: (addr function), reg: (addr array byte) -> result/eax: (addr var) -14040 # . prologue -14041 55/push-ebp -14042 89/<- %ebp 4/r32/esp -14043 # . save registers -14044 51/push-ecx -14045 # var curr/ecx: (addr list var) = lookup(fn->outputs) -14046 8b/-> *(ebp+8) 1/r32/ecx -14047 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax -14048 89/<- %ecx 0/r32/eax -14049 { -14050 $find-register:loop: -14051 # if (curr == 0) break -14052 81 7/subop/compare %ecx 0/imm32 -14053 74/jump-if-= break/disp8 -14054 # eax = curr->value->register -14055 (lookup *ecx *(ecx+4)) # List-value List-value => eax -14056 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -14057 # if (eax == reg) return curr->value -14058 $find-register:compare: -14059 (string-equal? *(ebp+0xc) %eax) # => eax -14060 { -14061 3d/compare-eax-and 0/imm32/false -14062 74/jump-if-= break/disp8 -14063 $find-register:found: -14064 (lookup *ecx *(ecx+4)) # List-value List-value => eax -14065 eb/jump $find-register:end/disp8 -14066 } -14067 # curr = lookup(curr->next) -14068 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -14069 89/<- %ecx 0/r32/eax -14070 # -14071 eb/jump loop/disp8 -14072 } -14073 $find-register:end: -14074 # . restore registers -14075 59/pop-to-ecx -14076 # . epilogue -14077 89/<- %esp 5/r32/ebp -14078 5d/pop-to-ebp -14079 c3/return -14080 -14081 assigns-in-stmts?: # stmts: (addr list stmt), v: (addr var) -> result/eax: boolean -14082 # . prologue -14083 55/push-ebp -14084 89/<- %ebp 4/r32/esp -14085 # . save registers -14086 51/push-ecx -14087 # var curr/ecx: (addr list stmt) = stmts -14088 8b/-> *(ebp+8) 1/r32/ecx -14089 { -14090 # if (curr == 0) break -14091 81 7/subop/compare %ecx 0/imm32 -14092 74/jump-if-= break/disp8 -14093 # if assigns-in-stmt?(curr->value, v) return true -14094 (lookup *ecx *(ecx+4)) # List-value List-value => eax -14095 (assigns-in-stmt? %eax *(ebp+0xc)) # => eax -14096 3d/compare-eax-and 0/imm32/false -14097 75/jump-if-!= break/disp8 -14098 # curr = lookup(curr->next) -14099 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -14100 89/<- %ecx 0/r32/eax -14101 # -14102 eb/jump loop/disp8 -14103 } -14104 $assigns-in-stmts?:end: -14105 # . restore registers -14106 59/pop-to-ecx -14107 # . epilogue -14108 89/<- %esp 5/r32/ebp -14109 5d/pop-to-ebp -14110 c3/return -14111 -14112 assigns-in-stmt?: # stmt: (addr stmt), v: (addr var) -> result/eax: boolean -14113 # . prologue -14114 55/push-ebp -14115 89/<- %ebp 4/r32/esp -14116 # . save registers -14117 51/push-ecx -14118 # ecx = stmt -14119 8b/-> *(ebp+8) 1/r32/ecx -14120 # if stmt is a stmt1, return assigns-in-stmt-vars?(stmt->outputs, v) -14121 { -14122 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag -14123 75/jump-if-!= break/disp8 -14124 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -14125 (assigns-in-stmt-vars? %eax *(ebp+0xc)) # => eax -14126 eb/jump $assigns-in-stmt?:end/disp8 -14127 } -14128 # if stmt is a block, return assigns-in-stmts?(stmt->stmts, v) -14129 { -14130 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag -14131 75/jump-if-!= break/disp8 -14132 (lookup *(ecx+4) *(ecx+8)) # Block-stmts Block-stmts => eax -14133 (assigns-in-stmts? %eax *(ebp+0xc)) # => eax -14134 eb/jump $assigns-in-stmt?:end/disp8 -14135 } -14136 # otherwise return false -14137 b8/copy 0/imm32/false -14138 $assigns-in-stmt?:end: -14139 # . restore registers -14140 59/pop-to-ecx -14141 # . epilogue -14142 89/<- %esp 5/r32/ebp -14143 5d/pop-to-ebp -14144 c3/return -14145 -14146 assigns-in-stmt-vars?: # stmt-var: (addr stmt-var), v: (addr var) -> result/eax: boolean -14147 # . prologue -14148 55/push-ebp -14149 89/<- %ebp 4/r32/esp -14150 # . save registers -14151 51/push-ecx -14152 # var curr/ecx: (addr stmt-var) = stmt-var -14153 8b/-> *(ebp+8) 1/r32/ecx -14154 { -14155 # if (curr == 0) break -14156 81 7/subop/compare %ecx 0/imm32 -14157 74/jump-if-= break/disp8 -14158 # eax = lookup(curr->value) -14159 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -14160 # if (eax == v && curr->is-deref? == false) return true -14161 { -14162 39/compare *(ebp+0xc) 0/r32/eax -14163 75/jump-if-!= break/disp8 -14164 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -14165 75/jump-if-!= break/disp8 -14166 b8/copy-to-eax 1/imm32/true -14167 eb/jump $assigns-in-stmt-vars?:end/disp8 -14168 } -14169 # curr = lookup(curr->next) -14170 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -14171 89/<- %ecx 0/r32/eax -14172 # -14173 eb/jump loop/disp8 -14174 } -14175 $assigns-in-stmt-vars?:end: -14176 # . restore registers -14177 59/pop-to-ecx -14178 # . epilogue -14179 89/<- %esp 5/r32/ebp -14180 5d/pop-to-ebp -14181 c3/return -14182 -14183 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? -14184 # v is guaranteed to be within vars -14185 # 'start' is provided as an optimization, a pointer within vars -14186 # *start == v -14187 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean -14188 # . prologue -14189 55/push-ebp -14190 89/<- %ebp 4/r32/esp -14191 # . save registers -14192 51/push-ecx -14193 52/push-edx -14194 53/push-ebx -14195 56/push-esi -14196 57/push-edi -14197 # ecx = v -14198 8b/-> *(ebp+8) 1/r32/ecx -14199 # var reg/edx: (addr array byte) = lookup(v->register) -14200 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -14201 89/<- %edx 0/r32/eax -14202 # var depth/ebx: int = v->block-depth -14203 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth -14204 # var min/ecx: (addr handle var) = vars->data -14205 8b/-> *(ebp+0xc) 1/r32/ecx -14206 81 0/subop/add %ecx 8/imm32 -14207 # TODO: check that start >= min and start < &vars->data[top] -14208 # TODO: check that *start == v -14209 # var curr/esi: (addr handle var) = start -14210 8b/-> *(ebp+0x10) 6/r32/esi -14211 # curr -= 8 -14212 81 5/subop/subtract %esi 8/imm32 -14213 { -14214 $same-register-spilled-before?:loop: -14215 # if (curr < min) break -14216 39/compare %esi 1/r32/ecx -14217 0f 82/jump-if-addr< break/disp32 -14218 # var x/eax: (addr var) = lookup(*curr) -14219 (lookup *esi *(esi+4)) # => eax -14220 # if (x->block-depth < depth) break -14221 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth -14222 0f 8c/jump-if-< break/disp32 -14223 # if (x->register == 0) continue -14224 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -14225 74/jump-if-= $same-register-spilled-before?:continue/disp8 -14226 # if (x->register == reg) return true -14227 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -14228 (string-equal? %eax %edx) # => eax -14229 3d/compare-eax-and 0/imm32/false -14230 b8/copy-to-eax 1/imm32/true -14231 75/jump-if-!= $same-register-spilled-before?:end/disp8 -14232 $same-register-spilled-before?:continue: -14233 # curr -= 8 -14234 81 5/subop/subtract %esi 8/imm32 -14235 e9/jump loop/disp32 -14236 } -14237 $same-register-spilled-before?:false: -14238 b8/copy-to-eax 0/imm32/false -14239 $same-register-spilled-before?:end: -14240 # . restore registers -14241 5f/pop-to-edi -14242 5e/pop-to-esi -14243 5b/pop-to-ebx -14244 5a/pop-to-edx -14245 59/pop-to-ecx -14246 # . epilogue -14247 89/<- %esp 5/r32/ebp -14248 5d/pop-to-ebp -14249 c3/return -14250 -14251 # Clean up global state for 'vars' until some block depth (inclusive). -14252 # -14253 # This would be a simple series of pops, if it wasn't for fn outputs, which -14254 # can occur anywhere in the stack. -14255 # So we have to _compact_ the entire array underlying the stack. -14256 # -14257 # We want to allow a fn output register to be written to by locals before the -14258 # output is set. -14259 # So fn outputs can't just be pushed at the start of the function. -14260 # -14261 # We want to allow other locals to shadow a fn output register after the -14262 # output is set. -14263 # So the output can't just always override anything in the stack. Sequence matters. -14264 clean-up-blocks: # vars: (addr stack live-var), until-block-depth: int, fn: (addr function) -14265 # pseudocode: -14266 # to = vars->top (which points outside the stack) -14267 # while true -14268 # if to <= 0 -14269 # break -14270 # var v = vars->data[to-1] -14271 # if v.depth < until and !in-function-outputs?(fn, v) -14272 # break -14273 # --to -14274 # from = to -14275 # while true -14276 # if from >= vars->top -14277 # break -14278 # assert(from >= to) -14279 # v = vars->data[from] -14280 # if in-function-outputs?(fn, v) -14281 # if from > to -14282 # vars->data[to] = vars->data[from] -14283 # ++to -14284 # ++from -14285 # vars->top = to -14286 # -14287 # . prologue -14288 55/push-ebp -14289 89/<- %ebp 4/r32/esp -14290 # . save registers -14291 50/push-eax -14292 52/push-edx -14293 53/push-ebx -14294 56/push-esi -14295 57/push-edi -14296 # ebx = vars -14297 8b/-> *(ebp+8) 3/r32/ebx -14298 # edx = until-block-depth -14299 8b/-> *(ebp+0xc) 2/r32/edx -14300 $clean-up-blocks:phase1: -14301 # var to/edi: int = vars->top -14302 8b/-> *ebx 7/r32/edi -14303 { -14304 $clean-up-blocks:loop1: -14305 # if (to <= 0) break -14306 81 7/subop/compare %edi 0/imm32 -14307 7e/jump-if-<= break/disp8 -14308 # var v/eax: (addr var) = lookup(vars->data[to-1]->var) -14309 8d/copy-address *(ebx+edi-4) 0/r32/eax # vars + 8 + to - 12 -14310 (lookup *eax *(eax+4)) # => eax -14311 # if (v->block-depth >= until-block-depth) continue -14312 39/compare *(eax+0x10) 2/r32/edx # Var-block-depth -14313 { -14314 7d/jump-if->= break/disp8 -14315 # if (!in-function-outputs?(fn, v)) break -14316 (in-function-outputs? *(ebp+0x10) %eax) # => eax -14317 3d/compare-eax-and 0/imm32/false -14318 74/jump-if-= $clean-up-blocks:phase2/disp8 -14319 } -14320 $clean-up-blocks:loop1-continue: -14321 # --to -14322 81 5/subop/subtract %edi 0xc/imm32 -14323 # -14324 eb/jump loop/disp8 -14325 } -14326 $clean-up-blocks:phase2: -14327 # var from/esi: int = to -14328 89/<- %esi 7/r32/edi -14329 { -14330 $clean-up-blocks:loop2: -14331 # if (from >= vars->top) break -14332 3b/compare 6/r32/esi *ebx -14333 7d/jump-if->= break/disp8 -14334 # var v/eax: (addr var) = lookup(vars->data[from]->var) -14335 8d/copy-address *(ebx+esi+8) 0/r32/eax -14336 (lookup *eax *(eax+4)) # => eax -14337 # if !in-function-outputs?(fn, v) continue -14338 (in-function-outputs? *(ebp+0x10) %eax) # => eax -14339 3d/compare-eax-and 0/imm32/false -14340 74/jump-if-= $clean-up-blocks:loop2-continue/disp8 -14341 # invariant: from >= to -14342 # if (from > to) vars->data[to] = vars->data[from] -14343 { -14344 39/compare %esi 7/r32/edi -14345 7e/jump-if-<= break/disp8 -14346 56/push-esi -14347 57/push-edi -14348 # . var from/esi: (addr byte) = &vars->data[from] -14349 8d/copy-address *(ebx+esi+8) 6/r32/esi -14350 # . var to/edi: (addr byte) = &vars->data[to] -14351 8d/copy-address *(ebx+edi+8) 7/r32/edi -14352 # . -14353 8b/-> *esi 0/r32/eax -14354 89/<- *edi 0/r32/eax -14355 8b/-> *(esi+4) 0/r32/eax -14356 89/<- *(edi+4) 0/r32/eax -14357 8b/-> *(esi+8) 0/r32/eax -14358 89/<- *(edi+8) 0/r32/eax -14359 5f/pop-to-edi -14360 5e/pop-to-esi -14361 } -14362 # ++to -14363 81 0/subop/add %edi 0xc/imm32 -14364 $clean-up-blocks:loop2-continue: -14365 # ++from -14366 81 0/subop/add %esi 0xc/imm32 -14367 # -14368 eb/jump loop/disp8 -14369 } -14370 89/<- *ebx 7/r32/edi -14371 $clean-up-blocks:end: -14372 # . restore registers -14373 5f/pop-to-edi -14374 5e/pop-to-esi -14375 5b/pop-to-ebx -14376 5a/pop-to-edx -14377 58/pop-to-eax -14378 # . epilogue -14379 89/<- %esp 5/r32/ebp -14380 5d/pop-to-ebp -14381 c3/return -14382 -14383 in-function-outputs?: # fn: (addr function), target: (addr var) -> result/eax: boolean -14384 # . prologue -14385 55/push-ebp -14386 89/<- %ebp 4/r32/esp -14387 # . save registers -14388 51/push-ecx -14389 # var curr/ecx: (addr list var) = lookup(fn->outputs) -14390 8b/-> *(ebp+8) 1/r32/ecx -14391 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax -14392 89/<- %ecx 0/r32/eax -14393 # while curr != null -14394 { -14395 81 7/subop/compare %ecx 0/imm32 -14396 74/jump-if-= break/disp8 -14397 # var v/eax: (addr var) = lookup(curr->value) -14398 (lookup *ecx *(ecx+4)) # List-value List-value => eax -14399 # if (v == target) return true -14400 39/compare *(ebp+0xc) 0/r32/eax -14401 b8/copy-to-eax 1/imm32/true -14402 74/jump-if-= $in-function-outputs?:end/disp8 -14403 # curr = curr->next -14404 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -14405 89/<- %ecx 0/r32/eax -14406 # -14407 eb/jump loop/disp8 -14408 } -14409 b8/copy-to-eax 0/imm32 -14410 $in-function-outputs?:end: -14411 # . restore registers -14412 59/pop-to-ecx -14413 # . epilogue -14414 89/<- %esp 5/r32/ebp -14415 5d/pop-to-ebp -14416 c3/return -14417 -14418 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) -14419 # . prologue -14420 55/push-ebp -14421 89/<- %ebp 4/r32/esp -14422 # . save registers -14423 50/push-eax -14424 51/push-ecx -14425 52/push-edx -14426 # eax = stmt -14427 8b/-> *(ebp+0xc) 0/r32/eax -14428 # var v/ecx: (addr var) -14429 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax -14430 89/<- %ecx 0/r32/eax -14431 # v->block-depth = *Curr-block-depth -14432 8b/-> *Curr-block-depth 0/r32/eax -14433 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -14434 # var n/edx: int = size-of(stmt->var) -14435 (size-of %ecx) # => eax -14436 89/<- %edx 0/r32/eax -14437 # *Curr-local-stack-offset -= n -14438 29/subtract-from *Curr-local-stack-offset 2/r32/edx -14439 # v->offset = *Curr-local-stack-offset -14440 8b/-> *Curr-local-stack-offset 0/r32/eax -14441 89/<- *(ecx+0x14) 0/r32/eax # Var-offset -14442 # if v is an array, do something special to initialize it -14443 { -14444 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -14445 (is-mu-array? %eax) # => eax -14446 3d/compare-eax-and 0/imm32/false -14447 0f 84/jump-if-= break/disp32 -14448 # var array-size-without-size/edx: int = n-4 -14449 81 5/subop/subtract %edx 4/imm32 -14450 # -14451 (emit-array-data-initialization *(ebp+8) %edx) -14452 e9/jump $emit-subx-var-def:end/disp32 -14453 } -14454 # another special-case for initializing streams -14455 # a stream is an array with 2 extra pointers -14456 { -14457 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -14458 (is-mu-stream? %eax) # => eax -14459 3d/compare-eax-and 0/imm32/false -14460 0f 84/jump-if-= break/disp32 -14461 # var array-size-without-size/edx: int = n-12 -14462 81 5/subop/subtract %edx 0xc/imm32 -14463 (emit-array-data-initialization *(ebp+8) %edx) -14464 # emit read and write pointers -14465 (emit-indent *(ebp+8) *Curr-block-depth) -14466 (write-buffered *(ebp+8) "68/push 0/imm32\n") -14467 (emit-indent *(ebp+8) *Curr-block-depth) -14468 (write-buffered *(ebp+8) "68/push 0/imm32\n") -14469 # -14470 eb/jump $emit-subx-var-def:end/disp8 -14471 } -14472 # while n > 0 -14473 { -14474 81 7/subop/compare %edx 0/imm32 -14475 7e/jump-if-<= break/disp8 -14476 (emit-indent *(ebp+8) *Curr-block-depth) -14477 (write-buffered *(ebp+8) "68/push 0/imm32\n") -14478 # n -= 4 -14479 81 5/subop/subtract %edx 4/imm32 +13622 52/push-edx +13623 # ecx = stmt +13624 8b/-> *(ebp+0xc) 1/r32/ecx +13625 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) +13626 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax +13627 # TODO: assert !sv->is-deref? +13628 # var v/ecx: (addr var) = lookup(sv->value) +13629 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +13630 89/<- %ecx 0/r32/eax +13631 # v->block-depth = *Curr-block-depth +13632 8b/-> *Curr-block-depth 0/r32/eax +13633 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +13634 #? (write-buffered Stderr "var ") +13635 #? (lookup *ecx *(ecx+4)) +13636 #? (write-buffered Stderr %eax) +13637 #? (write-buffered Stderr " at depth ") +13638 #? (write-int32-hex-buffered Stderr *(ecx+0x10)) +13639 #? (write-buffered Stderr Newline) +13640 #? (flush Stderr) +13641 # ensure that v is in a register +13642 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +13643 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 +13644 # var emit-spill?/edx: boolean = not-yet-spilled-this-block? && will-not-write-some-register?(fn) +13645 (not-yet-spilled-this-block? %ecx *(ebp+0x10)) # => eax +13646 89/<- %edx 0/r32/eax +13647 3d/compare-eax-and 0/imm32/false +13648 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 +13649 (will-not-write-some-register? %ecx *(ebp+0x14) *(ebp+0x18)) # => eax +13650 89/<- %edx 0/r32/eax +13651 # check emit-spill? +13652 3d/compare-eax-and 0/imm32/false +13653 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 +13654 # TODO: assert(size-of(output) == 4) +13655 # *Curr-local-stack-offset -= 4 +13656 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 +13657 # emit spill +13658 (emit-indent *(ebp+8) *Curr-block-depth) +13659 (write-buffered *(ebp+8) "ff 6/subop/push %") +13660 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +13661 (write-buffered *(ebp+8) %eax) +13662 (write-buffered *(ebp+8) Newline) +13663 $push-output-and-maybe-emit-spill:push: +13664 8b/-> *(ebp+0xc) 1/r32/ecx +13665 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax +13666 # push(vars, {sv->value, emit-spill?}) +13667 (push *(ebp+0x10) *eax) # Stmt-var-value +13668 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value +13669 (push *(ebp+0x10) %edx) +13670 $push-output-and-maybe-emit-spill:end: +13671 # . restore registers +13672 5a/pop-to-edx +13673 59/pop-to-ecx +13674 58/pop-to-eax +13675 # . epilogue +13676 89/<- %esp 5/r32/ebp +13677 5d/pop-to-ebp +13678 c3/return +13679 +13680 $push-output-and-maybe-emit-spill:abort: +13681 # error("var '" var->name "' initialized from an instruction must live in a register\n") +13682 (write-buffered *(ebp+0x1c) "var '") +13683 (write-buffered *(ebp+0x1c) *eax) # Var-name +13684 (write-buffered *(ebp+0x1c) "' initialized from an instruction must live in a register\n") +13685 (flush *(ebp+0x1c)) +13686 (stop *(ebp+0x20) 1) +13687 # never gets here +13688 +13689 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack live-var) +13690 # . prologue +13691 55/push-ebp +13692 89/<- %ebp 4/r32/esp +13693 # . save registers +13694 50/push-eax +13695 51/push-ecx +13696 # ecx = stmt +13697 8b/-> *(ebp+0xc) 1/r32/ecx +13698 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name +13699 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +13700 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +13701 (lookup *eax *(eax+4)) # Var-name Var-name => eax +13702 # clean up until target block +13703 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) +13704 # emit jump to target block +13705 (emit-indent *(ebp+8) *Curr-block-depth) +13706 (write-buffered *(ebp+8) "e9/jump ") +13707 (write-buffered *(ebp+8) %eax) +13708 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +13709 (string-starts-with? %eax "break") +13710 3d/compare-eax-and 0/imm32/false +13711 { +13712 74/jump-if-= break/disp8 +13713 (write-buffered *(ebp+8) ":break/disp32\n") +13714 } +13715 3d/compare-eax-and 0/imm32/false # just in case the function call modified flags +13716 { +13717 75/jump-if-!= break/disp8 +13718 (write-buffered *(ebp+8) ":loop/disp32\n") +13719 } +13720 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: +13721 # . restore registers +13722 59/pop-to-ecx +13723 58/pop-to-eax +13724 # . epilogue +13725 89/<- %esp 5/r32/ebp +13726 5d/pop-to-ebp +13727 c3/return +13728 +13729 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean +13730 # . prologue +13731 55/push-ebp +13732 89/<- %ebp 4/r32/esp +13733 # . save registers +13734 51/push-ecx +13735 # ecx = lookup(stmt->operation) +13736 8b/-> *(ebp+8) 1/r32/ecx +13737 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +13738 89/<- %ecx 0/r32/eax +13739 # if (stmt->operation starts with "loop") return true +13740 (string-starts-with? %ecx "loop") # => eax +13741 3d/compare-eax-and 0/imm32/false +13742 75/jump-if-not-equal $is-mu-branch?:end/disp8 +13743 # otherwise return (stmt->operation starts with "break") +13744 (string-starts-with? %ecx "break") # => eax +13745 $is-mu-branch?:end: +13746 # . restore registers +13747 59/pop-to-ecx +13748 # . epilogue +13749 89/<- %esp 5/r32/ebp +13750 5d/pop-to-ebp +13751 c3/return +13752 +13753 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) +13754 # . prologue +13755 55/push-ebp +13756 89/<- %ebp 4/r32/esp +13757 # . save registers +13758 50/push-eax +13759 # eax = stmt +13760 8b/-> *(ebp+0xc) 0/r32/eax +13761 # +13762 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +13763 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) +13764 (emit-indent *(ebp+8) *Curr-block-depth) +13765 (lookup *eax *(eax+4)) # => eax +13766 (write-buffered *(ebp+8) %eax) +13767 (write-buffered *(ebp+8) " break/disp32\n") +13768 $emit-reverse-break:end: +13769 # . restore registers +13770 58/pop-to-eax +13771 # . epilogue +13772 89/<- %esp 5/r32/ebp +13773 5d/pop-to-ebp +13774 c3/return +13775 +13776 == data +13777 +13778 # Table from Mu branch instructions to the reverse SubX opcodes for them. +13779 Reverse-branch: # (table (handle array byte) (handle array byte)) +13780 # a table is a stream +13781 0x140/imm32/write +13782 0/imm32/read +13783 0x140/imm32/size +13784 # data +13785 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 +13786 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 +13787 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 +13788 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 +13789 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 +13790 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 +13791 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 +13792 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 +13793 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +13794 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +13795 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 +13796 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 +13797 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +13798 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +13799 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +13800 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +13801 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +13802 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +13803 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +13804 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +13805 +13806 == code +13807 +13808 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack live-var), depth: int, label-suffix: (addr array byte) +13809 # . prologue +13810 55/push-ebp +13811 89/<- %ebp 4/r32/esp +13812 # . save registers +13813 50/push-eax +13814 51/push-ecx +13815 52/push-edx +13816 53/push-ebx +13817 56/push-esi +13818 # ecx = vars +13819 8b/-> *(ebp+0xc) 1/r32/ecx +13820 # var eax: int = vars->top +13821 8b/-> *ecx 0/r32/eax +13822 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +13823 8d/copy-address *(ecx+eax-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +13824 # var min/ecx: (addr handle var) = vars->data +13825 8d/copy-address *(ecx+8) 1/r32/ecx +13826 # edx = depth +13827 8b/-> *(ebp+0x10) 2/r32/edx +13828 { +13829 $emit-unconditional-jump-to-depth:loop: +13830 # if (curr < min) break +13831 39/compare %esi 1/r32/ecx +13832 0f 82/jump-if-addr< break/disp32 +13833 # var v/ebx: (addr var) = lookup(*curr) +13834 (lookup *esi *(esi+4)) # => eax +13835 89/<- %ebx 0/r32/eax +13836 # if (v->block-depth < until-block-depth) break +13837 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +13838 0f 8c/jump-if-< break/disp32 +13839 { +13840 $emit-unconditional-jump-to-depth:check: +13841 # if v->block-depth != until-block-depth, continue +13842 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +13843 0f 85/jump-if-!= break/disp32 +13844 $emit-unconditional-jump-to-depth:depth-found: +13845 # if v is not a literal, continue +13846 (size-of %ebx) # => eax +13847 3d/compare-eax-and 0/imm32 +13848 0f 85/jump-if-!= break/disp32 +13849 $emit-unconditional-jump-to-depth:label-found: +13850 # emit unconditional jump, then return +13851 (emit-indent *(ebp+8) *Curr-block-depth) +13852 (write-buffered *(ebp+8) "e9/jump ") +13853 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +13854 (write-buffered *(ebp+8) %eax) +13855 (write-buffered *(ebp+8) ":") +13856 (write-buffered *(ebp+8) *(ebp+0x14)) +13857 (write-buffered *(ebp+8) "/disp32\n") +13858 eb/jump $emit-unconditional-jump-to-depth:end/disp8 +13859 } +13860 # curr -= 12 +13861 81 5/subop/subtract %esi 0xc/imm32 +13862 e9/jump loop/disp32 +13863 } +13864 # TODO: error if no label at 'depth' was found +13865 $emit-unconditional-jump-to-depth:end: +13866 # . restore registers +13867 5e/pop-to-esi +13868 5b/pop-to-ebx +13869 5a/pop-to-edx +13870 59/pop-to-ecx +13871 58/pop-to-eax +13872 # . epilogue +13873 89/<- %esp 5/r32/ebp +13874 5d/pop-to-ebp +13875 c3/return +13876 +13877 # emit clean-up code for 'vars' until some block depth +13878 # doesn't actually modify 'vars' so we need traverse manually inside the stack +13879 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack live-var), until-block-depth: int +13880 # . prologue +13881 55/push-ebp +13882 89/<- %ebp 4/r32/esp +13883 # . save registers +13884 50/push-eax +13885 51/push-ecx +13886 52/push-edx +13887 53/push-ebx +13888 56/push-esi +13889 #? (write-buffered Stderr "--- cleanup\n") +13890 #? (flush Stderr) +13891 # ecx = vars +13892 8b/-> *(ebp+0xc) 1/r32/ecx +13893 # var esi: int = vars->top +13894 8b/-> *ecx 6/r32/esi +13895 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +13896 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +13897 # var min/ecx: (addr handle var) = vars->data +13898 81 0/subop/add %ecx 8/imm32 +13899 # edx = until-block-depth +13900 8b/-> *(ebp+0x10) 2/r32/edx +13901 { +13902 $emit-cleanup-code-until-depth:loop: +13903 # if (curr < min) break +13904 39/compare %esi 1/r32/ecx +13905 0f 82/jump-if-addr< break/disp32 +13906 # var v/ebx: (addr var) = lookup(*curr) +13907 (lookup *esi *(esi+4)) # => eax +13908 89/<- %ebx 0/r32/eax +13909 #? (lookup *ebx *(ebx+4)) # Var-name +13910 #? (write-buffered Stderr "var ") +13911 #? (write-buffered Stderr %eax) +13912 #? (write-buffered Stderr Newline) +13913 #? (flush Stderr) +13914 # if (v->block-depth < until-block-depth) break +13915 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +13916 0f 8c/jump-if-< break/disp32 +13917 # if v is in a register +13918 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +13919 { +13920 0f 84/jump-if-= break/disp32 +13921 { +13922 $emit-cleanup-code-until-depth:check-for-previous-spill: +13923 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled +13924 3d/compare-eax-and 0/imm32/false +13925 74/jump-if-= break/disp8 +13926 $emit-cleanup-code-until-depth:reclaim-var-in-register: +13927 (emit-indent *(ebp+8) *Curr-block-depth) +13928 (write-buffered *(ebp+8) "8f 0/subop/pop %") +13929 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +13930 (write-buffered *(ebp+8) %eax) +13931 (write-buffered *(ebp+8) Newline) +13932 } +13933 eb/jump $emit-cleanup-code-until-depth:continue/disp8 +13934 } +13935 # otherwise v is on the stack +13936 { +13937 75/jump-if-!= break/disp8 +13938 $emit-cleanup-code-until-depth:var-on-stack: +13939 (size-of %ebx) # => eax +13940 # don't emit code for labels +13941 3d/compare-eax-and 0/imm32 +13942 74/jump-if-= break/disp8 +13943 $emit-cleanup-code-until-depth:reclaim-var-on-stack: +13944 (emit-indent *(ebp+8) *Curr-block-depth) +13945 (write-buffered *(ebp+8) "81 0/subop/add %esp ") +13946 (write-int32-hex-buffered *(ebp+8) %eax) +13947 (write-buffered *(ebp+8) "/imm32\n") +13948 } +13949 $emit-cleanup-code-until-depth:continue: +13950 # curr -= 12 +13951 81 5/subop/subtract %esi 0xc/imm32 +13952 e9/jump loop/disp32 +13953 } +13954 $emit-cleanup-code-until-depth:end: +13955 # . restore registers +13956 5e/pop-to-esi +13957 5b/pop-to-ebx +13958 5a/pop-to-edx +13959 59/pop-to-ecx +13960 58/pop-to-eax +13961 # . epilogue +13962 89/<- %esp 5/r32/ebp +13963 5d/pop-to-ebp +13964 c3/return +13965 +13966 # emit clean-up code for 'vars' until a given label is encountered +13967 # doesn't actually modify 'vars' so we need traverse manually inside the stack +13968 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack live-var), until-block-label: (addr array byte) +13969 # . prologue +13970 55/push-ebp +13971 89/<- %ebp 4/r32/esp +13972 # . save registers +13973 50/push-eax +13974 51/push-ecx +13975 52/push-edx +13976 53/push-ebx +13977 # ecx = vars +13978 8b/-> *(ebp+0xc) 1/r32/ecx +13979 # var eax: int = vars->top +13980 8b/-> *ecx 0/r32/eax +13981 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] +13982 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size +13983 # var min/ecx: (addr handle var) = vars->data +13984 81 0/subop/add %ecx 8/imm32 +13985 { +13986 $emit-cleanup-code-until-target:loop: +13987 # if (curr < min) break +13988 39/compare %edx 1/r32/ecx +13989 0f 82/jump-if-addr< break/disp32 +13990 # var v/ebx: (handle var) = lookup(*curr) +13991 (lookup *edx *(edx+4)) # => eax +13992 89/<- %ebx 0/r32/eax +13993 # if (v->name == until-block-label) break +13994 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +13995 (string-equal? %eax *(ebp+0x10)) # => eax +13996 3d/compare-eax-and 0/imm32/false +13997 0f 85/jump-if-!= break/disp32 +13998 # if v is in a register +13999 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +14000 { +14001 0f 84/jump-if-= break/disp32 +14002 { +14003 $emit-cleanup-code-until-target:check-for-previous-spill: +14004 8b/-> *(edx+8) 0/r32/eax # Live-var-register-spilled +14005 3d/compare-eax-and 0/imm32/false +14006 74/jump-if-= break/disp8 +14007 $emit-cleanup-code-until-target:reclaim-var-in-register: +14008 (emit-indent *(ebp+8) *Curr-block-depth) +14009 (write-buffered *(ebp+8) "8f 0/subop/pop %") +14010 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +14011 (write-buffered *(ebp+8) %eax) +14012 (write-buffered *(ebp+8) Newline) +14013 } +14014 eb/jump $emit-cleanup-code-until-target:continue/disp8 +14015 } +14016 # otherwise v is on the stack +14017 { +14018 75/jump-if-!= break/disp8 +14019 $emit-cleanup-code-until-target:reclaim-var-on-stack: +14020 (size-of %ebx) # => eax +14021 # don't emit code for labels +14022 3d/compare-eax-and 0/imm32 +14023 74/jump-if-= break/disp8 +14024 # +14025 (emit-indent *(ebp+8) *Curr-block-depth) +14026 (write-buffered *(ebp+8) "81 0/subop/add %esp ") +14027 (write-int32-hex-buffered *(ebp+8) %eax) +14028 (write-buffered *(ebp+8) "/imm32\n") +14029 } +14030 $emit-cleanup-code-until-target:continue: +14031 # curr -= 12 +14032 81 5/subop/subtract %edx 0xc/imm32 +14033 e9/jump loop/disp32 +14034 } +14035 $emit-cleanup-code-until-target:end: +14036 # . restore registers +14037 5b/pop-to-ebx +14038 5a/pop-to-edx +14039 59/pop-to-ecx +14040 58/pop-to-eax +14041 # . epilogue +14042 89/<- %esp 5/r32/ebp +14043 5d/pop-to-ebp +14044 c3/return +14045 +14046 # Return true if there isn't a variable in 'vars' with the same block-depth +14047 # and register as 'v'. +14048 # 'v' is guaranteed not to be within 'vars'. +14049 not-yet-spilled-this-block?: # v: (addr var), vars: (addr stack live-var) -> result/eax: boolean +14050 # . prologue +14051 55/push-ebp +14052 89/<- %ebp 4/r32/esp +14053 # . save registers +14054 51/push-ecx +14055 52/push-edx +14056 53/push-ebx +14057 56/push-esi +14058 57/push-edi +14059 # ecx = vars +14060 8b/-> *(ebp+0xc) 1/r32/ecx +14061 # var eax: int = vars->top +14062 8b/-> *ecx 0/r32/eax +14063 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] +14064 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size +14065 # var min/ecx: (addr handle var) = vars->data +14066 8d/copy-address *(ecx+8) 1/r32/ecx +14067 # var depth/ebx: int = v->block-depth +14068 8b/-> *(ebp+8) 3/r32/ebx +14069 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth +14070 # var needle/esi: (addr array byte) = v->register +14071 8b/-> *(ebp+8) 6/r32/esi +14072 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +14073 89/<- %esi 0/r32/eax +14074 { +14075 $not-yet-spilled-this-block?:loop: +14076 # if (curr < min) break +14077 39/compare %edx 1/r32/ecx +14078 0f 82/jump-if-addr< break/disp32 +14079 # var cand/edi: (addr var) = lookup(*curr) +14080 (lookup *edx *(edx+4)) # => eax +14081 89/<- %edi 0/r32/eax +14082 # if (cand->block-depth < depth) break +14083 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth +14084 0f 8c/jump-if-< break/disp32 +14085 # var cand-reg/edi: (array array byte) = cand->reg +14086 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +14087 89/<- %edi 0/r32/eax +14088 # if (cand-reg == null) continue +14089 { +14090 $not-yet-spilled-this-block?:check-reg: +14091 81 7/subop/compare %edi 0/imm32 +14092 0f 84/jump-if-= break/disp32 +14093 # if (cand-reg == needle) return true +14094 (string-equal? %esi %edi) # => eax +14095 3d/compare-eax-and 0/imm32/false +14096 74/jump-if-= break/disp8 +14097 $not-yet-spilled-this-block?:return-false: +14098 b8/copy-to-eax 0/imm32/false +14099 eb/jump $not-yet-spilled-this-block?:end/disp8 +14100 } +14101 $not-yet-spilled-this-block?:continue: +14102 # curr -= 12 +14103 81 5/subop/subtract %edx 0xc/imm32 +14104 e9/jump loop/disp32 +14105 } +14106 $not-yet-spilled-this-block?:return-true: +14107 # return true +14108 b8/copy-to-eax 1/imm32/true +14109 $not-yet-spilled-this-block?:end: +14110 # . restore registers +14111 5f/pop-to-edi +14112 5e/pop-to-esi +14113 5b/pop-to-ebx +14114 5a/pop-to-edx +14115 59/pop-to-ecx +14116 # . epilogue +14117 89/<- %esp 5/r32/ebp +14118 5d/pop-to-ebp +14119 c3/return +14120 +14121 # could the register of 'v' ever be written to by one of the vars in fn-outputs? +14122 will-not-write-some-register?: # v: (addr var), stmts: (addr list stmt), fn: (addr function) -> result/eax: boolean +14123 # . prologue +14124 55/push-ebp +14125 89/<- %ebp 4/r32/esp +14126 # eax = v +14127 8b/-> *(ebp+8) 0/r32/eax +14128 # var reg/eax: (addr array byte) = lookup(v->register) +14129 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +14130 # var target/eax: (addr var) = find-register(fn-outputs, reg) +14131 (find-register *(ebp+0x10) %eax) # => eax +14132 # if (target == 0) return true +14133 { +14134 3d/compare-eax-and 0/imm32 +14135 75/jump-if-!= break/disp8 +14136 b8/copy-to-eax 1/imm32/true +14137 eb/jump $will-not-write-some-register?:end/disp8 +14138 } +14139 # return !assigns-in-stmts?(stmts, target) +14140 (assigns-in-stmts? *(ebp+0xc) %eax) # => eax +14141 3d/compare-eax-and 0/imm32/false +14142 # assume: true = 1, so no need to mask with 0x000000ff +14143 0f 94/set-if-= %al +14144 $will-not-write-some-register?:end: +14145 # . epilogue +14146 89/<- %esp 5/r32/ebp +14147 5d/pop-to-ebp +14148 c3/return +14149 +14150 # return fn output with matching register +14151 # always returns false if 'reg' is null +14152 find-register: # fn: (addr function), reg: (addr array byte) -> result/eax: (addr var) +14153 # . prologue +14154 55/push-ebp +14155 89/<- %ebp 4/r32/esp +14156 # . save registers +14157 51/push-ecx +14158 # var curr/ecx: (addr list var) = lookup(fn->outputs) +14159 8b/-> *(ebp+8) 1/r32/ecx +14160 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax +14161 89/<- %ecx 0/r32/eax +14162 { +14163 $find-register:loop: +14164 # if (curr == 0) break +14165 81 7/subop/compare %ecx 0/imm32 +14166 74/jump-if-= break/disp8 +14167 # eax = curr->value->register +14168 (lookup *ecx *(ecx+4)) # List-value List-value => eax +14169 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +14170 # if (eax == reg) return curr->value +14171 $find-register:compare: +14172 (string-equal? *(ebp+0xc) %eax) # => eax +14173 { +14174 3d/compare-eax-and 0/imm32/false +14175 74/jump-if-= break/disp8 +14176 $find-register:found: +14177 (lookup *ecx *(ecx+4)) # List-value List-value => eax +14178 eb/jump $find-register:end/disp8 +14179 } +14180 # curr = lookup(curr->next) +14181 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +14182 89/<- %ecx 0/r32/eax +14183 # +14184 eb/jump loop/disp8 +14185 } +14186 $find-register:end: +14187 # . restore registers +14188 59/pop-to-ecx +14189 # . epilogue +14190 89/<- %esp 5/r32/ebp +14191 5d/pop-to-ebp +14192 c3/return +14193 +14194 assigns-in-stmts?: # stmts: (addr list stmt), v: (addr var) -> result/eax: boolean +14195 # . prologue +14196 55/push-ebp +14197 89/<- %ebp 4/r32/esp +14198 # . save registers +14199 51/push-ecx +14200 # var curr/ecx: (addr list stmt) = stmts +14201 8b/-> *(ebp+8) 1/r32/ecx +14202 { +14203 # if (curr == 0) break +14204 81 7/subop/compare %ecx 0/imm32 +14205 74/jump-if-= break/disp8 +14206 # if assigns-in-stmt?(curr->value, v) return true +14207 (lookup *ecx *(ecx+4)) # List-value List-value => eax +14208 (assigns-in-stmt? %eax *(ebp+0xc)) # => eax +14209 3d/compare-eax-and 0/imm32/false +14210 75/jump-if-!= break/disp8 +14211 # curr = lookup(curr->next) +14212 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +14213 89/<- %ecx 0/r32/eax +14214 # +14215 eb/jump loop/disp8 +14216 } +14217 $assigns-in-stmts?:end: +14218 # . restore registers +14219 59/pop-to-ecx +14220 # . epilogue +14221 89/<- %esp 5/r32/ebp +14222 5d/pop-to-ebp +14223 c3/return +14224 +14225 assigns-in-stmt?: # stmt: (addr stmt), v: (addr var) -> result/eax: boolean +14226 # . prologue +14227 55/push-ebp +14228 89/<- %ebp 4/r32/esp +14229 # . save registers +14230 51/push-ecx +14231 # ecx = stmt +14232 8b/-> *(ebp+8) 1/r32/ecx +14233 # if stmt is a stmt1, return assigns-in-stmt-vars?(stmt->outputs, v) +14234 { +14235 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag +14236 75/jump-if-!= break/disp8 +14237 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +14238 (assigns-in-stmt-vars? %eax *(ebp+0xc)) # => eax +14239 eb/jump $assigns-in-stmt?:end/disp8 +14240 } +14241 # if stmt is a block, return assigns-in-stmts?(stmt->stmts, v) +14242 { +14243 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag +14244 75/jump-if-!= break/disp8 +14245 (lookup *(ecx+4) *(ecx+8)) # Block-stmts Block-stmts => eax +14246 (assigns-in-stmts? %eax *(ebp+0xc)) # => eax +14247 eb/jump $assigns-in-stmt?:end/disp8 +14248 } +14249 # otherwise return false +14250 b8/copy 0/imm32/false +14251 $assigns-in-stmt?:end: +14252 # . restore registers +14253 59/pop-to-ecx +14254 # . epilogue +14255 89/<- %esp 5/r32/ebp +14256 5d/pop-to-ebp +14257 c3/return +14258 +14259 assigns-in-stmt-vars?: # stmt-var: (addr stmt-var), v: (addr var) -> result/eax: boolean +14260 # . prologue +14261 55/push-ebp +14262 89/<- %ebp 4/r32/esp +14263 # . save registers +14264 51/push-ecx +14265 # var curr/ecx: (addr stmt-var) = stmt-var +14266 8b/-> *(ebp+8) 1/r32/ecx +14267 { +14268 # if (curr == 0) break +14269 81 7/subop/compare %ecx 0/imm32 +14270 74/jump-if-= break/disp8 +14271 # eax = lookup(curr->value) +14272 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +14273 # if (eax == v && curr->is-deref? == false) return true +14274 { +14275 39/compare *(ebp+0xc) 0/r32/eax +14276 75/jump-if-!= break/disp8 +14277 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +14278 75/jump-if-!= break/disp8 +14279 b8/copy-to-eax 1/imm32/true +14280 eb/jump $assigns-in-stmt-vars?:end/disp8 +14281 } +14282 # curr = lookup(curr->next) +14283 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +14284 89/<- %ecx 0/r32/eax +14285 # +14286 eb/jump loop/disp8 +14287 } +14288 $assigns-in-stmt-vars?:end: +14289 # . restore registers +14290 59/pop-to-ecx +14291 # . epilogue +14292 89/<- %esp 5/r32/ebp +14293 5d/pop-to-ebp +14294 c3/return +14295 +14296 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? +14297 # v is guaranteed to be within vars +14298 # 'start' is provided as an optimization, a pointer within vars +14299 # *start == v +14300 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean +14301 # . prologue +14302 55/push-ebp +14303 89/<- %ebp 4/r32/esp +14304 # . save registers +14305 51/push-ecx +14306 52/push-edx +14307 53/push-ebx +14308 56/push-esi +14309 57/push-edi +14310 # ecx = v +14311 8b/-> *(ebp+8) 1/r32/ecx +14312 # var reg/edx: (addr array byte) = lookup(v->register) +14313 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +14314 89/<- %edx 0/r32/eax +14315 # var depth/ebx: int = v->block-depth +14316 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth +14317 # var min/ecx: (addr handle var) = vars->data +14318 8b/-> *(ebp+0xc) 1/r32/ecx +14319 81 0/subop/add %ecx 8/imm32 +14320 # TODO: check that start >= min and start < &vars->data[top] +14321 # TODO: check that *start == v +14322 # var curr/esi: (addr handle var) = start +14323 8b/-> *(ebp+0x10) 6/r32/esi +14324 # curr -= 8 +14325 81 5/subop/subtract %esi 8/imm32 +14326 { +14327 $same-register-spilled-before?:loop: +14328 # if (curr < min) break +14329 39/compare %esi 1/r32/ecx +14330 0f 82/jump-if-addr< break/disp32 +14331 # var x/eax: (addr var) = lookup(*curr) +14332 (lookup *esi *(esi+4)) # => eax +14333 # if (x->block-depth < depth) break +14334 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth +14335 0f 8c/jump-if-< break/disp32 +14336 # if (x->register == 0) continue +14337 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14338 74/jump-if-= $same-register-spilled-before?:continue/disp8 +14339 # if (x->register == reg) return true +14340 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +14341 (string-equal? %eax %edx) # => eax +14342 3d/compare-eax-and 0/imm32/false +14343 b8/copy-to-eax 1/imm32/true +14344 75/jump-if-!= $same-register-spilled-before?:end/disp8 +14345 $same-register-spilled-before?:continue: +14346 # curr -= 8 +14347 81 5/subop/subtract %esi 8/imm32 +14348 e9/jump loop/disp32 +14349 } +14350 $same-register-spilled-before?:false: +14351 b8/copy-to-eax 0/imm32/false +14352 $same-register-spilled-before?:end: +14353 # . restore registers +14354 5f/pop-to-edi +14355 5e/pop-to-esi +14356 5b/pop-to-ebx +14357 5a/pop-to-edx +14358 59/pop-to-ecx +14359 # . epilogue +14360 89/<- %esp 5/r32/ebp +14361 5d/pop-to-ebp +14362 c3/return +14363 +14364 # Clean up global state for 'vars' until some block depth (inclusive). +14365 # +14366 # This would be a simple series of pops, if it wasn't for fn outputs, which +14367 # can occur anywhere in the stack. +14368 # So we have to _compact_ the entire array underlying the stack. +14369 # +14370 # We want to allow a fn output register to be written to by locals before the +14371 # output is set. +14372 # So fn outputs can't just be pushed at the start of the function. +14373 # +14374 # We want to allow other locals to shadow a fn output register after the +14375 # output is set. +14376 # So the output can't just always override anything in the stack. Sequence matters. +14377 clean-up-blocks: # vars: (addr stack live-var), until-block-depth: int, fn: (addr function) +14378 # pseudocode: +14379 # to = vars->top (which points outside the stack) +14380 # while true +14381 # if to <= 0 +14382 # break +14383 # var v = vars->data[to-1] +14384 # if v.depth < until and !in-function-outputs?(fn, v) +14385 # break +14386 # --to +14387 # from = to +14388 # while true +14389 # if from >= vars->top +14390 # break +14391 # assert(from >= to) +14392 # v = vars->data[from] +14393 # if in-function-outputs?(fn, v) +14394 # if from > to +14395 # vars->data[to] = vars->data[from] +14396 # ++to +14397 # ++from +14398 # vars->top = to +14399 # +14400 # . prologue +14401 55/push-ebp +14402 89/<- %ebp 4/r32/esp +14403 # . save registers +14404 50/push-eax +14405 52/push-edx +14406 53/push-ebx +14407 56/push-esi +14408 57/push-edi +14409 # ebx = vars +14410 8b/-> *(ebp+8) 3/r32/ebx +14411 # edx = until-block-depth +14412 8b/-> *(ebp+0xc) 2/r32/edx +14413 $clean-up-blocks:phase1: +14414 # var to/edi: int = vars->top +14415 8b/-> *ebx 7/r32/edi +14416 { +14417 $clean-up-blocks:loop1: +14418 # if (to <= 0) break +14419 81 7/subop/compare %edi 0/imm32 +14420 7e/jump-if-<= break/disp8 +14421 # var v/eax: (addr var) = lookup(vars->data[to-1]->var) +14422 8d/copy-address *(ebx+edi-4) 0/r32/eax # vars + 8 + to - 12 +14423 (lookup *eax *(eax+4)) # => eax +14424 # if (v->block-depth >= until-block-depth) continue +14425 39/compare *(eax+0x10) 2/r32/edx # Var-block-depth +14426 { +14427 7d/jump-if->= break/disp8 +14428 # if (!in-function-outputs?(fn, v)) break +14429 (in-function-outputs? *(ebp+0x10) %eax) # => eax +14430 3d/compare-eax-and 0/imm32/false +14431 74/jump-if-= $clean-up-blocks:phase2/disp8 +14432 } +14433 $clean-up-blocks:loop1-continue: +14434 # --to +14435 81 5/subop/subtract %edi 0xc/imm32 +14436 # +14437 eb/jump loop/disp8 +14438 } +14439 $clean-up-blocks:phase2: +14440 # var from/esi: int = to +14441 89/<- %esi 7/r32/edi +14442 { +14443 $clean-up-blocks:loop2: +14444 # if (from >= vars->top) break +14445 3b/compare 6/r32/esi *ebx +14446 7d/jump-if->= break/disp8 +14447 # var v/eax: (addr var) = lookup(vars->data[from]->var) +14448 8d/copy-address *(ebx+esi+8) 0/r32/eax +14449 (lookup *eax *(eax+4)) # => eax +14450 # if !in-function-outputs?(fn, v) continue +14451 (in-function-outputs? *(ebp+0x10) %eax) # => eax +14452 3d/compare-eax-and 0/imm32/false +14453 74/jump-if-= $clean-up-blocks:loop2-continue/disp8 +14454 # invariant: from >= to +14455 # if (from > to) vars->data[to] = vars->data[from] +14456 { +14457 39/compare %esi 7/r32/edi +14458 7e/jump-if-<= break/disp8 +14459 56/push-esi +14460 57/push-edi +14461 # . var from/esi: (addr byte) = &vars->data[from] +14462 8d/copy-address *(ebx+esi+8) 6/r32/esi +14463 # . var to/edi: (addr byte) = &vars->data[to] +14464 8d/copy-address *(ebx+edi+8) 7/r32/edi +14465 # . +14466 8b/-> *esi 0/r32/eax +14467 89/<- *edi 0/r32/eax +14468 8b/-> *(esi+4) 0/r32/eax +14469 89/<- *(edi+4) 0/r32/eax +14470 8b/-> *(esi+8) 0/r32/eax +14471 89/<- *(edi+8) 0/r32/eax +14472 5f/pop-to-edi +14473 5e/pop-to-esi +14474 } +14475 # ++to +14476 81 0/subop/add %edi 0xc/imm32 +14477 $clean-up-blocks:loop2-continue: +14478 # ++from +14479 81 0/subop/add %esi 0xc/imm32 14480 # 14481 eb/jump loop/disp8 14482 } -14483 $emit-subx-var-def:end: -14484 # . restore registers -14485 5a/pop-to-edx -14486 59/pop-to-ecx -14487 58/pop-to-eax -14488 # . epilogue -14489 89/<- %esp 5/r32/ebp -14490 5d/pop-to-ebp -14491 c3/return -14492 -14493 emit-array-data-initialization: # out: (addr buffered-file), n: int -14494 # . prologue -14495 55/push-ebp -14496 89/<- %ebp 4/r32/esp -14497 # -14498 (emit-indent *(ebp+8) *Curr-block-depth) -14499 (write-buffered *(ebp+8) "(push-n-zero-bytes ") -14500 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) -14501 (write-buffered *(ebp+8) ")\n") -14502 (emit-indent *(ebp+8) *Curr-block-depth) -14503 (write-buffered *(ebp+8) "68/push ") -14504 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) -14505 (write-buffered *(ebp+8) "/imm32\n") -14506 $emit-array-data-initialization:end: -14507 # . epilogue -14508 89/<- %esp 5/r32/ebp -14509 5d/pop-to-ebp -14510 c3/return -14511 -14512 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) -14513 # . prologue -14514 55/push-ebp -14515 89/<- %ebp 4/r32/esp -14516 # . save registers -14517 50/push-eax -14518 51/push-ecx -14519 # - some special-case primitives that don't actually use the 'primitives' data structure -14520 # var op/ecx: (addr array byte) = lookup(stmt->operation) -14521 8b/-> *(ebp+0xc) 1/r32/ecx -14522 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -14523 89/<- %ecx 0/r32/eax -14524 # array size -14525 { -14526 # if (!string-equal?(stmt->operation, "length")) break -14527 (string-equal? %ecx "length") # => eax -14528 3d/compare-eax-and 0/imm32 -14529 0f 84/jump-if-= break/disp32 -14530 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14531 e9/jump $emit-subx-stmt:end/disp32 -14532 } -14533 # index into array -14534 { -14535 # if (!string-equal?(stmt->operation, "index")) break -14536 (string-equal? %ecx "index") # => eax -14537 3d/compare-eax-and 0/imm32 -14538 0f 84/jump-if-= break/disp32 -14539 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14540 e9/jump $emit-subx-stmt:end/disp32 -14541 } -14542 # compute-offset for index into array -14543 { -14544 # if (!string-equal?(stmt->operation, "compute-offset")) break -14545 (string-equal? %ecx "compute-offset") # => eax -14546 3d/compare-eax-and 0/imm32 -14547 0f 84/jump-if-= break/disp32 -14548 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14549 e9/jump $emit-subx-stmt:end/disp32 -14550 } -14551 # get field from record -14552 { -14553 # if (!string-equal?(stmt->operation, "get")) break -14554 (string-equal? %ecx "get") # => eax -14555 3d/compare-eax-and 0/imm32 -14556 0f 84/jump-if-= break/disp32 -14557 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) -14558 e9/jump $emit-subx-stmt:end/disp32 -14559 } -14560 # allocate scalar -14561 { -14562 # if (!string-equal?(stmt->operation, "allocate")) break -14563 (string-equal? %ecx "allocate") # => eax -14564 3d/compare-eax-and 0/imm32 -14565 0f 84/jump-if-= break/disp32 -14566 (translate-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14567 e9/jump $emit-subx-stmt:end/disp32 -14568 } -14569 # allocate array -14570 { -14571 # if (!string-equal?(stmt->operation, "populate")) break -14572 (string-equal? %ecx "populate") # => eax -14573 3d/compare-eax-and 0/imm32 -14574 0f 84/jump-if-= break/disp32 -14575 (translate-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14576 e9/jump $emit-subx-stmt:end/disp32 -14577 } -14578 # allocate stream -14579 { -14580 # if (!string-equal?(stmt->operation, "populate-stream")) break -14581 (string-equal? %ecx "populate-stream") # => eax -14582 3d/compare-eax-and 0/imm32 -14583 0f 84/jump-if-= break/disp32 -14584 (translate-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14585 e9/jump $emit-subx-stmt:end/disp32 -14586 } -14587 # read from stream -14588 { -14589 # if (!string-equal?(stmt->operation, "read-from-stream")) break -14590 (string-equal? %ecx "read-from-stream") # => eax -14591 3d/compare-eax-and 0/imm32 -14592 0f 84/jump-if-= break/disp32 -14593 (translate-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14594 e9/jump $emit-subx-stmt:end/disp32 +14483 89/<- *ebx 7/r32/edi +14484 $clean-up-blocks:end: +14485 # . restore registers +14486 5f/pop-to-edi +14487 5e/pop-to-esi +14488 5b/pop-to-ebx +14489 5a/pop-to-edx +14490 58/pop-to-eax +14491 # . epilogue +14492 89/<- %esp 5/r32/ebp +14493 5d/pop-to-ebp +14494 c3/return +14495 +14496 in-function-outputs?: # fn: (addr function), target: (addr var) -> result/eax: boolean +14497 # . prologue +14498 55/push-ebp +14499 89/<- %ebp 4/r32/esp +14500 # . save registers +14501 51/push-ecx +14502 # var curr/ecx: (addr list var) = lookup(fn->outputs) +14503 8b/-> *(ebp+8) 1/r32/ecx +14504 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax +14505 89/<- %ecx 0/r32/eax +14506 # while curr != null +14507 { +14508 81 7/subop/compare %ecx 0/imm32 +14509 74/jump-if-= break/disp8 +14510 # var v/eax: (addr var) = lookup(curr->value) +14511 (lookup *ecx *(ecx+4)) # List-value List-value => eax +14512 # if (v == target) return true +14513 39/compare *(ebp+0xc) 0/r32/eax +14514 b8/copy-to-eax 1/imm32/true +14515 74/jump-if-= $in-function-outputs?:end/disp8 +14516 # curr = curr->next +14517 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +14518 89/<- %ecx 0/r32/eax +14519 # +14520 eb/jump loop/disp8 +14521 } +14522 b8/copy-to-eax 0/imm32 +14523 $in-function-outputs?:end: +14524 # . restore registers +14525 59/pop-to-ecx +14526 # . epilogue +14527 89/<- %esp 5/r32/ebp +14528 5d/pop-to-ebp +14529 c3/return +14530 +14531 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) +14532 # . prologue +14533 55/push-ebp +14534 89/<- %ebp 4/r32/esp +14535 # . save registers +14536 50/push-eax +14537 51/push-ecx +14538 52/push-edx +14539 # eax = stmt +14540 8b/-> *(ebp+0xc) 0/r32/eax +14541 # var v/ecx: (addr var) +14542 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax +14543 89/<- %ecx 0/r32/eax +14544 # v->block-depth = *Curr-block-depth +14545 8b/-> *Curr-block-depth 0/r32/eax +14546 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +14547 # var n/edx: int = size-of(stmt->var) +14548 (size-of %ecx) # => eax +14549 89/<- %edx 0/r32/eax +14550 # *Curr-local-stack-offset -= n +14551 29/subtract-from *Curr-local-stack-offset 2/r32/edx +14552 # v->offset = *Curr-local-stack-offset +14553 8b/-> *Curr-local-stack-offset 0/r32/eax +14554 89/<- *(ecx+0x14) 0/r32/eax # Var-offset +14555 # if v is an array, do something special to initialize it +14556 { +14557 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +14558 (is-mu-array? %eax) # => eax +14559 3d/compare-eax-and 0/imm32/false +14560 0f 84/jump-if-= break/disp32 +14561 # var array-size-without-size/edx: int = n-4 +14562 81 5/subop/subtract %edx 4/imm32 +14563 # +14564 (emit-array-data-initialization *(ebp+8) %edx) +14565 e9/jump $emit-subx-var-def:end/disp32 +14566 } +14567 # another special-case for initializing streams +14568 # a stream is an array with 2 extra pointers +14569 { +14570 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +14571 (is-mu-stream? %eax) # => eax +14572 3d/compare-eax-and 0/imm32/false +14573 0f 84/jump-if-= break/disp32 +14574 # var array-size-without-size/edx: int = n-12 +14575 81 5/subop/subtract %edx 0xc/imm32 +14576 (emit-array-data-initialization *(ebp+8) %edx) +14577 # emit read and write pointers +14578 (emit-indent *(ebp+8) *Curr-block-depth) +14579 (write-buffered *(ebp+8) "68/push 0/imm32\n") +14580 (emit-indent *(ebp+8) *Curr-block-depth) +14581 (write-buffered *(ebp+8) "68/push 0/imm32\n") +14582 # +14583 eb/jump $emit-subx-var-def:end/disp8 +14584 } +14585 # while n > 0 +14586 { +14587 81 7/subop/compare %edx 0/imm32 +14588 7e/jump-if-<= break/disp8 +14589 (emit-indent *(ebp+8) *Curr-block-depth) +14590 (write-buffered *(ebp+8) "68/push 0/imm32\n") +14591 # n -= 4 +14592 81 5/subop/subtract %edx 4/imm32 +14593 # +14594 eb/jump loop/disp8 14595 } -14596 # write to stream -14597 { -14598 # if (!string-equal?(stmt->operation, "write-to-stream")) break -14599 (string-equal? %ecx "write-to-stream") # => eax -14600 3d/compare-eax-and 0/imm32 -14601 0f 84/jump-if-= break/disp32 -14602 (translate-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -14603 e9/jump $emit-subx-stmt:end/disp32 -14604 } -14605 # - if stmt matches a primitive, emit it -14606 { -14607 $emit-subx-stmt:check-for-primitive: -14608 # var curr/eax: (addr primitive) -14609 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax -14610 3d/compare-eax-and 0/imm32 -14611 74/jump-if-= break/disp8 -14612 $emit-subx-stmt:primitive: -14613 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr -14614 e9/jump $emit-subx-stmt:end/disp32 -14615 } -14616 # - otherwise emit a call -14617 # TODO: type-checking -14618 $emit-subx-stmt:call: -14619 (emit-call *(ebp+8) *(ebp+0xc)) -14620 $emit-subx-stmt:end: -14621 # . restore registers -14622 59/pop-to-ecx -14623 58/pop-to-eax -14624 # . epilogue -14625 89/<- %esp 5/r32/ebp -14626 5d/pop-to-ebp -14627 c3/return -14628 -14629 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -14630 # . prologue -14631 55/push-ebp -14632 89/<- %ebp 4/r32/esp -14633 # . save registers -14634 50/push-eax -14635 51/push-ecx -14636 52/push-edx -14637 53/push-ebx -14638 56/push-esi -14639 # esi = stmt -14640 8b/-> *(ebp+0xc) 6/r32/esi -14641 # var base/ebx: (addr var) = stmt->inouts[0]->value -14642 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -14643 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -14644 89/<- %ebx 0/r32/eax -14645 # var elemsize/ecx: int = array-element-size(base) -14646 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -14647 89/<- %ecx 0/r32/eax -14648 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register -14649 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -14650 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -14651 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -14652 89/<- %edx 0/r32/eax -14653 # if elemsize == 1 -14654 { -14655 81 7/subop/compare %ecx 1/imm32 -14656 75/jump-if-!= break/disp8 -14657 $translate-mu-length-stmt:size-1: -14658 (emit-save-size-to *(ebp+8) %ebx %edx) -14659 e9/jump $translate-mu-length-stmt:end/disp32 -14660 } -14661 # if elemsize is a power of 2 less than 256 -14662 { -14663 (power-of-2? %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -14664 3d/compare-eax-and 0/imm32/false -14665 74/jump-if-= break/disp8 -14666 81 7/subop/compare %ecx 0xff/imm32 -14667 7f/jump-if-> break/disp8 -14668 $translate-mu-length-stmt:size-power-of-2: -14669 (emit-save-size-to *(ebp+8) %ebx %edx) -14670 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) -14671 e9/jump $translate-mu-length-stmt:end/disp32 +14596 $emit-subx-var-def:end: +14597 # . restore registers +14598 5a/pop-to-edx +14599 59/pop-to-ecx +14600 58/pop-to-eax +14601 # . epilogue +14602 89/<- %esp 5/r32/ebp +14603 5d/pop-to-ebp +14604 c3/return +14605 +14606 emit-array-data-initialization: # out: (addr buffered-file), n: int +14607 # . prologue +14608 55/push-ebp +14609 89/<- %ebp 4/r32/esp +14610 # +14611 (emit-indent *(ebp+8) *Curr-block-depth) +14612 (write-buffered *(ebp+8) "(push-n-zero-bytes ") +14613 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) +14614 (write-buffered *(ebp+8) ")\n") +14615 (emit-indent *(ebp+8) *Curr-block-depth) +14616 (write-buffered *(ebp+8) "68/push ") +14617 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) +14618 (write-buffered *(ebp+8) "/imm32\n") +14619 $emit-array-data-initialization:end: +14620 # . epilogue +14621 89/<- %esp 5/r32/ebp +14622 5d/pop-to-ebp +14623 c3/return +14624 +14625 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) +14626 # . prologue +14627 55/push-ebp +14628 89/<- %ebp 4/r32/esp +14629 # . save registers +14630 50/push-eax +14631 51/push-ecx +14632 # - some special-case primitives that don't actually use the 'primitives' data structure +14633 # var op/ecx: (addr array byte) = lookup(stmt->operation) +14634 8b/-> *(ebp+0xc) 1/r32/ecx +14635 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +14636 89/<- %ecx 0/r32/eax +14637 # array size +14638 { +14639 # if (!string-equal?(stmt->operation, "length")) break +14640 (string-equal? %ecx "length") # => eax +14641 3d/compare-eax-and 0/imm32 +14642 0f 84/jump-if-= break/disp32 +14643 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14644 e9/jump $emit-subx-stmt:end/disp32 +14645 } +14646 # index into array +14647 { +14648 # if (!string-equal?(stmt->operation, "index")) break +14649 (string-equal? %ecx "index") # => eax +14650 3d/compare-eax-and 0/imm32 +14651 0f 84/jump-if-= break/disp32 +14652 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14653 e9/jump $emit-subx-stmt:end/disp32 +14654 } +14655 # compute-offset for index into array +14656 { +14657 # if (!string-equal?(stmt->operation, "compute-offset")) break +14658 (string-equal? %ecx "compute-offset") # => eax +14659 3d/compare-eax-and 0/imm32 +14660 0f 84/jump-if-= break/disp32 +14661 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14662 e9/jump $emit-subx-stmt:end/disp32 +14663 } +14664 # get field from record +14665 { +14666 # if (!string-equal?(stmt->operation, "get")) break +14667 (string-equal? %ecx "get") # => eax +14668 3d/compare-eax-and 0/imm32 +14669 0f 84/jump-if-= break/disp32 +14670 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) +14671 e9/jump $emit-subx-stmt:end/disp32 14672 } -14673 # otherwise, the complex case -14674 # . emit register spills -14675 { -14676 $translate-mu-length-stmt:complex: -14677 (string-equal? %edx "eax") # => eax -14678 3d/compare-eax-and 0/imm32/false -14679 75/break-if-!= break/disp8 -14680 (emit-indent *(ebp+8) *Curr-block-depth) -14681 (write-buffered *(ebp+8) "50/push-eax\n") -14682 } +14673 # allocate scalar +14674 { +14675 # if (!string-equal?(stmt->operation, "allocate")) break +14676 (string-equal? %ecx "allocate") # => eax +14677 3d/compare-eax-and 0/imm32 +14678 0f 84/jump-if-= break/disp32 +14679 (translate-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14680 e9/jump $emit-subx-stmt:end/disp32 +14681 } +14682 # allocate array 14683 { -14684 (string-equal? %edx "ecx") # => eax -14685 3d/compare-eax-and 0/imm32/false -14686 75/break-if-!= break/disp8 -14687 (emit-indent *(ebp+8) *Curr-block-depth) -14688 (write-buffered *(ebp+8) "51/push-ecx\n") -14689 } -14690 { -14691 (string-equal? %edx "edx") # => eax -14692 3d/compare-eax-and 0/imm32/false -14693 75/break-if-!= break/disp8 -14694 (emit-indent *(ebp+8) *Curr-block-depth) -14695 (write-buffered *(ebp+8) "52/push-edx\n") -14696 } -14697 # . -14698 (emit-save-size-to *(ebp+8) %ebx "eax") -14699 (emit-indent *(ebp+8) *Curr-block-depth) -14700 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") -14701 (emit-indent *(ebp+8) *Curr-block-depth) -14702 (write-buffered *(ebp+8) "b9/copy-to-ecx ") -14703 (write-int32-hex-buffered *(ebp+8) %ecx) -14704 (write-buffered *(ebp+8) "/imm32\n") -14705 (emit-indent *(ebp+8) *Curr-block-depth) -14706 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") -14707 { -14708 (string-equal? %edx "eax") # => eax -14709 3d/compare-eax-and 0/imm32/false -14710 75/break-if-!= break/disp8 -14711 (emit-indent *(ebp+8) *Curr-block-depth) -14712 (write-buffered *(ebp+8) "89/<- %") -14713 (write-buffered *(ebp+8) %edx) -14714 (write-buffered *(ebp+8) " 0/r32/eax\n") -14715 } -14716 # . emit register restores -14717 { -14718 (string-equal? %edx "edx") # => eax -14719 3d/compare-eax-and 0/imm32/false -14720 75/break-if-!= break/disp8 -14721 (emit-indent *(ebp+8) *Curr-block-depth) -14722 (write-buffered *(ebp+8) "5a/pop-to-edx\n") -14723 } -14724 { -14725 (string-equal? %edx "ecx") # => eax -14726 3d/compare-eax-and 0/imm32/false -14727 75/break-if-!= break/disp8 -14728 (emit-indent *(ebp+8) *Curr-block-depth) -14729 (write-buffered *(ebp+8) "59/pop-to-ecx\n") -14730 } -14731 { -14732 (string-equal? %edx "eax") # => eax -14733 3d/compare-eax-and 0/imm32/false -14734 75/break-if-!= break/disp8 -14735 (emit-indent *(ebp+8) *Curr-block-depth) -14736 (write-buffered *(ebp+8) "58/pop-to-eax\n") -14737 } -14738 $translate-mu-length-stmt:end: -14739 # . restore registers -14740 5e/pop-to-esi -14741 5b/pop-to-ebx -14742 5a/pop-to-edx -14743 59/pop-to-ecx -14744 58/pop-to-eax -14745 # . epilogue -14746 89/<- %esp 5/r32/ebp -14747 5d/pop-to-ebp -14748 c3/return -14749 -14750 array-element-size: # arr: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -14751 # . prologue -14752 55/push-ebp -14753 89/<- %ebp 4/r32/esp -14754 # -14755 (array-element-type-id *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax -14756 (size-of-type-id-as-array-element %eax) # => eax -14757 $array-element-size:end: -14758 # . epilogue -14759 89/<- %esp 5/r32/ebp -14760 5d/pop-to-ebp -14761 c3/return -14762 -14763 array-element-type-id: # v: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: type-id -14764 # precondition: n is positive -14765 # . prologue -14766 55/push-ebp -14767 89/<- %ebp 4/r32/esp -14768 # -14769 8b/-> *(ebp+8) 0/r32/eax -14770 # var t/eax: (addr type-tree) -14771 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -14772 # if t == 0 abort -14773 3d/compare-eax-with 0/imm32 -14774 0f 84/jump-if-== $array-element-type-id:error0/disp32 -14775 # if t->is-atom? abort -14776 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -14777 0f 85/jump-if-!= $array-element-type-id:error1/disp32 -14778 # if (t->left == addr) t = t->right -14779 { -14780 50/push-eax -14781 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -14782 (is-simple-mu-type? %eax 2) # addr => eax -14783 3d/compare-eax-with 0/imm32/false -14784 58/pop-to-eax -14785 74/jump-if-= break/disp8 -14786 $array-element-type-id:skip-addr: -14787 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -14788 } -14789 # if t == 0 abort -14790 3d/compare-eax-with 0/imm32 -14791 0f 84/jump-if-= $array-element-type-id:error2/disp32 -14792 # if t->is-atom? abort -14793 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -14794 0f 85/jump-if-!= $array-element-type-id:error2/disp32 -14795 # if t->left != array abort +14684 # if (!string-equal?(stmt->operation, "populate")) break +14685 (string-equal? %ecx "populate") # => eax +14686 3d/compare-eax-and 0/imm32 +14687 0f 84/jump-if-= break/disp32 +14688 (translate-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14689 e9/jump $emit-subx-stmt:end/disp32 +14690 } +14691 # allocate stream +14692 { +14693 # if (!string-equal?(stmt->operation, "populate-stream")) break +14694 (string-equal? %ecx "populate-stream") # => eax +14695 3d/compare-eax-and 0/imm32 +14696 0f 84/jump-if-= break/disp32 +14697 (translate-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14698 e9/jump $emit-subx-stmt:end/disp32 +14699 } +14700 # read from stream +14701 { +14702 # if (!string-equal?(stmt->operation, "read-from-stream")) break +14703 (string-equal? %ecx "read-from-stream") # => eax +14704 3d/compare-eax-and 0/imm32 +14705 0f 84/jump-if-= break/disp32 +14706 (translate-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14707 e9/jump $emit-subx-stmt:end/disp32 +14708 } +14709 # write to stream +14710 { +14711 # if (!string-equal?(stmt->operation, "write-to-stream")) break +14712 (string-equal? %ecx "write-to-stream") # => eax +14713 3d/compare-eax-and 0/imm32 +14714 0f 84/jump-if-= break/disp32 +14715 (translate-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +14716 e9/jump $emit-subx-stmt:end/disp32 +14717 } +14718 # - if stmt matches a primitive, emit it +14719 { +14720 $emit-subx-stmt:check-for-primitive: +14721 # var curr/eax: (addr primitive) +14722 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax +14723 3d/compare-eax-and 0/imm32 +14724 74/jump-if-= break/disp8 +14725 $emit-subx-stmt:primitive: +14726 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr +14727 e9/jump $emit-subx-stmt:end/disp32 +14728 } +14729 # - otherwise emit a call +14730 # TODO: type-checking +14731 $emit-subx-stmt:call: +14732 (emit-call *(ebp+8) *(ebp+0xc)) +14733 $emit-subx-stmt:end: +14734 # . restore registers +14735 59/pop-to-ecx +14736 58/pop-to-eax +14737 # . epilogue +14738 89/<- %esp 5/r32/ebp +14739 5d/pop-to-ebp +14740 c3/return +14741 +14742 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +14743 # . prologue +14744 55/push-ebp +14745 89/<- %ebp 4/r32/esp +14746 # . save registers +14747 50/push-eax +14748 51/push-ecx +14749 52/push-edx +14750 53/push-ebx +14751 56/push-esi +14752 # esi = stmt +14753 8b/-> *(ebp+0xc) 6/r32/esi +14754 # var base/ebx: (addr var) = stmt->inouts[0]->value +14755 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +14756 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +14757 89/<- %ebx 0/r32/eax +14758 # var elemsize/ecx: int = array-element-size(base) +14759 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +14760 89/<- %ecx 0/r32/eax +14761 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register +14762 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +14763 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +14764 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +14765 89/<- %edx 0/r32/eax +14766 # if elemsize == 1 +14767 { +14768 81 7/subop/compare %ecx 1/imm32 +14769 75/jump-if-!= break/disp8 +14770 $translate-mu-length-stmt:size-1: +14771 (emit-save-size-to *(ebp+8) %ebx %edx) +14772 e9/jump $translate-mu-length-stmt:end/disp32 +14773 } +14774 # if elemsize is a power of 2 less than 256 +14775 { +14776 (power-of-2? %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +14777 3d/compare-eax-and 0/imm32/false +14778 74/jump-if-= break/disp8 +14779 81 7/subop/compare %ecx 0xff/imm32 +14780 7f/jump-if-> break/disp8 +14781 $translate-mu-length-stmt:size-power-of-2: +14782 (emit-save-size-to *(ebp+8) %ebx %edx) +14783 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) +14784 e9/jump $translate-mu-length-stmt:end/disp32 +14785 } +14786 # otherwise, the complex case +14787 # . emit register spills +14788 { +14789 $translate-mu-length-stmt:complex: +14790 (string-equal? %edx "eax") # => eax +14791 3d/compare-eax-and 0/imm32/false +14792 75/break-if-!= break/disp8 +14793 (emit-indent *(ebp+8) *Curr-block-depth) +14794 (write-buffered *(ebp+8) "50/push-eax\n") +14795 } 14796 { -14797 50/push-eax -14798 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -14799 (is-simple-mu-type? %eax 3) # array => eax -14800 3d/compare-eax-with 0/imm32/false -14801 58/pop-to-eax -14802 $array-element-type-id:no-array: -14803 0f 84/jump-if-= $array-element-type-id:error2/disp32 -14804 } -14805 $array-element-type-id:skip-array: -14806 # t = t->right -14807 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -14808 # if t == 0 abort -14809 3d/compare-eax-with 0/imm32 -14810 0f 84/jump-if-= $array-element-type-id:error2/disp32 -14811 # if t->is-atom? abort -14812 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -14813 0f 85/jump-if-!= $array-element-type-id:error2/disp32 -14814 # return t->left->value -14815 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -14816 8b/-> *(eax+4) 0/r32/eax # Type-tree-value -14817 $array-element-type-id:end: -14818 # . epilogue -14819 89/<- %esp 5/r32/ebp -14820 5d/pop-to-ebp -14821 c3/return -14822 -14823 $array-element-type-id:error0: -14824 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -14825 50/push-eax -14826 8b/-> *(ebp+8) 0/r32/eax -14827 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14828 (write-buffered *(ebp+0xc) %eax) -14829 58/pop-to-eax -14830 (write-buffered *(ebp+0xc) "' has no type\n") -14831 (flush *(ebp+0xc)) -14832 (stop *(ebp+0x10) 1) -14833 # never gets here -14834 -14835 $array-element-type-id:error1: -14836 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -14837 50/push-eax -14838 8b/-> *(ebp+8) 0/r32/eax -14839 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14840 (write-buffered *(ebp+0xc) %eax) -14841 58/pop-to-eax -14842 (write-buffered *(ebp+0xc) "' has atomic type ") -14843 (write-int32-hex-buffered *(ebp+0xc) *(eax+4)) # Type-tree-value -14844 (write-buffered *(ebp+0xc) Newline) -14845 (flush *(ebp+0xc)) -14846 (stop *(ebp+0x10) 1) -14847 # never gets here -14848 -14849 $array-element-type-id:error2: -14850 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -14851 50/push-eax -14852 8b/-> *(ebp+8) 0/r32/eax -14853 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14854 (write-buffered *(ebp+0xc) %eax) -14855 58/pop-to-eax -14856 (write-buffered *(ebp+0xc) "' has non-array type\n") -14857 (flush *(ebp+0xc)) -14858 (stop *(ebp+0x10) 1) -14859 # never gets here -14860 -14861 size-of-type-id-as-array-element: # t: type-id -> result/eax: int -14862 # . prologue -14863 55/push-ebp -14864 89/<- %ebp 4/r32/esp -14865 # eax = t -14866 8b/-> *(ebp+8) 0/r32/eax -14867 # if t is 'byte', size is 1 -14868 3d/compare-eax-and 8/imm32/byte -14869 { -14870 75/jump-if-!= break/disp8 -14871 b8/copy-to-eax 1/imm32 -14872 eb/jump $size-of-type-id-as-array-element:end/disp8 -14873 } -14874 # otherwise proceed as usual -14875 (size-of-type-id %eax) # => eax -14876 $size-of-type-id-as-array-element:end: -14877 # . epilogue -14878 89/<- %esp 5/r32/ebp -14879 5d/pop-to-ebp -14880 c3/return -14881 -14882 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) -14883 # . prologue -14884 55/push-ebp -14885 89/<- %ebp 4/r32/esp -14886 # . save registers -14887 50/push-eax -14888 53/push-ebx -14889 # ebx = base -14890 8b/-> *(ebp+0xc) 3/r32/ebx -14891 (emit-indent *(ebp+8) *Curr-block-depth) -14892 (write-buffered *(ebp+8) "8b/-> *") -14893 # if base is an (addr array ...) in a register -14894 { -14895 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register -14896 74/jump-if-= break/disp8 -14897 $emit-save-size-to:emit-base-from-register: -14898 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -14899 (write-buffered *(ebp+8) %eax) -14900 eb/jump $emit-save-size-to:emit-output/disp8 +14797 (string-equal? %edx "ecx") # => eax +14798 3d/compare-eax-and 0/imm32/false +14799 75/break-if-!= break/disp8 +14800 (emit-indent *(ebp+8) *Curr-block-depth) +14801 (write-buffered *(ebp+8) "51/push-ecx\n") +14802 } +14803 { +14804 (string-equal? %edx "edx") # => eax +14805 3d/compare-eax-and 0/imm32/false +14806 75/break-if-!= break/disp8 +14807 (emit-indent *(ebp+8) *Curr-block-depth) +14808 (write-buffered *(ebp+8) "52/push-edx\n") +14809 } +14810 # . +14811 (emit-save-size-to *(ebp+8) %ebx "eax") +14812 (emit-indent *(ebp+8) *Curr-block-depth) +14813 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") +14814 (emit-indent *(ebp+8) *Curr-block-depth) +14815 (write-buffered *(ebp+8) "b9/copy-to-ecx ") +14816 (write-int32-hex-buffered *(ebp+8) %ecx) +14817 (write-buffered *(ebp+8) "/imm32\n") +14818 (emit-indent *(ebp+8) *Curr-block-depth) +14819 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") +14820 { +14821 (string-equal? %edx "eax") # => eax +14822 3d/compare-eax-and 0/imm32/false +14823 75/break-if-!= break/disp8 +14824 (emit-indent *(ebp+8) *Curr-block-depth) +14825 (write-buffered *(ebp+8) "89/<- %") +14826 (write-buffered *(ebp+8) %edx) +14827 (write-buffered *(ebp+8) " 0/r32/eax\n") +14828 } +14829 # . emit register restores +14830 { +14831 (string-equal? %edx "edx") # => eax +14832 3d/compare-eax-and 0/imm32/false +14833 75/break-if-!= break/disp8 +14834 (emit-indent *(ebp+8) *Curr-block-depth) +14835 (write-buffered *(ebp+8) "5a/pop-to-edx\n") +14836 } +14837 { +14838 (string-equal? %edx "ecx") # => eax +14839 3d/compare-eax-and 0/imm32/false +14840 75/break-if-!= break/disp8 +14841 (emit-indent *(ebp+8) *Curr-block-depth) +14842 (write-buffered *(ebp+8) "59/pop-to-ecx\n") +14843 } +14844 { +14845 (string-equal? %edx "eax") # => eax +14846 3d/compare-eax-and 0/imm32/false +14847 75/break-if-!= break/disp8 +14848 (emit-indent *(ebp+8) *Curr-block-depth) +14849 (write-buffered *(ebp+8) "58/pop-to-eax\n") +14850 } +14851 $translate-mu-length-stmt:end: +14852 # . restore registers +14853 5e/pop-to-esi +14854 5b/pop-to-ebx +14855 5a/pop-to-edx +14856 59/pop-to-ecx +14857 58/pop-to-eax +14858 # . epilogue +14859 89/<- %esp 5/r32/ebp +14860 5d/pop-to-ebp +14861 c3/return +14862 +14863 array-element-size: # arr: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +14864 # . prologue +14865 55/push-ebp +14866 89/<- %ebp 4/r32/esp +14867 # +14868 (array-element-type-id *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax +14869 (size-of-type-id-as-array-element %eax) # => eax +14870 $array-element-size:end: +14871 # . epilogue +14872 89/<- %esp 5/r32/ebp +14873 5d/pop-to-ebp +14874 c3/return +14875 +14876 array-element-type-id: # v: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: type-id +14877 # precondition: n is positive +14878 # . prologue +14879 55/push-ebp +14880 89/<- %ebp 4/r32/esp +14881 # +14882 8b/-> *(ebp+8) 0/r32/eax +14883 # var t/eax: (addr type-tree) +14884 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +14885 # if t == 0 abort +14886 3d/compare-eax-with 0/imm32 +14887 0f 84/jump-if-== $array-element-type-id:error0/disp32 +14888 # if t->is-atom? abort +14889 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +14890 0f 85/jump-if-!= $array-element-type-id:error1/disp32 +14891 # if (t->left == addr) t = t->right +14892 { +14893 50/push-eax +14894 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +14895 (is-simple-mu-type? %eax 2) # addr => eax +14896 3d/compare-eax-with 0/imm32/false +14897 58/pop-to-eax +14898 74/jump-if-= break/disp8 +14899 $array-element-type-id:skip-addr: +14900 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax 14901 } -14902 # otherwise if base is an (array ...) on the stack -14903 { -14904 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset -14905 74/jump-if-= break/disp8 -14906 $emit-save-size-to:emit-base-from-stack: -14907 (write-buffered *(ebp+8) "(ebp+") -14908 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14)) # Var-offset -14909 (write-buffered *(ebp+8) ")") -14910 } -14911 $emit-save-size-to:emit-output: -14912 (write-buffered *(ebp+8) " ") -14913 (get Mu-registers *(ebp+0x10) 0xc "Mu-registers") # => eax -14914 (write-int32-hex-buffered *(ebp+8) *eax) -14915 (write-buffered *(ebp+8) "/r32\n") -14916 $emit-save-size-to:end: -14917 # . restore registers -14918 5b/pop-to-ebx -14919 58/pop-to-eax -14920 # . epilogue -14921 89/<- %esp 5/r32/ebp -14922 5d/pop-to-ebp -14923 c3/return -14924 -14925 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int -14926 # . prologue -14927 55/push-ebp -14928 89/<- %ebp 4/r32/esp -14929 # . save registers -14930 50/push-eax -14931 # -14932 (emit-indent *(ebp+8) *Curr-block-depth) -14933 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") -14934 (write-buffered *(ebp+8) *(ebp+0xc)) -14935 (write-buffered *(ebp+8) Space) -14936 (num-shift-rights *(ebp+0x10)) # => eax -14937 (write-int32-hex-buffered *(ebp+8) %eax) -14938 (write-buffered *(ebp+8) "/imm8\n") -14939 $emit-divide-by-shift-right:end: -14940 # . restore registers -14941 58/pop-to-eax -14942 # . epilogue -14943 89/<- %esp 5/r32/ebp -14944 5d/pop-to-ebp -14945 c3/return -14946 -14947 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -14948 # . prologue -14949 55/push-ebp -14950 89/<- %ebp 4/r32/esp -14951 # . save registers -14952 51/push-ecx -14953 # ecx = stmt -14954 8b/-> *(ebp+0xc) 1/r32/ecx -14955 # var base/ecx: (addr var) = stmt->inouts[0] -14956 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -14957 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -14958 89/<- %ecx 0/r32/eax -14959 # if (var->register) do one thing -14960 { -14961 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -14962 74/jump-if-= break/disp8 -14963 # TODO: ensure there's no dereference -14964 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -14965 eb/jump $translate-mu-index-stmt:end/disp8 -14966 } -14967 # if (var->offset) do a different thing -14968 { -14969 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset -14970 74/jump-if-= break/disp8 -14971 # TODO: ensure there's no dereference -14972 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -14973 eb/jump $translate-mu-index-stmt:end/disp8 -14974 } -14975 $translate-mu-index-stmt:end: -14976 # . restore registers -14977 59/pop-to-ecx -14978 # . epilogue -14979 89/<- %esp 5/r32/ebp -14980 5d/pop-to-ebp -14981 c3/return -14982 -14983 $translate-mu-index-stmt-with-array:error1: -14984 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") -14985 (flush *(ebp+0x10)) -14986 (stop *(ebp+0x14) 1) -14987 # never gets here -14988 -14989 $translate-mu-index-stmt-with-array:error2: -14990 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") -14991 (flush *(ebp+0x10)) -14992 (stop *(ebp+0x14) 1) -14993 # never gets here +14902 # if t == 0 abort +14903 3d/compare-eax-with 0/imm32 +14904 0f 84/jump-if-= $array-element-type-id:error2/disp32 +14905 # if t->is-atom? abort +14906 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +14907 0f 85/jump-if-!= $array-element-type-id:error2/disp32 +14908 # if t->left != array abort +14909 { +14910 50/push-eax +14911 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +14912 (is-simple-mu-type? %eax 3) # array => eax +14913 3d/compare-eax-with 0/imm32/false +14914 58/pop-to-eax +14915 $array-element-type-id:no-array: +14916 0f 84/jump-if-= $array-element-type-id:error2/disp32 +14917 } +14918 $array-element-type-id:skip-array: +14919 # t = t->right +14920 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +14921 # if t == 0 abort +14922 3d/compare-eax-with 0/imm32 +14923 0f 84/jump-if-= $array-element-type-id:error2/disp32 +14924 # if t->is-atom? abort +14925 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +14926 0f 85/jump-if-!= $array-element-type-id:error2/disp32 +14927 # return t->left->value +14928 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +14929 8b/-> *(eax+4) 0/r32/eax # Type-tree-value +14930 $array-element-type-id:end: +14931 # . epilogue +14932 89/<- %esp 5/r32/ebp +14933 5d/pop-to-ebp +14934 c3/return +14935 +14936 $array-element-type-id:error0: +14937 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +14938 50/push-eax +14939 8b/-> *(ebp+8) 0/r32/eax +14940 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14941 (write-buffered *(ebp+0xc) %eax) +14942 58/pop-to-eax +14943 (write-buffered *(ebp+0xc) "' has no type\n") +14944 (flush *(ebp+0xc)) +14945 (stop *(ebp+0x10) 1) +14946 # never gets here +14947 +14948 $array-element-type-id:error1: +14949 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +14950 50/push-eax +14951 8b/-> *(ebp+8) 0/r32/eax +14952 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14953 (write-buffered *(ebp+0xc) %eax) +14954 58/pop-to-eax +14955 (write-buffered *(ebp+0xc) "' has atomic type ") +14956 (write-int32-hex-buffered *(ebp+0xc) *(eax+4)) # Type-tree-value +14957 (write-buffered *(ebp+0xc) Newline) +14958 (flush *(ebp+0xc)) +14959 (stop *(ebp+0x10) 1) +14960 # never gets here +14961 +14962 $array-element-type-id:error2: +14963 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +14964 50/push-eax +14965 8b/-> *(ebp+8) 0/r32/eax +14966 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14967 (write-buffered *(ebp+0xc) %eax) +14968 58/pop-to-eax +14969 (write-buffered *(ebp+0xc) "' has non-array type\n") +14970 (flush *(ebp+0xc)) +14971 (stop *(ebp+0x10) 1) +14972 # never gets here +14973 +14974 size-of-type-id-as-array-element: # t: type-id -> result/eax: int +14975 # . prologue +14976 55/push-ebp +14977 89/<- %ebp 4/r32/esp +14978 # eax = t +14979 8b/-> *(ebp+8) 0/r32/eax +14980 # if t is 'byte', size is 1 +14981 3d/compare-eax-and 8/imm32/byte +14982 { +14983 75/jump-if-!= break/disp8 +14984 b8/copy-to-eax 1/imm32 +14985 eb/jump $size-of-type-id-as-array-element:end/disp8 +14986 } +14987 # otherwise proceed as usual +14988 (size-of-type-id %eax) # => eax +14989 $size-of-type-id-as-array-element:end: +14990 # . epilogue +14991 89/<- %esp 5/r32/ebp +14992 5d/pop-to-ebp +14993 c3/return 14994 -14995 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +14995 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) 14996 # . prologue 14997 55/push-ebp 14998 89/<- %ebp 4/r32/esp 14999 # . save registers 15000 50/push-eax -15001 51/push-ecx -15002 52/push-edx -15003 53/push-ebx -15004 # -15005 (emit-indent *(ebp+8) *Curr-block-depth) -15006 (write-buffered *(ebp+8) "8d/copy-address *(") -15007 # TODO: ensure inouts[0] is in a register and not dereferenced -15008 $translate-mu-index-stmt-with-array-in-register:emit-base: -15009 # ecx = stmt -15010 8b/-> *(ebp+0xc) 1/r32/ecx -15011 # var base/ebx: (addr var) = inouts[0] -15012 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15013 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15014 89/<- %ebx 0/r32/eax -15015 # print base->register " + " -15016 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -15017 (write-buffered *(ebp+8) %eax) -15018 (write-buffered *(ebp+8) " + ") -15019 # var index/edx: (addr var) = inouts[1] -15020 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15021 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -15022 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15023 89/<- %edx 0/r32/eax -15024 # if index->register -15025 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register -15026 { -15027 0f 84/jump-if-= break/disp32 -15028 $translate-mu-index-stmt-with-array-in-register:emit-register-index: -15029 # if index is an int -15030 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15031 (is-simple-mu-type? %eax 1) # int => eax -15032 3d/compare-eax-and 0/imm32/false -15033 { -15034 0f 84/jump-if-= break/disp32 -15035 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: -15036 # print index->register "<<" log2(array-element-size(base)) " + 4) " -15037 # . index->register "<<" -15038 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15039 (write-buffered *(ebp+8) %eax) -15040 (write-buffered *(ebp+8) "<<") -15041 # . log2(array-element-size(base->type)) -15042 # TODO: ensure size is a power of 2 -15043 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -15044 (num-shift-rights %eax) # => eax -15045 (write-int32-hex-buffered *(ebp+8) %eax) -15046 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 -15047 } -15048 # if index->type is any other atom, abort -15049 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15050 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -15051 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 -15052 # if index has type (offset ...) -15053 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15054 (is-simple-mu-type? %eax 7) # => eax -15055 3d/compare-eax-and 0/imm32/false -15056 { -15057 0f 84/jump-if-= break/disp32 -15058 # print index->register -15059 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: -15060 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15061 (write-buffered *(ebp+8) %eax) -15062 } -15063 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: -15064 (write-buffered *(ebp+8) " + 4) ") -15065 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 -15066 } -15067 # otherwise if index is a literal -15068 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15069 (is-simple-mu-type? %eax 0) # => eax -15070 3d/compare-eax-and 0/imm32/false -15071 { -15072 0f 84/jump-if-= break/disp32 -15073 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: -15074 # var index-value/edx: int = parse-hex-int(index->name) -15075 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15076 (parse-hex-int %eax) # => eax -15077 89/<- %edx 0/r32/eax -15078 # offset = idx-value * array-element-size(base->type) -15079 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -15080 f7 4/subop/multiply-into-eax %edx # clobbers edx -15081 # offset += 4 for array size -15082 05/add-to-eax 4/imm32 -15083 # TODO: check edx for overflow -15084 # print offset -15085 (write-int32-hex-buffered *(ebp+8) %eax) -15086 (write-buffered *(ebp+8) ") ") -15087 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 -15088 } -15089 # otherwise abort -15090 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 -15091 $translate-mu-index-stmt-with-array-in-register:emit-output: -15092 # outputs[0] "/r32" -15093 8b/-> *(ebp+0xc) 1/r32/ecx -15094 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -15095 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15096 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -15097 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -15098 (write-int32-hex-buffered *(ebp+8) *eax) -15099 (write-buffered *(ebp+8) "/r32\n") -15100 $translate-mu-index-stmt-with-array-in-register:end: -15101 # . restore registers -15102 5b/pop-to-ebx -15103 5a/pop-to-edx -15104 59/pop-to-ecx -15105 58/pop-to-eax -15106 # . epilogue -15107 89/<- %esp 5/r32/ebp -15108 5d/pop-to-ebp -15109 c3/return -15110 -15111 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15112 # . prologue -15113 55/push-ebp -15114 89/<- %ebp 4/r32/esp -15115 # . save registers -15116 50/push-eax -15117 51/push-ecx -15118 52/push-edx -15119 53/push-ebx -15120 # -15121 (emit-indent *(ebp+8) *Curr-block-depth) -15122 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") -15123 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) -15124 8b/-> *(ebp+0xc) 0/r32/eax -15125 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15126 89/<- %edx 0/r32/eax -15127 # var base/ecx: (addr var) = lookup(curr->value) -15128 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15129 89/<- %ecx 0/r32/eax -15130 # var curr2/eax: (addr stmt-var) = lookup(curr->next) -15131 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax -15132 # var index/edx: (handle var) = curr2->value -15133 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15134 89/<- %edx 0/r32/eax -15135 # if index->register -15136 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register -15137 { -15138 0f 84/jump-if-= break/disp32 -15139 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: -15140 # if index is an int -15141 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15142 (is-simple-mu-type? %eax 1) # int => eax -15143 3d/compare-eax-and 0/imm32/false -15144 { -15145 0f 84/jump-if-= break/disp32 -15146 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: -15147 # print index->register "<<" log2(array-element-size(base)) " + " base->offset+4 -15148 # . inouts[1]->register "<<" -15149 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15150 (write-buffered *(ebp+8) %eax) -15151 (write-buffered *(ebp+8) "<<") -15152 # . log2(array-element-size(base)) -15153 # TODO: ensure size is a power of 2 -15154 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -15155 (num-shift-rights %eax) # => eax -15156 (write-int32-hex-buffered *(ebp+8) %eax) -15157 # -15158 (write-buffered *(ebp+8) " + ") -15159 # -15160 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset -15161 05/add-to-eax 4/imm32 # for array length -15162 (write-int32-hex-buffered *(ebp+8) %eax) -15163 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 -15164 } -15165 # if index->type is any other atom, abort -15166 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15167 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -15168 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 -15169 # if index has type (offset ...) -15170 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15171 (is-simple-mu-type? %eax 7) # => eax -15172 3d/compare-eax-and 0/imm32/false -15173 { -15174 0f 84/jump-if-= break/disp32 -15175 # print index->register -15176 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: -15177 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15178 (write-buffered *(ebp+8) %eax) -15179 } -15180 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: -15181 (write-buffered *(ebp+8) ") ") -15182 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 -15183 } -15184 # otherwise if index is a literal -15185 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15186 (is-simple-mu-type? %eax 0) # => eax -15187 3d/compare-eax-and 0/imm32/false -15188 { -15189 0f 84/jump-if-= break/disp32 -15190 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: -15191 # var idx-value/edx: int = parse-hex-int(index->name) -15192 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15193 (parse-hex-int %eax) # Var-name => eax -15194 89/<- %edx 0/r32/eax -15195 # offset = idx-value * array-element-size(base) -15196 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -15197 f7 4/subop/multiply-into-eax %edx # clobbers edx -15198 # offset += base->offset -15199 03/add *(ecx+0x14) 0/r32/eax # Var-offset -15200 # offset += 4 for array size -15201 05/add-to-eax 4/imm32 -15202 # TODO: check edx for overflow -15203 # print offset -15204 (write-int32-hex-buffered *(ebp+8) %eax) -15205 (write-buffered *(ebp+8) ") ") -15206 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 -15207 } -15208 # otherwise abort -15209 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 -15210 $translate-mu-index-stmt-with-array-on-stack:emit-output: -15211 # outputs[0] "/r32" -15212 8b/-> *(ebp+0xc) 0/r32/eax -15213 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax -15214 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15215 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -15216 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -15217 (write-int32-hex-buffered *(ebp+8) *eax) -15218 (write-buffered *(ebp+8) "/r32\n") -15219 $translate-mu-index-stmt-with-array-on-stack:end: -15220 # . restore registers -15221 5b/pop-to-ebx -15222 5a/pop-to-edx -15223 59/pop-to-ecx -15224 58/pop-to-eax -15225 # . epilogue -15226 89/<- %esp 5/r32/ebp -15227 5d/pop-to-ebp -15228 c3/return -15229 -15230 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15231 # . prologue -15232 55/push-ebp -15233 89/<- %ebp 4/r32/esp -15234 # . save registers -15235 50/push-eax -15236 51/push-ecx -15237 52/push-edx -15238 53/push-ebx -15239 # -15240 (emit-indent *(ebp+8) *Curr-block-depth) -15241 (write-buffered *(ebp+8) "69/multiply") -15242 # ecx = stmt -15243 8b/-> *(ebp+0xc) 1/r32/ecx -15244 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] -15245 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15246 89/<- %ebx 0/r32/eax -15247 $translate-mu-compute-index-stmt:emit-index: -15248 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax -15249 (emit-subx-var-as-rm32 *(ebp+8) %eax) -15250 (write-buffered *(ebp+8) Space) -15251 $translate-mu-compute-index-stmt:emit-elem-size: -15252 # var base/ebx: (addr var) -15253 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax -15254 89/<- %ebx 0/r32/eax -15255 # print array-element-size(base) -15256 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -15257 (write-int32-hex-buffered *(ebp+8) %eax) -15258 (write-buffered *(ebp+8) "/imm32 ") -15259 $translate-mu-compute-index-stmt:emit-output: -15260 # outputs[0] "/r32" -15261 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -15262 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15263 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -15264 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -15265 (write-int32-hex-buffered *(ebp+8) *eax) -15266 (write-buffered *(ebp+8) "/r32\n") -15267 $translate-mu-compute-index-stmt:end: -15268 # . restore registers -15269 5b/pop-to-ebx -15270 5a/pop-to-edx -15271 59/pop-to-ecx -15272 58/pop-to-eax -15273 # . epilogue -15274 89/<- %esp 5/r32/ebp -15275 5d/pop-to-ebp -15276 c3/return -15277 -15278 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) -15279 # . prologue -15280 55/push-ebp -15281 89/<- %ebp 4/r32/esp -15282 # . save registers -15283 50/push-eax -15284 51/push-ecx -15285 52/push-edx -15286 # -15287 (emit-indent *(ebp+8) *Curr-block-depth) -15288 (write-buffered *(ebp+8) "8d/copy-address ") -15289 # ecx = stmt -15290 8b/-> *(ebp+0xc) 1/r32/ecx -15291 # var offset/edx: int = get offset of stmt -15292 (mu-get-offset %ecx) # => eax -15293 89/<- %edx 0/r32/eax -15294 # var base/eax: (addr var) = stmt->inouts->value -15295 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15296 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15297 # if base is in a register -15298 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -15299 { -15300 0f 84/jump-if-= break/disp32 -15301 $translate-mu-get-stmt:emit-register-input: -15302 # emit "*(" base->register " + " offset ") " -15303 (write-buffered *(ebp+8) "*(") -15304 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -15305 (write-buffered *(ebp+8) %eax) -15306 (write-buffered *(ebp+8) " + ") -15307 (write-int32-hex-buffered *(ebp+8) %edx) -15308 (write-buffered *(ebp+8) ") ") -15309 e9/jump $translate-mu-get-stmt:emit-output/disp32 -15310 } -15311 # otherwise base is on the stack -15312 { -15313 $translate-mu-get-stmt:emit-stack-input: -15314 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " -15315 (write-buffered *(ebp+8) "*(ebp+") -15316 03/add *(eax+0x14) 2/r32/edx # Var-offset -15317 (write-int32-hex-buffered *(ebp+8) %edx) +15001 53/push-ebx +15002 # ebx = base +15003 8b/-> *(ebp+0xc) 3/r32/ebx +15004 (emit-indent *(ebp+8) *Curr-block-depth) +15005 (write-buffered *(ebp+8) "8b/-> *") +15006 # if base is an (addr array ...) in a register +15007 { +15008 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register +15009 74/jump-if-= break/disp8 +15010 $emit-save-size-to:emit-base-from-register: +15011 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +15012 (write-buffered *(ebp+8) %eax) +15013 eb/jump $emit-save-size-to:emit-output/disp8 +15014 } +15015 # otherwise if base is an (array ...) on the stack +15016 { +15017 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset +15018 74/jump-if-= break/disp8 +15019 $emit-save-size-to:emit-base-from-stack: +15020 (write-buffered *(ebp+8) "(ebp+") +15021 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14)) # Var-offset +15022 (write-buffered *(ebp+8) ")") +15023 } +15024 $emit-save-size-to:emit-output: +15025 (write-buffered *(ebp+8) " ") +15026 (get Mu-registers *(ebp+0x10) 0xc "Mu-registers") # => eax +15027 (write-int32-hex-buffered *(ebp+8) *eax) +15028 (write-buffered *(ebp+8) "/r32\n") +15029 $emit-save-size-to:end: +15030 # . restore registers +15031 5b/pop-to-ebx +15032 58/pop-to-eax +15033 # . epilogue +15034 89/<- %esp 5/r32/ebp +15035 5d/pop-to-ebp +15036 c3/return +15037 +15038 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int +15039 # . prologue +15040 55/push-ebp +15041 89/<- %ebp 4/r32/esp +15042 # . save registers +15043 50/push-eax +15044 # +15045 (emit-indent *(ebp+8) *Curr-block-depth) +15046 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") +15047 (write-buffered *(ebp+8) *(ebp+0xc)) +15048 (write-buffered *(ebp+8) Space) +15049 (num-shift-rights *(ebp+0x10)) # => eax +15050 (write-int32-hex-buffered *(ebp+8) %eax) +15051 (write-buffered *(ebp+8) "/imm8\n") +15052 $emit-divide-by-shift-right:end: +15053 # . restore registers +15054 58/pop-to-eax +15055 # . epilogue +15056 89/<- %esp 5/r32/ebp +15057 5d/pop-to-ebp +15058 c3/return +15059 +15060 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15061 # . prologue +15062 55/push-ebp +15063 89/<- %ebp 4/r32/esp +15064 # . save registers +15065 51/push-ecx +15066 # ecx = stmt +15067 8b/-> *(ebp+0xc) 1/r32/ecx +15068 # var base/ecx: (addr var) = stmt->inouts[0] +15069 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15070 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15071 89/<- %ecx 0/r32/eax +15072 # if (var->register) do one thing +15073 { +15074 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +15075 74/jump-if-= break/disp8 +15076 # TODO: ensure there's no dereference +15077 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +15078 eb/jump $translate-mu-index-stmt:end/disp8 +15079 } +15080 # if (var->offset) do a different thing +15081 { +15082 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset +15083 74/jump-if-= break/disp8 +15084 # TODO: ensure there's no dereference +15085 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +15086 eb/jump $translate-mu-index-stmt:end/disp8 +15087 } +15088 $translate-mu-index-stmt:end: +15089 # . restore registers +15090 59/pop-to-ecx +15091 # . epilogue +15092 89/<- %esp 5/r32/ebp +15093 5d/pop-to-ebp +15094 c3/return +15095 +15096 $translate-mu-index-stmt-with-array:error1: +15097 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") +15098 (flush *(ebp+0x10)) +15099 (stop *(ebp+0x14) 1) +15100 # never gets here +15101 +15102 $translate-mu-index-stmt-with-array:error2: +15103 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") +15104 (flush *(ebp+0x10)) +15105 (stop *(ebp+0x14) 1) +15106 # never gets here +15107 +15108 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15109 # . prologue +15110 55/push-ebp +15111 89/<- %ebp 4/r32/esp +15112 # . save registers +15113 50/push-eax +15114 51/push-ecx +15115 52/push-edx +15116 53/push-ebx +15117 # +15118 (emit-indent *(ebp+8) *Curr-block-depth) +15119 (write-buffered *(ebp+8) "8d/copy-address *(") +15120 # TODO: ensure inouts[0] is in a register and not dereferenced +15121 $translate-mu-index-stmt-with-array-in-register:emit-base: +15122 # ecx = stmt +15123 8b/-> *(ebp+0xc) 1/r32/ecx +15124 # var base/ebx: (addr var) = inouts[0] +15125 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15126 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15127 89/<- %ebx 0/r32/eax +15128 # print base->register " + " +15129 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +15130 (write-buffered *(ebp+8) %eax) +15131 (write-buffered *(ebp+8) " + ") +15132 # var index/edx: (addr var) = inouts[1] +15133 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15134 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +15135 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15136 89/<- %edx 0/r32/eax +15137 # if index->register +15138 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register +15139 { +15140 0f 84/jump-if-= break/disp32 +15141 $translate-mu-index-stmt-with-array-in-register:emit-register-index: +15142 # if index is an int +15143 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15144 (is-simple-mu-type? %eax 1) # int => eax +15145 3d/compare-eax-and 0/imm32/false +15146 { +15147 0f 84/jump-if-= break/disp32 +15148 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: +15149 # print index->register "<<" log2(array-element-size(base)) " + 4) " +15150 # . index->register "<<" +15151 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +15152 (write-buffered *(ebp+8) %eax) +15153 (write-buffered *(ebp+8) "<<") +15154 # . log2(array-element-size(base->type)) +15155 # TODO: ensure size is a power of 2 +15156 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +15157 (num-shift-rights %eax) # => eax +15158 (write-int32-hex-buffered *(ebp+8) %eax) +15159 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 +15160 } +15161 # if index->type is any other atom, abort +15162 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15163 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +15164 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 +15165 # if index has type (offset ...) +15166 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15167 (is-simple-mu-type? %eax 7) # => eax +15168 3d/compare-eax-and 0/imm32/false +15169 { +15170 0f 84/jump-if-= break/disp32 +15171 # print index->register +15172 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: +15173 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +15174 (write-buffered *(ebp+8) %eax) +15175 } +15176 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: +15177 (write-buffered *(ebp+8) " + 4) ") +15178 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 +15179 } +15180 # otherwise if index is a literal +15181 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15182 (is-simple-mu-type? %eax 0) # => eax +15183 3d/compare-eax-and 0/imm32/false +15184 { +15185 0f 84/jump-if-= break/disp32 +15186 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: +15187 # var index-value/edx: int = parse-hex-int(index->name) +15188 (lookup *edx *(edx+4)) # Var-name Var-name => eax +15189 (parse-hex-int %eax) # => eax +15190 89/<- %edx 0/r32/eax +15191 # offset = idx-value * array-element-size(base->type) +15192 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +15193 f7 4/subop/multiply-into-eax %edx # clobbers edx +15194 # offset += 4 for array size +15195 05/add-to-eax 4/imm32 +15196 # TODO: check edx for overflow +15197 # print offset +15198 (write-int32-hex-buffered *(ebp+8) %eax) +15199 (write-buffered *(ebp+8) ") ") +15200 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 +15201 } +15202 # otherwise abort +15203 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 +15204 $translate-mu-index-stmt-with-array-in-register:emit-output: +15205 # outputs[0] "/r32" +15206 8b/-> *(ebp+0xc) 1/r32/ecx +15207 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +15208 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15209 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +15210 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +15211 (write-int32-hex-buffered *(ebp+8) *eax) +15212 (write-buffered *(ebp+8) "/r32\n") +15213 $translate-mu-index-stmt-with-array-in-register:end: +15214 # . restore registers +15215 5b/pop-to-ebx +15216 5a/pop-to-edx +15217 59/pop-to-ecx +15218 58/pop-to-eax +15219 # . epilogue +15220 89/<- %esp 5/r32/ebp +15221 5d/pop-to-ebp +15222 c3/return +15223 +15224 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15225 # . prologue +15226 55/push-ebp +15227 89/<- %ebp 4/r32/esp +15228 # . save registers +15229 50/push-eax +15230 51/push-ecx +15231 52/push-edx +15232 53/push-ebx +15233 # +15234 (emit-indent *(ebp+8) *Curr-block-depth) +15235 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") +15236 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) +15237 8b/-> *(ebp+0xc) 0/r32/eax +15238 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15239 89/<- %edx 0/r32/eax +15240 # var base/ecx: (addr var) = lookup(curr->value) +15241 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15242 89/<- %ecx 0/r32/eax +15243 # var curr2/eax: (addr stmt-var) = lookup(curr->next) +15244 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax +15245 # var index/edx: (handle var) = curr2->value +15246 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15247 89/<- %edx 0/r32/eax +15248 # if index->register +15249 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register +15250 { +15251 0f 84/jump-if-= break/disp32 +15252 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: +15253 # if index is an int +15254 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15255 (is-simple-mu-type? %eax 1) # int => eax +15256 3d/compare-eax-and 0/imm32/false +15257 { +15258 0f 84/jump-if-= break/disp32 +15259 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: +15260 # print index->register "<<" log2(array-element-size(base)) " + " base->offset+4 +15261 # . inouts[1]->register "<<" +15262 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +15263 (write-buffered *(ebp+8) %eax) +15264 (write-buffered *(ebp+8) "<<") +15265 # . log2(array-element-size(base)) +15266 # TODO: ensure size is a power of 2 +15267 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +15268 (num-shift-rights %eax) # => eax +15269 (write-int32-hex-buffered *(ebp+8) %eax) +15270 # +15271 (write-buffered *(ebp+8) " + ") +15272 # +15273 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset +15274 05/add-to-eax 4/imm32 # for array length +15275 (write-int32-hex-buffered *(ebp+8) %eax) +15276 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 +15277 } +15278 # if index->type is any other atom, abort +15279 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15280 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +15281 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 +15282 # if index has type (offset ...) +15283 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15284 (is-simple-mu-type? %eax 7) # => eax +15285 3d/compare-eax-and 0/imm32/false +15286 { +15287 0f 84/jump-if-= break/disp32 +15288 # print index->register +15289 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: +15290 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +15291 (write-buffered *(ebp+8) %eax) +15292 } +15293 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: +15294 (write-buffered *(ebp+8) ") ") +15295 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 +15296 } +15297 # otherwise if index is a literal +15298 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15299 (is-simple-mu-type? %eax 0) # => eax +15300 3d/compare-eax-and 0/imm32/false +15301 { +15302 0f 84/jump-if-= break/disp32 +15303 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: +15304 # var idx-value/edx: int = parse-hex-int(index->name) +15305 (lookup *edx *(edx+4)) # Var-name Var-name => eax +15306 (parse-hex-int %eax) # Var-name => eax +15307 89/<- %edx 0/r32/eax +15308 # offset = idx-value * array-element-size(base) +15309 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +15310 f7 4/subop/multiply-into-eax %edx # clobbers edx +15311 # offset += base->offset +15312 03/add *(ecx+0x14) 0/r32/eax # Var-offset +15313 # offset += 4 for array size +15314 05/add-to-eax 4/imm32 +15315 # TODO: check edx for overflow +15316 # print offset +15317 (write-int32-hex-buffered *(ebp+8) %eax) 15318 (write-buffered *(ebp+8) ") ") -15319 eb/jump $translate-mu-get-stmt:emit-output/disp8 +15319 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 15320 } -15321 $translate-mu-get-stmt:emit-output: -15322 # var output/eax: (addr var) = stmt->outputs->value -15323 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -15324 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15325 # emit offset->register "/r32" -15326 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -15327 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -15328 (write-int32-hex-buffered *(ebp+8) *eax) -15329 (write-buffered *(ebp+8) "/r32\n") -15330 $translate-mu-get-stmt:end: -15331 # . restore registers -15332 5a/pop-to-edx -15333 59/pop-to-ecx -15334 58/pop-to-eax -15335 # . epilogue -15336 89/<- %esp 5/r32/ebp -15337 5d/pop-to-ebp -15338 c3/return -15339 -15340 translate-mu-allocate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15341 # . prologue -15342 55/push-ebp -15343 89/<- %ebp 4/r32/esp -15344 # . save registers -15345 50/push-eax -15346 56/push-esi -15347 57/push-edi -15348 # esi = stmt -15349 8b/-> *(ebp+0xc) 6/r32/esi -15350 # var target/edi: (addr stmt-var) = stmt->inouts[0] -15351 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15352 89/<- %edi 0/r32/eax -15353 # -15354 (emit-indent *(ebp+8) *Curr-block-depth) -15355 (write-buffered *(ebp+8) "(allocate Heap ") -15356 (addr-handle-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -15357 (write-int32-hex-buffered *(ebp+8) %eax) -15358 (emit-subx-call-operand *(ebp+8) %edi) -15359 (write-buffered *(ebp+8) ")\n") -15360 $translate-mu-allocate-stmt:end: -15361 # . restore registers -15362 5f/pop-to-edi -15363 5e/pop-to-esi -15364 58/pop-to-eax -15365 # . epilogue -15366 89/<- %esp 5/r32/ebp -15367 5d/pop-to-ebp -15368 c3/return -15369 -15370 addr-handle-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -15371 # . prologue -15372 55/push-ebp -15373 89/<- %ebp 4/r32/esp -15374 # var t/eax: (addr type-tree) = s->value->type -15375 8b/-> *(ebp+8) 0/r32/eax -15376 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15377 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -15378 # TODO: check eax != 0 -15379 # TODO: check !t->is-atom? -15380 # TODO: check t->left == addr -15381 # t = t->right -15382 $addr-handle-payload-size:skip-addr: -15383 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15384 # TODO: check eax != 0 -15385 # TODO: check !t->is-atom? -15386 # TODO: check t->left == handle -15387 # t = t->right -15388 $addr-handle-payload-size:skip-handle: -15389 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15390 # TODO: check eax != 0 -15391 # if !t->is-atom? t = t->left -15392 81 7/subop/compare *eax 0/imm32/false -15393 { -15394 75/jump-if-!= break/disp8 -15395 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15396 } -15397 # TODO: check t->is-atom? -15398 # return size(t->value) -15399 (size-of-type-id *(eax+4)) # Type-tree-value => eax -15400 $addr-handle-payload-size:end: -15401 # . epilogue -15402 89/<- %esp 5/r32/ebp -15403 5d/pop-to-ebp -15404 c3/return -15405 -15406 addr-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -15407 # . prologue -15408 55/push-ebp -15409 89/<- %ebp 4/r32/esp -15410 # var t/eax: (addr type-tree) = s->value->type -15411 8b/-> *(ebp+8) 0/r32/eax -15412 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15413 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -15414 # TODO: check eax != 0 -15415 # TODO: check !t->is-atom? -15416 # TODO: check t->left == addr -15417 # t = t->right -15418 $addr-payload-size:skip-addr: -15419 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15420 # TODO: check eax != 0 -15421 # if !t->is-atom? t = t->left -15422 81 7/subop/compare *eax 0/imm32/false -15423 { -15424 75/jump-if-!= break/disp8 -15425 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15426 } -15427 # TODO: check t->is-atom? -15428 # return size(t->value) -15429 (size-of-type-id *(eax+4)) # Type-tree-value => eax -15430 $addr-payload-size:end: -15431 # . epilogue -15432 89/<- %esp 5/r32/ebp -15433 5d/pop-to-ebp -15434 c3/return -15435 -15436 translate-mu-populate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15437 # . prologue -15438 55/push-ebp -15439 89/<- %ebp 4/r32/esp -15440 # . save registers -15441 50/push-eax -15442 51/push-ecx -15443 56/push-esi -15444 57/push-edi -15445 # esi = stmt -15446 8b/-> *(ebp+0xc) 6/r32/esi -15447 # var target/edi: (addr stmt-var) = stmt->inouts[0] -15448 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15449 89/<- %edi 0/r32/eax -15450 # var len/ecx: (addr stmt-var) = stmt->inouts[1] -15451 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -15452 89/<- %ecx 0/r32/eax -15453 # -15454 (emit-indent *(ebp+8) *Curr-block-depth) -15455 (write-buffered *(ebp+8) "(allocate-array2 Heap ") -15456 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -15457 (write-int32-hex-buffered *(ebp+8) %eax) -15458 (emit-subx-call-operand *(ebp+8) %ecx) -15459 (emit-subx-call-operand *(ebp+8) %edi) -15460 (write-buffered *(ebp+8) ")\n") -15461 $translate-mu-populate-stmt:end: -15462 # . restore registers -15463 5f/pop-to-edi -15464 5e/pop-to-esi -15465 59/pop-to-ecx -15466 58/pop-to-eax -15467 # . epilogue -15468 89/<- %esp 5/r32/ebp -15469 5d/pop-to-ebp -15470 c3/return -15471 -15472 translate-mu-populate-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15473 # . prologue -15474 55/push-ebp -15475 89/<- %ebp 4/r32/esp -15476 # . save registers -15477 50/push-eax -15478 51/push-ecx -15479 56/push-esi -15480 57/push-edi -15481 # esi = stmt -15482 8b/-> *(ebp+0xc) 6/r32/esi -15483 # var target/edi: (addr stmt-var) = stmt->inouts[0] -15484 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15485 89/<- %edi 0/r32/eax -15486 # var len/ecx: (addr stmt-var) = stmt->inouts[1] -15487 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -15488 89/<- %ecx 0/r32/eax -15489 # -15490 (emit-indent *(ebp+8) *Curr-block-depth) -15491 (write-buffered *(ebp+8) "(new-stream Heap ") -15492 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -15493 (write-int32-hex-buffered *(ebp+8) %eax) -15494 (emit-subx-call-operand *(ebp+8) %ecx) -15495 (emit-subx-call-operand *(ebp+8) %edi) -15496 (write-buffered *(ebp+8) ")\n") -15497 $translate-mu-populate-stream-stmt:end: -15498 # . restore registers -15499 5f/pop-to-edi -15500 5e/pop-to-esi -15501 59/pop-to-ecx -15502 58/pop-to-eax -15503 # . epilogue -15504 89/<- %esp 5/r32/ebp -15505 5d/pop-to-ebp -15506 c3/return -15507 -15508 translate-mu-read-from-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15509 # . prologue -15510 55/push-ebp -15511 89/<- %ebp 4/r32/esp -15512 # . save registers -15513 50/push-eax -15514 51/push-ecx -15515 56/push-esi -15516 57/push-edi -15517 # esi = stmt -15518 8b/-> *(ebp+0xc) 6/r32/esi -15519 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] -15520 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15521 89/<- %ecx 0/r32/eax -15522 # var target/edi: (addr stmt-var) = stmt->inouts[1] -15523 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -15524 89/<- %edi 0/r32/eax -15525 # -15526 (emit-indent *(ebp+8) *Curr-block-depth) -15527 (write-buffered *(ebp+8) "(read-from-stream") -15528 (emit-subx-call-operand *(ebp+8) %ecx) -15529 (emit-subx-call-operand *(ebp+8) %edi) -15530 (write-buffered *(ebp+8) Space) -15531 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -15532 (write-int32-hex-buffered *(ebp+8) %eax) -15533 (write-buffered *(ebp+8) ")\n") -15534 $translate-mu-read-from-stream-stmt:end: -15535 # . restore registers -15536 5f/pop-to-edi -15537 5e/pop-to-esi -15538 59/pop-to-ecx -15539 58/pop-to-eax -15540 # . epilogue -15541 89/<- %esp 5/r32/ebp -15542 5d/pop-to-ebp -15543 c3/return -15544 -15545 translate-mu-write-to-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -15546 # . prologue -15547 55/push-ebp -15548 89/<- %ebp 4/r32/esp -15549 # . save registers -15550 50/push-eax -15551 51/push-ecx -15552 56/push-esi -15553 57/push-edi -15554 # esi = stmt -15555 8b/-> *(ebp+0xc) 6/r32/esi -15556 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] -15557 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15558 89/<- %ecx 0/r32/eax -15559 # var target/edi: (addr stmt-var) = stmt->inouts[1] -15560 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -15561 89/<- %edi 0/r32/eax -15562 # -15563 (emit-indent *(ebp+8) *Curr-block-depth) -15564 (write-buffered *(ebp+8) "(write-to-stream") -15565 (emit-subx-call-operand *(ebp+8) %ecx) -15566 (flush *(ebp+8)) -15567 (emit-subx-call-operand *(ebp+8) %edi) -15568 (flush *(ebp+8)) -15569 (write-buffered *(ebp+8) Space) -15570 (flush *(ebp+8)) -15571 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -15572 (write-int32-hex-buffered *(ebp+8) %eax) +15321 # otherwise abort +15322 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 +15323 $translate-mu-index-stmt-with-array-on-stack:emit-output: +15324 # outputs[0] "/r32" +15325 8b/-> *(ebp+0xc) 0/r32/eax +15326 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax +15327 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15328 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +15329 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +15330 (write-int32-hex-buffered *(ebp+8) *eax) +15331 (write-buffered *(ebp+8) "/r32\n") +15332 $translate-mu-index-stmt-with-array-on-stack:end: +15333 # . restore registers +15334 5b/pop-to-ebx +15335 5a/pop-to-edx +15336 59/pop-to-ecx +15337 58/pop-to-eax +15338 # . epilogue +15339 89/<- %esp 5/r32/ebp +15340 5d/pop-to-ebp +15341 c3/return +15342 +15343 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15344 # . prologue +15345 55/push-ebp +15346 89/<- %ebp 4/r32/esp +15347 # . save registers +15348 50/push-eax +15349 51/push-ecx +15350 52/push-edx +15351 53/push-ebx +15352 # +15353 (emit-indent *(ebp+8) *Curr-block-depth) +15354 (write-buffered *(ebp+8) "69/multiply") +15355 # ecx = stmt +15356 8b/-> *(ebp+0xc) 1/r32/ecx +15357 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] +15358 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15359 89/<- %ebx 0/r32/eax +15360 $translate-mu-compute-index-stmt:emit-index: +15361 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax +15362 (emit-subx-var-as-rm32 *(ebp+8) %eax) +15363 (write-buffered *(ebp+8) Space) +15364 $translate-mu-compute-index-stmt:emit-elem-size: +15365 # var base/ebx: (addr var) +15366 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax +15367 89/<- %ebx 0/r32/eax +15368 # print array-element-size(base) +15369 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +15370 (write-int32-hex-buffered *(ebp+8) %eax) +15371 (write-buffered *(ebp+8) "/imm32 ") +15372 $translate-mu-compute-index-stmt:emit-output: +15373 # outputs[0] "/r32" +15374 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +15375 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15376 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +15377 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +15378 (write-int32-hex-buffered *(ebp+8) *eax) +15379 (write-buffered *(ebp+8) "/r32\n") +15380 $translate-mu-compute-index-stmt:end: +15381 # . restore registers +15382 5b/pop-to-ebx +15383 5a/pop-to-edx +15384 59/pop-to-ecx +15385 58/pop-to-eax +15386 # . epilogue +15387 89/<- %esp 5/r32/ebp +15388 5d/pop-to-ebp +15389 c3/return +15390 +15391 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) +15392 # . prologue +15393 55/push-ebp +15394 89/<- %ebp 4/r32/esp +15395 # . save registers +15396 50/push-eax +15397 51/push-ecx +15398 52/push-edx +15399 # +15400 (emit-indent *(ebp+8) *Curr-block-depth) +15401 (write-buffered *(ebp+8) "8d/copy-address ") +15402 # ecx = stmt +15403 8b/-> *(ebp+0xc) 1/r32/ecx +15404 # var offset/edx: int = get offset of stmt +15405 (mu-get-offset %ecx) # => eax +15406 89/<- %edx 0/r32/eax +15407 # var base/eax: (addr var) = stmt->inouts->value +15408 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15409 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15410 # if base is in a register +15411 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +15412 { +15413 0f 84/jump-if-= break/disp32 +15414 $translate-mu-get-stmt:emit-register-input: +15415 # emit "*(" base->register " + " offset ") " +15416 (write-buffered *(ebp+8) "*(") +15417 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +15418 (write-buffered *(ebp+8) %eax) +15419 (write-buffered *(ebp+8) " + ") +15420 (write-int32-hex-buffered *(ebp+8) %edx) +15421 (write-buffered *(ebp+8) ") ") +15422 e9/jump $translate-mu-get-stmt:emit-output/disp32 +15423 } +15424 # otherwise base is on the stack +15425 { +15426 $translate-mu-get-stmt:emit-stack-input: +15427 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " +15428 (write-buffered *(ebp+8) "*(ebp+") +15429 03/add *(eax+0x14) 2/r32/edx # Var-offset +15430 (write-int32-hex-buffered *(ebp+8) %edx) +15431 (write-buffered *(ebp+8) ") ") +15432 eb/jump $translate-mu-get-stmt:emit-output/disp8 +15433 } +15434 $translate-mu-get-stmt:emit-output: +15435 # var output/eax: (addr var) = stmt->outputs->value +15436 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +15437 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15438 # emit offset->register "/r32" +15439 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +15440 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +15441 (write-int32-hex-buffered *(ebp+8) *eax) +15442 (write-buffered *(ebp+8) "/r32\n") +15443 $translate-mu-get-stmt:end: +15444 # . restore registers +15445 5a/pop-to-edx +15446 59/pop-to-ecx +15447 58/pop-to-eax +15448 # . epilogue +15449 89/<- %esp 5/r32/ebp +15450 5d/pop-to-ebp +15451 c3/return +15452 +15453 translate-mu-allocate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15454 # . prologue +15455 55/push-ebp +15456 89/<- %ebp 4/r32/esp +15457 # . save registers +15458 50/push-eax +15459 56/push-esi +15460 57/push-edi +15461 # esi = stmt +15462 8b/-> *(ebp+0xc) 6/r32/esi +15463 # var target/edi: (addr stmt-var) = stmt->inouts[0] +15464 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15465 89/<- %edi 0/r32/eax +15466 # +15467 (emit-indent *(ebp+8) *Curr-block-depth) +15468 (write-buffered *(ebp+8) "(allocate Heap ") +15469 (addr-handle-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +15470 (write-int32-hex-buffered *(ebp+8) %eax) +15471 (emit-subx-call-operand *(ebp+8) %edi) +15472 (write-buffered *(ebp+8) ")\n") +15473 $translate-mu-allocate-stmt:end: +15474 # . restore registers +15475 5f/pop-to-edi +15476 5e/pop-to-esi +15477 58/pop-to-eax +15478 # . epilogue +15479 89/<- %esp 5/r32/ebp +15480 5d/pop-to-ebp +15481 c3/return +15482 +15483 addr-handle-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +15484 # . prologue +15485 55/push-ebp +15486 89/<- %ebp 4/r32/esp +15487 # var t/eax: (addr type-tree) = s->value->type +15488 8b/-> *(ebp+8) 0/r32/eax +15489 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15490 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +15491 # TODO: check eax != 0 +15492 # TODO: check !t->is-atom? +15493 # TODO: check t->left == addr +15494 # t = t->right +15495 $addr-handle-payload-size:skip-addr: +15496 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15497 # TODO: check eax != 0 +15498 # TODO: check !t->is-atom? +15499 # TODO: check t->left == handle +15500 # t = t->right +15501 $addr-handle-payload-size:skip-handle: +15502 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15503 # TODO: check eax != 0 +15504 # if !t->is-atom? t = t->left +15505 81 7/subop/compare *eax 0/imm32/false +15506 { +15507 75/jump-if-!= break/disp8 +15508 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15509 } +15510 # TODO: check t->is-atom? +15511 # return size(t->value) +15512 (size-of-type-id *(eax+4)) # Type-tree-value => eax +15513 $addr-handle-payload-size:end: +15514 # . epilogue +15515 89/<- %esp 5/r32/ebp +15516 5d/pop-to-ebp +15517 c3/return +15518 +15519 addr-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +15520 # . prologue +15521 55/push-ebp +15522 89/<- %ebp 4/r32/esp +15523 # var t/eax: (addr type-tree) = s->value->type +15524 8b/-> *(ebp+8) 0/r32/eax +15525 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15526 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +15527 # TODO: check eax != 0 +15528 # TODO: check !t->is-atom? +15529 # TODO: check t->left == addr +15530 # t = t->right +15531 $addr-payload-size:skip-addr: +15532 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15533 # TODO: check eax != 0 +15534 # if !t->is-atom? t = t->left +15535 81 7/subop/compare *eax 0/imm32/false +15536 { +15537 75/jump-if-!= break/disp8 +15538 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15539 } +15540 # TODO: check t->is-atom? +15541 # return size(t->value) +15542 (size-of-type-id *(eax+4)) # Type-tree-value => eax +15543 $addr-payload-size:end: +15544 # . epilogue +15545 89/<- %esp 5/r32/ebp +15546 5d/pop-to-ebp +15547 c3/return +15548 +15549 translate-mu-populate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15550 # . prologue +15551 55/push-ebp +15552 89/<- %ebp 4/r32/esp +15553 # . save registers +15554 50/push-eax +15555 51/push-ecx +15556 56/push-esi +15557 57/push-edi +15558 # esi = stmt +15559 8b/-> *(ebp+0xc) 6/r32/esi +15560 # var target/edi: (addr stmt-var) = stmt->inouts[0] +15561 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15562 89/<- %edi 0/r32/eax +15563 # var len/ecx: (addr stmt-var) = stmt->inouts[1] +15564 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +15565 89/<- %ecx 0/r32/eax +15566 # +15567 (emit-indent *(ebp+8) *Curr-block-depth) +15568 (write-buffered *(ebp+8) "(allocate-array2 Heap ") +15569 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +15570 (write-int32-hex-buffered *(ebp+8) %eax) +15571 (emit-subx-call-operand *(ebp+8) %ecx) +15572 (emit-subx-call-operand *(ebp+8) %edi) 15573 (write-buffered *(ebp+8) ")\n") -15574 $translate-mu-write-to-stream-stmt:end: +15574 $translate-mu-populate-stmt:end: 15575 # . restore registers 15576 5f/pop-to-edi 15577 5e/pop-to-esi @@ -14941,6754 +14931,6910 @@ if ('onhashchange' in window) { 15582 5d/pop-to-ebp 15583 c3/return 15584 -15585 addr-handle-array-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +15585 translate-mu-populate-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) 15586 # . prologue 15587 55/push-ebp 15588 89/<- %ebp 4/r32/esp -15589 # var t/eax: (addr type-tree) = s->value->type -15590 8b/-> *(ebp+8) 0/r32/eax -15591 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15592 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -15593 # TODO: check eax != 0 -15594 # TODO: check !t->is-atom? -15595 # TODO: check t->left == addr -15596 # t = t->right -15597 $addr-handle-array-payload-size:skip-addr: -15598 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15599 # TODO: check eax != 0 -15600 # TODO: check !t->is-atom? -15601 # TODO: check t->left == handle -15602 # t = t->right -15603 $addr-handle-array-payload-size:skip-handle: -15604 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15605 # TODO: check eax != 0 -15606 # TODO: check !t->is-atom? -15607 # TODO: check t->left == array -15608 # t = t->right -15609 $addr-handle-array-payload-size:skip-array: -15610 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -15611 # TODO: check eax != 0 -15612 # if !t->is-atom? t = t->left -15613 81 7/subop/compare *eax 0/imm32/false -15614 { -15615 75/jump-if-!= break/disp8 -15616 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15617 } -15618 $addr-handle-array-payload-size:compute-size: -15619 # TODO: check t->is-atom? -15620 # return size(t->value) -15621 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax -15622 $addr-handle-array-payload-size:end: -15623 # . epilogue -15624 89/<- %esp 5/r32/ebp -15625 5d/pop-to-ebp -15626 c3/return -15627 -15628 power-of-2?: # n: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: boolean -15629 # precondition: n is positive -15630 # . prologue -15631 55/push-ebp -15632 89/<- %ebp 4/r32/esp -15633 # eax = n -15634 8b/-> *(ebp+8) 0/r32/eax -15635 # if (n < 0) abort -15636 3d/compare-eax-with 0/imm32 -15637 0f 8c/jump-if-< $power-of-2?:abort/disp32 -15638 # var tmp/eax: int = n-1 -15639 48/decrement-eax -15640 # var tmp2/eax: int = n & tmp -15641 23/and-> *(ebp+8) 0/r32/eax -15642 # return (tmp2 == 0) -15643 3d/compare-eax-and 0/imm32 -15644 0f 94/set-byte-if-= %al -15645 81 4/subop/and %eax 0xff/imm32 -15646 $power-of-2?:end: -15647 # . epilogue -15648 89/<- %esp 5/r32/ebp -15649 5d/pop-to-ebp -15650 c3/return -15651 -15652 $power-of-2?:abort: -15653 (write-buffered *(ebp+0xc) "power-of-2?: negative number\n") -15654 (flush *(ebp+0xc)) -15655 (stop *(ebp+0x10) 1) -15656 # never gets here +15589 # . save registers +15590 50/push-eax +15591 51/push-ecx +15592 56/push-esi +15593 57/push-edi +15594 # esi = stmt +15595 8b/-> *(ebp+0xc) 6/r32/esi +15596 # var target/edi: (addr stmt-var) = stmt->inouts[0] +15597 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15598 89/<- %edi 0/r32/eax +15599 # var len/ecx: (addr stmt-var) = stmt->inouts[1] +15600 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +15601 89/<- %ecx 0/r32/eax +15602 # +15603 (emit-indent *(ebp+8) *Curr-block-depth) +15604 (write-buffered *(ebp+8) "(new-stream Heap ") +15605 (addr-handle-stream-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +15606 (write-int32-hex-buffered *(ebp+8) %eax) +15607 (emit-subx-call-operand *(ebp+8) %ecx) +15608 (emit-subx-call-operand *(ebp+8) %edi) +15609 (write-buffered *(ebp+8) ")\n") +15610 $translate-mu-populate-stream-stmt:end: +15611 # . restore registers +15612 5f/pop-to-edi +15613 5e/pop-to-esi +15614 59/pop-to-ecx +15615 58/pop-to-eax +15616 # . epilogue +15617 89/<- %esp 5/r32/ebp +15618 5d/pop-to-ebp +15619 c3/return +15620 +15621 translate-mu-read-from-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15622 # . prologue +15623 55/push-ebp +15624 89/<- %ebp 4/r32/esp +15625 # . save registers +15626 50/push-eax +15627 51/push-ecx +15628 56/push-esi +15629 57/push-edi +15630 # esi = stmt +15631 8b/-> *(ebp+0xc) 6/r32/esi +15632 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] +15633 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15634 89/<- %ecx 0/r32/eax +15635 # var target/edi: (addr stmt-var) = stmt->inouts[1] +15636 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +15637 89/<- %edi 0/r32/eax +15638 # +15639 (emit-indent *(ebp+8) *Curr-block-depth) +15640 (write-buffered *(ebp+8) "(read-from-stream") +15641 (emit-subx-call-operand *(ebp+8) %ecx) +15642 (emit-subx-call-operand *(ebp+8) %edi) +15643 (write-buffered *(ebp+8) Space) +15644 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +15645 (write-int32-hex-buffered *(ebp+8) %eax) +15646 (write-buffered *(ebp+8) ")\n") +15647 $translate-mu-read-from-stream-stmt:end: +15648 # . restore registers +15649 5f/pop-to-edi +15650 5e/pop-to-esi +15651 59/pop-to-ecx +15652 58/pop-to-eax +15653 # . epilogue +15654 89/<- %esp 5/r32/ebp +15655 5d/pop-to-ebp +15656 c3/return 15657 -15658 num-shift-rights: # n: int -> result/eax: int -15659 # precondition: n is a positive power of 2 -15660 # . prologue -15661 55/push-ebp -15662 89/<- %ebp 4/r32/esp -15663 # . save registers +15658 translate-mu-write-to-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +15659 # . prologue +15660 55/push-ebp +15661 89/<- %ebp 4/r32/esp +15662 # . save registers +15663 50/push-eax 15664 51/push-ecx -15665 # var curr/ecx: int = n -15666 8b/-> *(ebp+8) 1/r32/ecx -15667 # result = 0 -15668 b8/copy-to-eax 0/imm32 -15669 { -15670 # if (curr <= 1) break -15671 81 7/subop/compare %ecx 1/imm32 -15672 7e/jump-if-<= break/disp8 -15673 40/increment-eax -15674 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 -15675 eb/jump loop/disp8 -15676 } -15677 $num-shift-rights:end: -15678 # . restore registers -15679 59/pop-to-ecx -15680 # . epilogue -15681 89/<- %esp 5/r32/ebp -15682 5d/pop-to-ebp -15683 c3/return -15684 -15685 mu-get-offset: # stmt: (addr stmt) -> result/eax: int -15686 # . prologue -15687 55/push-ebp -15688 89/<- %ebp 4/r32/esp -15689 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next -15690 8b/-> *(ebp+8) 0/r32/eax -15691 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -15692 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -15693 # var output-var/eax: (addr var) = second-inout->value -15694 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -15695 #? (write-buffered Stderr "mu-get-offset: ") -15696 #? (write-int32-hex-buffered Stderr %eax) -15697 #? (write-buffered Stderr " name: ") -15698 #? 50/push-eax -15699 #? (lookup *eax *(eax+4)) # Var-name -15700 #? (write-buffered Stderr %eax) -15701 #? 58/pop-to-eax -15702 #? (write-buffered Stderr Newline) -15703 #? (flush Stderr) -15704 # return output-var->stack-offset -15705 8b/-> *(eax+0x14) 0/r32/eax # Var-offset -15706 #? (write-buffered Stderr "=> ") -15707 #? (write-int32-hex-buffered Stderr %eax) -15708 #? (write-buffered Stderr Newline) -15709 #? (flush Stderr) -15710 $emit-get-offset:end: -15711 # . epilogue -15712 89/<- %esp 5/r32/ebp -15713 5d/pop-to-ebp -15714 c3/return -15715 -15716 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -15717 # . prologue -15718 55/push-ebp -15719 89/<- %ebp 4/r32/esp -15720 # . save registers -15721 50/push-eax -15722 51/push-ecx -15723 56/push-esi -15724 # esi = block -15725 8b/-> *(ebp+0xc) 6/r32/esi -15726 # block->var->block-depth = *Curr-block-depth -15727 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax -15728 8b/-> *Curr-block-depth 1/r32/ecx -15729 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth -15730 # var stmts/eax: (addr list stmt) = lookup(block->statements) -15731 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax -15732 # -15733 { -15734 $emit-subx-block:check-empty: -15735 3d/compare-eax-and 0/imm32 -15736 0f 84/jump-if-= break/disp32 -15737 (emit-indent *(ebp+8) *Curr-block-depth) -15738 (write-buffered *(ebp+8) "{\n") -15739 # var v/ecx: (addr var) = lookup(block->var) -15740 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax -15741 89/<- %ecx 0/r32/eax -15742 # -15743 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -15744 (write-buffered *(ebp+8) %eax) -15745 (write-buffered *(ebp+8) ":loop:\n") -15746 ff 0/subop/increment *Curr-block-depth -15747 (push *(ebp+0x10) *(esi+0xc)) # Block-var -15748 (push *(ebp+0x10) *(esi+0x10)) # Block-var -15749 (push *(ebp+0x10) 0) # false -15750 # emit block->statements -15751 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax -15752 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -15753 (pop *(ebp+0x10)) # => eax -15754 (pop *(ebp+0x10)) # => eax -15755 (pop *(ebp+0x10)) # => eax -15756 ff 1/subop/decrement *Curr-block-depth -15757 (emit-indent *(ebp+8) *Curr-block-depth) -15758 (write-buffered *(ebp+8) "}\n") -15759 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -15760 (write-buffered *(ebp+8) %eax) -15761 (write-buffered *(ebp+8) ":break:\n") -15762 } -15763 $emit-subx-block:end: -15764 # . restore registers -15765 5e/pop-to-esi -15766 59/pop-to-ecx -15767 58/pop-to-eax -15768 # . epilogue -15769 89/<- %esp 5/r32/ebp -15770 5d/pop-to-ebp -15771 c3/return -15772 -15773 # Primitives supported -15774 # See mu_instructions for a summary of this linked-list data structure. -15775 # -15776 # For each operation, put variants with hard-coded registers before flexible ones. -15777 # -15778 # Unfortunately, our restrictions on addresses require that various fields in -15779 # primitives be handles, which complicates these definitions. -15780 # - we need to insert dummy fields all over the place for fake alloc-ids -15781 # - we can't use our syntax sugar of quoted literals for string fields -15782 # -15783 # Fake alloc-ids are needed because our type definitions up top require -15784 # handles but it's clearer to statically allocate these long-lived objects. -15785 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. -15786 # -15787 # Every 'object' below starts with a fake alloc-id. It may also contain other -15788 # fake alloc-ids for various handle fields. -15789 # -15790 # I think of objects starting with a fake alloc-id as having type 'payload'. -15791 # It's not really intended to be created dynamically; for that use `allocate` -15792 # as usual. -15793 # -15794 # Idea for a notation to simplify such definitions: -15795 # _Primitive-increment-eax: # (payload primitive) -15796 # 0x11/alloc-id:fake:payload -15797 # 0x11 @(0x11 "increment") # name -15798 # 0 0 # inouts -15799 # 0x11 @(0x11/payload -15800 # 0x11 @(0x11/payload # List-value -15801 # 0 0 # Var-name -15802 # 0x11 @(0x11 # Var-type -15803 # 1/is-atom -15804 # 1/value 0/unused # Type-tree-left -15805 # 0 0 # Type-tree-right -15806 # ) -15807 # 1 # block-depth -15808 # 0 # stack-offset -15809 # 0x11 @(0x11 "eax") # Var-register -15810 # ) -15811 # 0 0) # List-next -15812 # ... -15813 # _Primitive-increment-ecx/imm32/next -15814 # ... -15815 # Awfully complex and non-obvious. But also clearly signals there's something -15816 # to learn here, so may be worth trying. -15817 # -15818 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " -15819 # -15820 # For now we'll continue to just use comments and manually ensure they stay up -15821 # to date. -15822 == data -15823 Primitives: # (addr primitive) -15824 # - increment/decrement -15825 _Primitive-increment-eax: # (addr primitive) -15826 # var/eax <- increment => 40/increment-eax -15827 0x11/imm32/alloc-id:fake -15828 _string-increment/imm32/name -15829 0/imm32/no-inouts -15830 0/imm32/no-inouts -15831 0x11/imm32/alloc-id:fake -15832 Single-int-var-in-eax/imm32/outputs -15833 0x11/imm32/alloc-id:fake -15834 _string_40_increment_eax/imm32/subx-name -15835 0/imm32/no-rm32 -15836 0/imm32/no-r32 -15837 0/imm32/no-imm32 -15838 0/imm32/no-imm8 -15839 0/imm32/no-disp32 -15840 0/imm32/output-is-write-only -15841 0x11/imm32/alloc-id:fake -15842 _Primitive-increment-ecx/imm32/next -15843 _Primitive-increment-ecx: # (payload primitive) -15844 0x11/imm32/alloc-id:fake:payload -15845 # var/ecx <- increment => 41/increment-ecx -15846 0x11/imm32/alloc-id:fake -15847 _string-increment/imm32/name -15848 0/imm32/no-inouts -15849 0/imm32/no-inouts -15850 0x11/imm32/alloc-id:fake -15851 Single-int-var-in-ecx/imm32/outputs -15852 0x11/imm32/alloc-id:fake -15853 _string_41_increment_ecx/imm32/subx-name -15854 0/imm32/no-rm32 -15855 0/imm32/no-r32 -15856 0/imm32/no-imm32 -15857 0/imm32/no-imm8 -15858 0/imm32/no-disp32 -15859 0/imm32/output-is-write-only -15860 0x11/imm32/alloc-id:fake -15861 _Primitive-increment-edx/imm32/next -15862 _Primitive-increment-edx: # (payload primitive) -15863 0x11/imm32/alloc-id:fake:payload -15864 # var/edx <- increment => 42/increment-edx -15865 0x11/imm32/alloc-id:fake -15866 _string-increment/imm32/name -15867 0/imm32/no-inouts -15868 0/imm32/no-inouts -15869 0x11/imm32/alloc-id:fake -15870 Single-int-var-in-edx/imm32/outputs -15871 0x11/imm32/alloc-id:fake -15872 _string_42_increment_edx/imm32/subx-name -15873 0/imm32/no-rm32 -15874 0/imm32/no-r32 -15875 0/imm32/no-imm32 -15876 0/imm32/no-imm8 -15877 0/imm32/no-disp32 -15878 0/imm32/output-is-write-only -15879 0x11/imm32/alloc-id:fake -15880 _Primitive-increment-ebx/imm32/next -15881 _Primitive-increment-ebx: # (payload primitive) -15882 0x11/imm32/alloc-id:fake:payload -15883 # var/ebx <- increment => 43/increment-ebx -15884 0x11/imm32/alloc-id:fake -15885 _string-increment/imm32/name -15886 0/imm32/no-inouts -15887 0/imm32/no-inouts -15888 0x11/imm32/alloc-id:fake -15889 Single-int-var-in-ebx/imm32/outputs -15890 0x11/imm32/alloc-id:fake -15891 _string_43_increment_ebx/imm32/subx-name -15892 0/imm32/no-rm32 -15893 0/imm32/no-r32 -15894 0/imm32/no-imm32 -15895 0/imm32/no-imm8 -15896 0/imm32/no-disp32 -15897 0/imm32/output-is-write-only -15898 0x11/imm32/alloc-id:fake -15899 _Primitive-increment-esi/imm32/next -15900 _Primitive-increment-esi: # (payload primitive) -15901 0x11/imm32/alloc-id:fake:payload -15902 # var/esi <- increment => 46/increment-esi -15903 0x11/imm32/alloc-id:fake -15904 _string-increment/imm32/name -15905 0/imm32/no-inouts -15906 0/imm32/no-inouts -15907 0x11/imm32/alloc-id:fake -15908 Single-int-var-in-esi/imm32/outputs -15909 0x11/imm32/alloc-id:fake -15910 _string_46_increment_esi/imm32/subx-name -15911 0/imm32/no-rm32 -15912 0/imm32/no-r32 -15913 0/imm32/no-imm32 -15914 0/imm32/no-imm8 -15915 0/imm32/no-disp32 -15916 0/imm32/output-is-write-only -15917 0x11/imm32/alloc-id:fake -15918 _Primitive-increment-edi/imm32/next -15919 _Primitive-increment-edi: # (payload primitive) -15920 0x11/imm32/alloc-id:fake:payload -15921 # var/edi <- increment => 47/increment-edi -15922 0x11/imm32/alloc-id:fake -15923 _string-increment/imm32/name -15924 0/imm32/no-inouts -15925 0/imm32/no-inouts -15926 0x11/imm32/alloc-id:fake -15927 Single-int-var-in-edi/imm32/outputs -15928 0x11/imm32/alloc-id:fake -15929 _string_47_increment_edi/imm32/subx-name -15930 0/imm32/no-rm32 -15931 0/imm32/no-r32 -15932 0/imm32/no-imm32 -15933 0/imm32/no-imm8 -15934 0/imm32/no-disp32 -15935 0/imm32/output-is-write-only -15936 0x11/imm32/alloc-id:fake -15937 _Primitive-decrement-eax/imm32/next -15938 _Primitive-decrement-eax: # (payload primitive) -15939 0x11/imm32/alloc-id:fake:payload -15940 # var/eax <- decrement => 48/decrement-eax -15941 0x11/imm32/alloc-id:fake -15942 _string-decrement/imm32/name -15943 0/imm32/no-inouts -15944 0/imm32/no-inouts -15945 0x11/imm32/alloc-id:fake -15946 Single-int-var-in-eax/imm32/outputs -15947 0x11/imm32/alloc-id:fake -15948 _string_48_decrement_eax/imm32/subx-name -15949 0/imm32/no-rm32 -15950 0/imm32/no-r32 -15951 0/imm32/no-imm32 -15952 0/imm32/no-imm8 -15953 0/imm32/no-disp32 -15954 0/imm32/output-is-write-only -15955 0x11/imm32/alloc-id:fake -15956 _Primitive-decrement-ecx/imm32/next -15957 _Primitive-decrement-ecx: # (payload primitive) -15958 0x11/imm32/alloc-id:fake:payload -15959 # var/ecx <- decrement => 49/decrement-ecx -15960 0x11/imm32/alloc-id:fake -15961 _string-decrement/imm32/name -15962 0/imm32/no-inouts -15963 0/imm32/no-inouts -15964 0x11/imm32/alloc-id:fake -15965 Single-int-var-in-ecx/imm32/outputs -15966 0x11/imm32/alloc-id:fake -15967 _string_49_decrement_ecx/imm32/subx-name -15968 0/imm32/no-rm32 -15969 0/imm32/no-r32 -15970 0/imm32/no-imm32 -15971 0/imm32/no-imm8 -15972 0/imm32/no-disp32 -15973 0/imm32/output-is-write-only -15974 0x11/imm32/alloc-id:fake -15975 _Primitive-decrement-edx/imm32/next -15976 _Primitive-decrement-edx: # (payload primitive) -15977 0x11/imm32/alloc-id:fake:payload -15978 # var/edx <- decrement => 4a/decrement-edx -15979 0x11/imm32/alloc-id:fake -15980 _string-decrement/imm32/name -15981 0/imm32/no-inouts -15982 0/imm32/no-inouts +15665 56/push-esi +15666 57/push-edi +15667 # esi = stmt +15668 8b/-> *(ebp+0xc) 6/r32/esi +15669 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] +15670 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15671 89/<- %ecx 0/r32/eax +15672 # var target/edi: (addr stmt-var) = stmt->inouts[1] +15673 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +15674 89/<- %edi 0/r32/eax +15675 # +15676 (emit-indent *(ebp+8) *Curr-block-depth) +15677 (write-buffered *(ebp+8) "(write-to-stream") +15678 (emit-subx-call-operand *(ebp+8) %ecx) +15679 (flush *(ebp+8)) +15680 (emit-subx-call-operand *(ebp+8) %edi) +15681 (flush *(ebp+8)) +15682 (write-buffered *(ebp+8) Space) +15683 (flush *(ebp+8)) +15684 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +15685 (write-int32-hex-buffered *(ebp+8) %eax) +15686 (write-buffered *(ebp+8) ")\n") +15687 $translate-mu-write-to-stream-stmt:end: +15688 # . restore registers +15689 5f/pop-to-edi +15690 5e/pop-to-esi +15691 59/pop-to-ecx +15692 58/pop-to-eax +15693 # . epilogue +15694 89/<- %esp 5/r32/ebp +15695 5d/pop-to-ebp +15696 c3/return +15697 +15698 addr-handle-array-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +15699 # . prologue +15700 55/push-ebp +15701 89/<- %ebp 4/r32/esp +15702 # var t/eax: (addr type-tree) = s->value->type +15703 8b/-> *(ebp+8) 0/r32/eax +15704 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15705 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +15706 # TODO: check eax != 0 +15707 # TODO: check !t->is-atom? +15708 # TODO: check t->left == addr +15709 # t = t->right +15710 $addr-handle-array-payload-size:skip-addr: +15711 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15712 # TODO: check eax != 0 +15713 # TODO: check !t->is-atom? +15714 # TODO: check t->left == handle +15715 # t = t->right +15716 $addr-handle-array-payload-size:skip-handle: +15717 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15718 # TODO: check eax != 0 +15719 # TODO: check !t->is-atom? +15720 # TODO: check t->left == array +15721 # t = t->right +15722 $addr-handle-array-payload-size:skip-array: +15723 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15724 # TODO: check eax != 0 +15725 # if !t->is-atom? t = t->left +15726 81 7/subop/compare *eax 0/imm32/false +15727 { +15728 75/jump-if-!= break/disp8 +15729 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15730 } +15731 $addr-handle-array-payload-size:compute-size: +15732 # TODO: check t->is-atom? +15733 # return size(t->value) +15734 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax +15735 $addr-handle-array-payload-size:end: +15736 # . epilogue +15737 89/<- %esp 5/r32/ebp +15738 5d/pop-to-ebp +15739 c3/return +15740 +15741 addr-handle-stream-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +15742 # . prologue +15743 55/push-ebp +15744 89/<- %ebp 4/r32/esp +15745 # var t/eax: (addr type-tree) = s->value->type +15746 8b/-> *(ebp+8) 0/r32/eax +15747 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15748 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +15749 # TODO: check eax != 0 +15750 # TODO: check !t->is-atom? +15751 # TODO: check t->left == addr +15752 # t = t->right +15753 $addr-handle-stream-payload-size:skip-addr: +15754 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15755 # TODO: check eax != 0 +15756 # TODO: check !t->is-atom? +15757 # TODO: check t->left == handle +15758 # t = t->right +15759 $addr-handle-stream-payload-size:skip-handle: +15760 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15761 # TODO: check eax != 0 +15762 # TODO: check !t->is-atom? +15763 # TODO: check t->left == stream +15764 # t = t->right +15765 $addr-handle-stream-payload-size:skip-stream: +15766 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15767 # TODO: check eax != 0 +15768 # if !t->is-atom? t = t->left +15769 81 7/subop/compare *eax 0/imm32/false +15770 { +15771 75/jump-if-!= break/disp8 +15772 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15773 } +15774 $addr-handle-stream-payload-size:compute-size: +15775 # TODO: check t->is-atom? +15776 # return size(t->value) +15777 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax +15778 $addr-handle-stream-payload-size:end: +15779 # . epilogue +15780 89/<- %esp 5/r32/ebp +15781 5d/pop-to-ebp +15782 c3/return +15783 +15784 power-of-2?: # n: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: boolean +15785 # precondition: n is positive +15786 # . prologue +15787 55/push-ebp +15788 89/<- %ebp 4/r32/esp +15789 # eax = n +15790 8b/-> *(ebp+8) 0/r32/eax +15791 # if (n < 0) abort +15792 3d/compare-eax-with 0/imm32 +15793 0f 8c/jump-if-< $power-of-2?:abort/disp32 +15794 # var tmp/eax: int = n-1 +15795 48/decrement-eax +15796 # var tmp2/eax: int = n & tmp +15797 23/and-> *(ebp+8) 0/r32/eax +15798 # return (tmp2 == 0) +15799 3d/compare-eax-and 0/imm32 +15800 0f 94/set-byte-if-= %al +15801 81 4/subop/and %eax 0xff/imm32 +15802 $power-of-2?:end: +15803 # . epilogue +15804 89/<- %esp 5/r32/ebp +15805 5d/pop-to-ebp +15806 c3/return +15807 +15808 $power-of-2?:abort: +15809 (write-buffered *(ebp+0xc) "power-of-2?: negative number\n") +15810 (flush *(ebp+0xc)) +15811 (stop *(ebp+0x10) 1) +15812 # never gets here +15813 +15814 num-shift-rights: # n: int -> result/eax: int +15815 # precondition: n is a positive power of 2 +15816 # . prologue +15817 55/push-ebp +15818 89/<- %ebp 4/r32/esp +15819 # . save registers +15820 51/push-ecx +15821 # var curr/ecx: int = n +15822 8b/-> *(ebp+8) 1/r32/ecx +15823 # result = 0 +15824 b8/copy-to-eax 0/imm32 +15825 { +15826 # if (curr <= 1) break +15827 81 7/subop/compare %ecx 1/imm32 +15828 7e/jump-if-<= break/disp8 +15829 40/increment-eax +15830 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 +15831 eb/jump loop/disp8 +15832 } +15833 $num-shift-rights:end: +15834 # . restore registers +15835 59/pop-to-ecx +15836 # . epilogue +15837 89/<- %esp 5/r32/ebp +15838 5d/pop-to-ebp +15839 c3/return +15840 +15841 mu-get-offset: # stmt: (addr stmt) -> result/eax: int +15842 # . prologue +15843 55/push-ebp +15844 89/<- %ebp 4/r32/esp +15845 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next +15846 8b/-> *(ebp+8) 0/r32/eax +15847 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +15848 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +15849 # var output-var/eax: (addr var) = second-inout->value +15850 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +15851 #? (write-buffered Stderr "mu-get-offset: ") +15852 #? (write-int32-hex-buffered Stderr %eax) +15853 #? (write-buffered Stderr " name: ") +15854 #? 50/push-eax +15855 #? (lookup *eax *(eax+4)) # Var-name +15856 #? (write-buffered Stderr %eax) +15857 #? 58/pop-to-eax +15858 #? (write-buffered Stderr Newline) +15859 #? (flush Stderr) +15860 # return output-var->stack-offset +15861 8b/-> *(eax+0x14) 0/r32/eax # Var-offset +15862 #? (write-buffered Stderr "=> ") +15863 #? (write-int32-hex-buffered Stderr %eax) +15864 #? (write-buffered Stderr Newline) +15865 #? (flush Stderr) +15866 $emit-get-offset:end: +15867 # . epilogue +15868 89/<- %esp 5/r32/ebp +15869 5d/pop-to-ebp +15870 c3/return +15871 +15872 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +15873 # . prologue +15874 55/push-ebp +15875 89/<- %ebp 4/r32/esp +15876 # . save registers +15877 50/push-eax +15878 51/push-ecx +15879 56/push-esi +15880 # esi = block +15881 8b/-> *(ebp+0xc) 6/r32/esi +15882 # block->var->block-depth = *Curr-block-depth +15883 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax +15884 8b/-> *Curr-block-depth 1/r32/ecx +15885 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth +15886 # var stmts/eax: (addr list stmt) = lookup(block->statements) +15887 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax +15888 # +15889 { +15890 $emit-subx-block:check-empty: +15891 3d/compare-eax-and 0/imm32 +15892 0f 84/jump-if-= break/disp32 +15893 (emit-indent *(ebp+8) *Curr-block-depth) +15894 (write-buffered *(ebp+8) "{\n") +15895 # var v/ecx: (addr var) = lookup(block->var) +15896 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax +15897 89/<- %ecx 0/r32/eax +15898 # +15899 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +15900 (write-buffered *(ebp+8) %eax) +15901 (write-buffered *(ebp+8) ":loop:\n") +15902 ff 0/subop/increment *Curr-block-depth +15903 (push *(ebp+0x10) *(esi+0xc)) # Block-var +15904 (push *(ebp+0x10) *(esi+0x10)) # Block-var +15905 (push *(ebp+0x10) 0) # false +15906 # emit block->statements +15907 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax +15908 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +15909 (pop *(ebp+0x10)) # => eax +15910 (pop *(ebp+0x10)) # => eax +15911 (pop *(ebp+0x10)) # => eax +15912 ff 1/subop/decrement *Curr-block-depth +15913 (emit-indent *(ebp+8) *Curr-block-depth) +15914 (write-buffered *(ebp+8) "}\n") +15915 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +15916 (write-buffered *(ebp+8) %eax) +15917 (write-buffered *(ebp+8) ":break:\n") +15918 } +15919 $emit-subx-block:end: +15920 # . restore registers +15921 5e/pop-to-esi +15922 59/pop-to-ecx +15923 58/pop-to-eax +15924 # . epilogue +15925 89/<- %esp 5/r32/ebp +15926 5d/pop-to-ebp +15927 c3/return +15928 +15929 # Primitives supported +15930 # See mu_instructions for a summary of this linked-list data structure. +15931 # +15932 # For each operation, put variants with hard-coded registers before flexible ones. +15933 # +15934 # Unfortunately, our restrictions on addresses require that various fields in +15935 # primitives be handles, which complicates these definitions. +15936 # - we need to insert dummy fields all over the place for fake alloc-ids +15937 # - we can't use our syntax sugar of quoted literals for string fields +15938 # +15939 # Fake alloc-ids are needed because our type definitions up top require +15940 # handles but it's clearer to statically allocate these long-lived objects. +15941 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. +15942 # +15943 # Every 'object' below starts with a fake alloc-id. It may also contain other +15944 # fake alloc-ids for various handle fields. +15945 # +15946 # I think of objects starting with a fake alloc-id as having type 'payload'. +15947 # It's not really intended to be created dynamically; for that use `allocate` +15948 # as usual. +15949 # +15950 # Idea for a notation to simplify such definitions: +15951 # _Primitive-increment-eax: # (payload primitive) +15952 # 0x11/alloc-id:fake:payload +15953 # 0x11 @(0x11 "increment") # name +15954 # 0 0 # inouts +15955 # 0x11 @(0x11/payload +15956 # 0x11 @(0x11/payload # List-value +15957 # 0 0 # Var-name +15958 # 0x11 @(0x11 # Var-type +15959 # 1/is-atom +15960 # 1/value 0/unused # Type-tree-left +15961 # 0 0 # Type-tree-right +15962 # ) +15963 # 1 # block-depth +15964 # 0 # stack-offset +15965 # 0x11 @(0x11 "eax") # Var-register +15966 # ) +15967 # 0 0) # List-next +15968 # ... +15969 # _Primitive-increment-ecx/imm32/next +15970 # ... +15971 # Awfully complex and non-obvious. But also clearly signals there's something +15972 # to learn here, so may be worth trying. +15973 # +15974 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " +15975 # +15976 # For now we'll continue to just use comments and manually ensure they stay up +15977 # to date. +15978 == data +15979 Primitives: # (addr primitive) +15980 # - increment/decrement +15981 _Primitive-increment-eax: # (addr primitive) +15982 # var/eax <- increment => 40/increment-eax 15983 0x11/imm32/alloc-id:fake -15984 Single-int-var-in-edx/imm32/outputs -15985 0x11/imm32/alloc-id:fake -15986 _string_4a_decrement_edx/imm32/subx-name -15987 0/imm32/no-rm32 -15988 0/imm32/no-r32 -15989 0/imm32/no-imm32 -15990 0/imm32/no-imm8 -15991 0/imm32/no-disp32 -15992 0/imm32/output-is-write-only -15993 0x11/imm32/alloc-id:fake -15994 _Primitive-decrement-ebx/imm32/next -15995 _Primitive-decrement-ebx: # (payload primitive) -15996 0x11/imm32/alloc-id:fake:payload -15997 # var/ebx <- decrement => 4b/decrement-ebx -15998 0x11/imm32/alloc-id:fake -15999 _string-decrement/imm32/name -16000 0/imm32/no-inouts -16001 0/imm32/no-inouts +15984 _string-increment/imm32/name +15985 0/imm32/no-inouts +15986 0/imm32/no-inouts +15987 0x11/imm32/alloc-id:fake +15988 Single-int-var-in-eax/imm32/outputs +15989 0x11/imm32/alloc-id:fake +15990 _string_40_increment_eax/imm32/subx-name +15991 0/imm32/no-rm32 +15992 0/imm32/no-r32 +15993 0/imm32/no-imm32 +15994 0/imm32/no-imm8 +15995 0/imm32/no-disp32 +15996 0/imm32/output-is-write-only +15997 0x11/imm32/alloc-id:fake +15998 _Primitive-increment-ecx/imm32/next +15999 _Primitive-increment-ecx: # (payload primitive) +16000 0x11/imm32/alloc-id:fake:payload +16001 # var/ecx <- increment => 41/increment-ecx 16002 0x11/imm32/alloc-id:fake -16003 Single-int-var-in-ebx/imm32/outputs -16004 0x11/imm32/alloc-id:fake -16005 _string_4b_decrement_ebx/imm32/subx-name -16006 0/imm32/no-rm32 -16007 0/imm32/no-r32 -16008 0/imm32/no-imm32 -16009 0/imm32/no-imm8 -16010 0/imm32/no-disp32 -16011 0/imm32/output-is-write-only -16012 0x11/imm32/alloc-id:fake -16013 _Primitive-decrement-esi/imm32/next -16014 _Primitive-decrement-esi: # (payload primitive) -16015 0x11/imm32/alloc-id:fake:payload -16016 # var/esi <- decrement => 4e/decrement-esi -16017 0x11/imm32/alloc-id:fake -16018 _string-decrement/imm32/name -16019 0/imm32/no-inouts -16020 0/imm32/no-inouts +16003 _string-increment/imm32/name +16004 0/imm32/no-inouts +16005 0/imm32/no-inouts +16006 0x11/imm32/alloc-id:fake +16007 Single-int-var-in-ecx/imm32/outputs +16008 0x11/imm32/alloc-id:fake +16009 _string_41_increment_ecx/imm32/subx-name +16010 0/imm32/no-rm32 +16011 0/imm32/no-r32 +16012 0/imm32/no-imm32 +16013 0/imm32/no-imm8 +16014 0/imm32/no-disp32 +16015 0/imm32/output-is-write-only +16016 0x11/imm32/alloc-id:fake +16017 _Primitive-increment-edx/imm32/next +16018 _Primitive-increment-edx: # (payload primitive) +16019 0x11/imm32/alloc-id:fake:payload +16020 # var/edx <- increment => 42/increment-edx 16021 0x11/imm32/alloc-id:fake -16022 Single-int-var-in-esi/imm32/outputs -16023 0x11/imm32/alloc-id:fake -16024 _string_4e_decrement_esi/imm32/subx-name -16025 0/imm32/no-rm32 -16026 0/imm32/no-r32 -16027 0/imm32/no-imm32 -16028 0/imm32/no-imm8 -16029 0/imm32/no-disp32 -16030 0/imm32/output-is-write-only -16031 0x11/imm32/alloc-id:fake -16032 _Primitive-decrement-edi/imm32/next -16033 _Primitive-decrement-edi: # (payload primitive) -16034 0x11/imm32/alloc-id:fake:payload -16035 # var/edi <- decrement => 4f/decrement-edi -16036 0x11/imm32/alloc-id:fake -16037 _string-decrement/imm32/name -16038 0/imm32/no-inouts -16039 0/imm32/no-inouts +16022 _string-increment/imm32/name +16023 0/imm32/no-inouts +16024 0/imm32/no-inouts +16025 0x11/imm32/alloc-id:fake +16026 Single-int-var-in-edx/imm32/outputs +16027 0x11/imm32/alloc-id:fake +16028 _string_42_increment_edx/imm32/subx-name +16029 0/imm32/no-rm32 +16030 0/imm32/no-r32 +16031 0/imm32/no-imm32 +16032 0/imm32/no-imm8 +16033 0/imm32/no-disp32 +16034 0/imm32/output-is-write-only +16035 0x11/imm32/alloc-id:fake +16036 _Primitive-increment-ebx/imm32/next +16037 _Primitive-increment-ebx: # (payload primitive) +16038 0x11/imm32/alloc-id:fake:payload +16039 # var/ebx <- increment => 43/increment-ebx 16040 0x11/imm32/alloc-id:fake -16041 Single-int-var-in-edi/imm32/outputs -16042 0x11/imm32/alloc-id:fake -16043 _string_4f_decrement_edi/imm32/subx-name -16044 0/imm32/no-rm32 -16045 0/imm32/no-r32 -16046 0/imm32/no-imm32 -16047 0/imm32/no-imm8 -16048 0/imm32/no-disp32 -16049 0/imm32/output-is-write-only -16050 0x11/imm32/alloc-id:fake -16051 _Primitive-increment-mem/imm32/next -16052 _Primitive-increment-mem: # (payload primitive) -16053 0x11/imm32/alloc-id:fake:payload -16054 # increment var => ff 0/subop/increment *(ebp+__) -16055 0x11/imm32/alloc-id:fake -16056 _string-increment/imm32/name -16057 0x11/imm32/alloc-id:fake -16058 Single-int-var-in-mem/imm32/inouts -16059 0/imm32/no-outputs -16060 0/imm32/no-outputs -16061 0x11/imm32/alloc-id:fake -16062 _string_ff_subop_increment/imm32/subx-name -16063 1/imm32/rm32-is-first-inout -16064 0/imm32/no-r32 -16065 0/imm32/no-imm32 -16066 0/imm32/no-imm8 -16067 0/imm32/no-disp32 -16068 0/imm32/output-is-write-only -16069 0x11/imm32/alloc-id:fake -16070 _Primitive-increment-reg/imm32/next -16071 _Primitive-increment-reg: # (payload primitive) -16072 0x11/imm32/alloc-id:fake:payload -16073 # var/reg <- increment => ff 0/subop/increment %__ -16074 0x11/imm32/alloc-id:fake -16075 _string-increment/imm32/name -16076 0/imm32/no-inouts -16077 0/imm32/no-inouts +16041 _string-increment/imm32/name +16042 0/imm32/no-inouts +16043 0/imm32/no-inouts +16044 0x11/imm32/alloc-id:fake +16045 Single-int-var-in-ebx/imm32/outputs +16046 0x11/imm32/alloc-id:fake +16047 _string_43_increment_ebx/imm32/subx-name +16048 0/imm32/no-rm32 +16049 0/imm32/no-r32 +16050 0/imm32/no-imm32 +16051 0/imm32/no-imm8 +16052 0/imm32/no-disp32 +16053 0/imm32/output-is-write-only +16054 0x11/imm32/alloc-id:fake +16055 _Primitive-increment-esi/imm32/next +16056 _Primitive-increment-esi: # (payload primitive) +16057 0x11/imm32/alloc-id:fake:payload +16058 # var/esi <- increment => 46/increment-esi +16059 0x11/imm32/alloc-id:fake +16060 _string-increment/imm32/name +16061 0/imm32/no-inouts +16062 0/imm32/no-inouts +16063 0x11/imm32/alloc-id:fake +16064 Single-int-var-in-esi/imm32/outputs +16065 0x11/imm32/alloc-id:fake +16066 _string_46_increment_esi/imm32/subx-name +16067 0/imm32/no-rm32 +16068 0/imm32/no-r32 +16069 0/imm32/no-imm32 +16070 0/imm32/no-imm8 +16071 0/imm32/no-disp32 +16072 0/imm32/output-is-write-only +16073 0x11/imm32/alloc-id:fake +16074 _Primitive-increment-edi/imm32/next +16075 _Primitive-increment-edi: # (payload primitive) +16076 0x11/imm32/alloc-id:fake:payload +16077 # var/edi <- increment => 47/increment-edi 16078 0x11/imm32/alloc-id:fake -16079 Single-int-var-in-some-register/imm32/outputs -16080 0x11/imm32/alloc-id:fake -16081 _string_ff_subop_increment/imm32/subx-name -16082 3/imm32/rm32-is-first-output -16083 0/imm32/no-r32 -16084 0/imm32/no-imm32 -16085 0/imm32/no-imm8 -16086 0/imm32/no-disp32 -16087 0/imm32/output-is-write-only -16088 0x11/imm32/alloc-id:fake -16089 _Primitive-decrement-mem/imm32/next -16090 _Primitive-decrement-mem: # (payload primitive) -16091 0x11/imm32/alloc-id:fake:payload -16092 # decrement var => ff 1/subop/decrement *(ebp+__) -16093 0x11/imm32/alloc-id:fake -16094 _string-decrement/imm32/name -16095 0x11/imm32/alloc-id:fake -16096 Single-int-var-in-mem/imm32/inouts -16097 0/imm32/no-outputs -16098 0/imm32/no-outputs -16099 0x11/imm32/alloc-id:fake -16100 _string_ff_subop_decrement/imm32/subx-name -16101 1/imm32/rm32-is-first-inout -16102 0/imm32/no-r32 -16103 0/imm32/no-imm32 -16104 0/imm32/no-imm8 -16105 0/imm32/no-disp32 -16106 0/imm32/output-is-write-only -16107 0x11/imm32/alloc-id:fake -16108 _Primitive-decrement-reg/imm32/next -16109 _Primitive-decrement-reg: # (payload primitive) -16110 0x11/imm32/alloc-id:fake:payload -16111 # var/reg <- decrement => ff 1/subop/decrement %__ -16112 0x11/imm32/alloc-id:fake -16113 _string-decrement/imm32/name -16114 0/imm32/no-inouts -16115 0/imm32/no-inouts +16079 _string-increment/imm32/name +16080 0/imm32/no-inouts +16081 0/imm32/no-inouts +16082 0x11/imm32/alloc-id:fake +16083 Single-int-var-in-edi/imm32/outputs +16084 0x11/imm32/alloc-id:fake +16085 _string_47_increment_edi/imm32/subx-name +16086 0/imm32/no-rm32 +16087 0/imm32/no-r32 +16088 0/imm32/no-imm32 +16089 0/imm32/no-imm8 +16090 0/imm32/no-disp32 +16091 0/imm32/output-is-write-only +16092 0x11/imm32/alloc-id:fake +16093 _Primitive-decrement-eax/imm32/next +16094 _Primitive-decrement-eax: # (payload primitive) +16095 0x11/imm32/alloc-id:fake:payload +16096 # var/eax <- decrement => 48/decrement-eax +16097 0x11/imm32/alloc-id:fake +16098 _string-decrement/imm32/name +16099 0/imm32/no-inouts +16100 0/imm32/no-inouts +16101 0x11/imm32/alloc-id:fake +16102 Single-int-var-in-eax/imm32/outputs +16103 0x11/imm32/alloc-id:fake +16104 _string_48_decrement_eax/imm32/subx-name +16105 0/imm32/no-rm32 +16106 0/imm32/no-r32 +16107 0/imm32/no-imm32 +16108 0/imm32/no-imm8 +16109 0/imm32/no-disp32 +16110 0/imm32/output-is-write-only +16111 0x11/imm32/alloc-id:fake +16112 _Primitive-decrement-ecx/imm32/next +16113 _Primitive-decrement-ecx: # (payload primitive) +16114 0x11/imm32/alloc-id:fake:payload +16115 # var/ecx <- decrement => 49/decrement-ecx 16116 0x11/imm32/alloc-id:fake -16117 Single-int-var-in-some-register/imm32/outputs -16118 0x11/imm32/alloc-id:fake -16119 _string_ff_subop_decrement/imm32/subx-name -16120 3/imm32/rm32-is-first-output -16121 0/imm32/no-r32 -16122 0/imm32/no-imm32 -16123 0/imm32/no-imm8 -16124 0/imm32/no-disp32 -16125 0/imm32/output-is-write-only -16126 0x11/imm32/alloc-id:fake -16127 _Primitive-add-to-eax/imm32/next -16128 # - add -16129 _Primitive-add-to-eax: # (payload primitive) -16130 0x11/imm32/alloc-id:fake:payload -16131 # var/eax <- add lit => 05/add-to-eax lit/imm32 -16132 0x11/imm32/alloc-id:fake -16133 _string-add/imm32/name -16134 0x11/imm32/alloc-id:fake -16135 Single-lit-var/imm32/inouts -16136 0x11/imm32/alloc-id:fake -16137 Single-int-var-in-eax/imm32/outputs -16138 0x11/imm32/alloc-id:fake -16139 _string_05_add_to_eax/imm32/subx-name -16140 0/imm32/no-rm32 -16141 0/imm32/no-r32 -16142 1/imm32/imm32-is-first-inout -16143 0/imm32/no-imm8 -16144 0/imm32/no-disp32 -16145 0/imm32/output-is-write-only -16146 0x11/imm32/alloc-id:fake -16147 _Primitive-add-reg-to-reg/imm32/next -16148 _Primitive-add-reg-to-reg: # (payload primitive) -16149 0x11/imm32/alloc-id:fake:payload -16150 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 -16151 0x11/imm32/alloc-id:fake -16152 _string-add/imm32/name -16153 0x11/imm32/alloc-id:fake -16154 Single-int-var-in-some-register/imm32/inouts -16155 0x11/imm32/alloc-id:fake -16156 Single-int-var-in-some-register/imm32/outputs -16157 0x11/imm32/alloc-id:fake -16158 _string_01_add_to/imm32/subx-name -16159 3/imm32/rm32-is-first-output -16160 1/imm32/r32-is-first-inout -16161 0/imm32/no-imm32 -16162 0/imm32/no-imm8 -16163 0/imm32/no-disp32 -16164 0/imm32/output-is-write-only -16165 0x11/imm32/alloc-id:fake -16166 _Primitive-add-reg-to-mem/imm32/next -16167 _Primitive-add-reg-to-mem: # (payload primitive) -16168 0x11/imm32/alloc-id:fake:payload -16169 # add-to var1 var2/reg => 01/add-to var1 var2/r32 -16170 0x11/imm32/alloc-id:fake -16171 _string-add-to/imm32/name -16172 0x11/imm32/alloc-id:fake -16173 Two-args-int-stack-int-reg/imm32/inouts -16174 0/imm32/no-outputs -16175 0/imm32/no-outputs -16176 0x11/imm32/alloc-id:fake -16177 _string_01_add_to/imm32/subx-name -16178 1/imm32/rm32-is-first-inout -16179 2/imm32/r32-is-second-inout -16180 0/imm32/no-imm32 -16181 0/imm32/no-imm8 -16182 0/imm32/no-disp32 -16183 0/imm32/output-is-write-only -16184 0x11/imm32/alloc-id:fake -16185 _Primitive-add-mem-to-reg/imm32/next -16186 _Primitive-add-mem-to-reg: # (payload primitive) -16187 0x11/imm32/alloc-id:fake:payload -16188 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 -16189 0x11/imm32/alloc-id:fake -16190 _string-add/imm32/name -16191 0x11/imm32/alloc-id:fake -16192 Single-int-var-in-mem/imm32/inouts -16193 0x11/imm32/alloc-id:fake -16194 Single-int-var-in-some-register/imm32/outputs -16195 0x11/imm32/alloc-id:fake -16196 _string_03_add/imm32/subx-name -16197 1/imm32/rm32-is-first-inout -16198 3/imm32/r32-is-first-output -16199 0/imm32/no-imm32 -16200 0/imm32/no-imm8 -16201 0/imm32/no-disp32 -16202 0/imm32/output-is-write-only -16203 0x11/imm32/alloc-id:fake -16204 _Primitive-add-lit-to-reg/imm32/next -16205 _Primitive-add-lit-to-reg: # (payload primitive) -16206 0x11/imm32/alloc-id:fake:payload -16207 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 -16208 0x11/imm32/alloc-id:fake -16209 _string-add/imm32/name -16210 0x11/imm32/alloc-id:fake -16211 Single-lit-var/imm32/inouts -16212 0x11/imm32/alloc-id:fake -16213 Single-int-var-in-some-register/imm32/outputs -16214 0x11/imm32/alloc-id:fake -16215 _string_81_subop_add/imm32/subx-name -16216 3/imm32/rm32-is-first-output -16217 0/imm32/no-r32 -16218 1/imm32/imm32-is-first-inout -16219 0/imm32/no-imm8 -16220 0/imm32/no-disp32 -16221 0/imm32/output-is-write-only -16222 0x11/imm32/alloc-id:fake -16223 _Primitive-add-lit-to-mem/imm32/next -16224 _Primitive-add-lit-to-mem: # (payload primitive) -16225 0x11/imm32/alloc-id:fake:payload -16226 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 -16227 0x11/imm32/alloc-id:fake -16228 _string-add-to/imm32/name -16229 0x11/imm32/alloc-id:fake -16230 Int-var-and-literal/imm32/inouts -16231 0/imm32/no-outputs -16232 0/imm32/no-outputs -16233 0x11/imm32/alloc-id:fake -16234 _string_81_subop_add/imm32/subx-name -16235 1/imm32/rm32-is-first-inout -16236 0/imm32/no-r32 -16237 2/imm32/imm32-is-second-inout -16238 0/imm32/no-imm8 -16239 0/imm32/no-disp32 -16240 0/imm32/output-is-write-only -16241 0x11/imm32/alloc-id:fake -16242 _Primitive-subtract-from-eax/imm32/next -16243 # - subtract -16244 _Primitive-subtract-from-eax: # (payload primitive) -16245 0x11/imm32/alloc-id:fake:payload -16246 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 -16247 0x11/imm32/alloc-id:fake -16248 _string-subtract/imm32/name +16117 _string-decrement/imm32/name +16118 0/imm32/no-inouts +16119 0/imm32/no-inouts +16120 0x11/imm32/alloc-id:fake +16121 Single-int-var-in-ecx/imm32/outputs +16122 0x11/imm32/alloc-id:fake +16123 _string_49_decrement_ecx/imm32/subx-name +16124 0/imm32/no-rm32 +16125 0/imm32/no-r32 +16126 0/imm32/no-imm32 +16127 0/imm32/no-imm8 +16128 0/imm32/no-disp32 +16129 0/imm32/output-is-write-only +16130 0x11/imm32/alloc-id:fake +16131 _Primitive-decrement-edx/imm32/next +16132 _Primitive-decrement-edx: # (payload primitive) +16133 0x11/imm32/alloc-id:fake:payload +16134 # var/edx <- decrement => 4a/decrement-edx +16135 0x11/imm32/alloc-id:fake +16136 _string-decrement/imm32/name +16137 0/imm32/no-inouts +16138 0/imm32/no-inouts +16139 0x11/imm32/alloc-id:fake +16140 Single-int-var-in-edx/imm32/outputs +16141 0x11/imm32/alloc-id:fake +16142 _string_4a_decrement_edx/imm32/subx-name +16143 0/imm32/no-rm32 +16144 0/imm32/no-r32 +16145 0/imm32/no-imm32 +16146 0/imm32/no-imm8 +16147 0/imm32/no-disp32 +16148 0/imm32/output-is-write-only +16149 0x11/imm32/alloc-id:fake +16150 _Primitive-decrement-ebx/imm32/next +16151 _Primitive-decrement-ebx: # (payload primitive) +16152 0x11/imm32/alloc-id:fake:payload +16153 # var/ebx <- decrement => 4b/decrement-ebx +16154 0x11/imm32/alloc-id:fake +16155 _string-decrement/imm32/name +16156 0/imm32/no-inouts +16157 0/imm32/no-inouts +16158 0x11/imm32/alloc-id:fake +16159 Single-int-var-in-ebx/imm32/outputs +16160 0x11/imm32/alloc-id:fake +16161 _string_4b_decrement_ebx/imm32/subx-name +16162 0/imm32/no-rm32 +16163 0/imm32/no-r32 +16164 0/imm32/no-imm32 +16165 0/imm32/no-imm8 +16166 0/imm32/no-disp32 +16167 0/imm32/output-is-write-only +16168 0x11/imm32/alloc-id:fake +16169 _Primitive-decrement-esi/imm32/next +16170 _Primitive-decrement-esi: # (payload primitive) +16171 0x11/imm32/alloc-id:fake:payload +16172 # var/esi <- decrement => 4e/decrement-esi +16173 0x11/imm32/alloc-id:fake +16174 _string-decrement/imm32/name +16175 0/imm32/no-inouts +16176 0/imm32/no-inouts +16177 0x11/imm32/alloc-id:fake +16178 Single-int-var-in-esi/imm32/outputs +16179 0x11/imm32/alloc-id:fake +16180 _string_4e_decrement_esi/imm32/subx-name +16181 0/imm32/no-rm32 +16182 0/imm32/no-r32 +16183 0/imm32/no-imm32 +16184 0/imm32/no-imm8 +16185 0/imm32/no-disp32 +16186 0/imm32/output-is-write-only +16187 0x11/imm32/alloc-id:fake +16188 _Primitive-decrement-edi/imm32/next +16189 _Primitive-decrement-edi: # (payload primitive) +16190 0x11/imm32/alloc-id:fake:payload +16191 # var/edi <- decrement => 4f/decrement-edi +16192 0x11/imm32/alloc-id:fake +16193 _string-decrement/imm32/name +16194 0/imm32/no-inouts +16195 0/imm32/no-inouts +16196 0x11/imm32/alloc-id:fake +16197 Single-int-var-in-edi/imm32/outputs +16198 0x11/imm32/alloc-id:fake +16199 _string_4f_decrement_edi/imm32/subx-name +16200 0/imm32/no-rm32 +16201 0/imm32/no-r32 +16202 0/imm32/no-imm32 +16203 0/imm32/no-imm8 +16204 0/imm32/no-disp32 +16205 0/imm32/output-is-write-only +16206 0x11/imm32/alloc-id:fake +16207 _Primitive-increment-mem/imm32/next +16208 _Primitive-increment-mem: # (payload primitive) +16209 0x11/imm32/alloc-id:fake:payload +16210 # increment var => ff 0/subop/increment *(ebp+__) +16211 0x11/imm32/alloc-id:fake +16212 _string-increment/imm32/name +16213 0x11/imm32/alloc-id:fake +16214 Single-int-var-in-mem/imm32/inouts +16215 0/imm32/no-outputs +16216 0/imm32/no-outputs +16217 0x11/imm32/alloc-id:fake +16218 _string_ff_subop_increment/imm32/subx-name +16219 1/imm32/rm32-is-first-inout +16220 0/imm32/no-r32 +16221 0/imm32/no-imm32 +16222 0/imm32/no-imm8 +16223 0/imm32/no-disp32 +16224 0/imm32/output-is-write-only +16225 0x11/imm32/alloc-id:fake +16226 _Primitive-increment-reg/imm32/next +16227 _Primitive-increment-reg: # (payload primitive) +16228 0x11/imm32/alloc-id:fake:payload +16229 # var/reg <- increment => ff 0/subop/increment %__ +16230 0x11/imm32/alloc-id:fake +16231 _string-increment/imm32/name +16232 0/imm32/no-inouts +16233 0/imm32/no-inouts +16234 0x11/imm32/alloc-id:fake +16235 Single-int-var-in-some-register/imm32/outputs +16236 0x11/imm32/alloc-id:fake +16237 _string_ff_subop_increment/imm32/subx-name +16238 3/imm32/rm32-is-first-output +16239 0/imm32/no-r32 +16240 0/imm32/no-imm32 +16241 0/imm32/no-imm8 +16242 0/imm32/no-disp32 +16243 0/imm32/output-is-write-only +16244 0x11/imm32/alloc-id:fake +16245 _Primitive-decrement-mem/imm32/next +16246 _Primitive-decrement-mem: # (payload primitive) +16247 0x11/imm32/alloc-id:fake:payload +16248 # decrement var => ff 1/subop/decrement *(ebp+__) 16249 0x11/imm32/alloc-id:fake -16250 Single-lit-var/imm32/inouts +16250 _string-decrement/imm32/name 16251 0x11/imm32/alloc-id:fake -16252 Single-int-var-in-eax/imm32/outputs -16253 0x11/imm32/alloc-id:fake -16254 _string_2d_subtract_from_eax/imm32/subx-name -16255 0/imm32/no-rm32 -16256 0/imm32/no-r32 -16257 1/imm32/imm32-is-first-inout -16258 0/imm32/no-imm8 -16259 0/imm32/no-disp32 -16260 0/imm32/output-is-write-only -16261 0x11/imm32/alloc-id:fake -16262 _Primitive-subtract-reg-from-reg/imm32/next -16263 _Primitive-subtract-reg-from-reg: # (payload primitive) -16264 0x11/imm32/alloc-id:fake:payload -16265 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 -16266 0x11/imm32/alloc-id:fake -16267 _string-subtract/imm32/name +16252 Single-int-var-in-mem/imm32/inouts +16253 0/imm32/no-outputs +16254 0/imm32/no-outputs +16255 0x11/imm32/alloc-id:fake +16256 _string_ff_subop_decrement/imm32/subx-name +16257 1/imm32/rm32-is-first-inout +16258 0/imm32/no-r32 +16259 0/imm32/no-imm32 +16260 0/imm32/no-imm8 +16261 0/imm32/no-disp32 +16262 0/imm32/output-is-write-only +16263 0x11/imm32/alloc-id:fake +16264 _Primitive-decrement-reg/imm32/next +16265 _Primitive-decrement-reg: # (payload primitive) +16266 0x11/imm32/alloc-id:fake:payload +16267 # var/reg <- decrement => ff 1/subop/decrement %__ 16268 0x11/imm32/alloc-id:fake -16269 Single-int-var-in-some-register/imm32/inouts -16270 0x11/imm32/alloc-id:fake -16271 Single-int-var-in-some-register/imm32/outputs +16269 _string-decrement/imm32/name +16270 0/imm32/no-inouts +16271 0/imm32/no-inouts 16272 0x11/imm32/alloc-id:fake -16273 _string_29_subtract_from/imm32/subx-name -16274 3/imm32/rm32-is-first-output -16275 1/imm32/r32-is-first-inout -16276 0/imm32/no-imm32 -16277 0/imm32/no-imm8 -16278 0/imm32/no-disp32 -16279 0/imm32/output-is-write-only -16280 0x11/imm32/alloc-id:fake -16281 _Primitive-subtract-reg-from-mem/imm32/next -16282 _Primitive-subtract-reg-from-mem: # (payload primitive) -16283 0x11/imm32/alloc-id:fake:payload -16284 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 -16285 0x11/imm32/alloc-id:fake -16286 _string-subtract-from/imm32/name -16287 0x11/imm32/alloc-id:fake -16288 Two-args-int-stack-int-reg/imm32/inouts -16289 0/imm32/no-outputs -16290 0/imm32/no-outputs -16291 0x11/imm32/alloc-id:fake -16292 _string_29_subtract_from/imm32/subx-name -16293 1/imm32/rm32-is-first-inout -16294 2/imm32/r32-is-second-inout -16295 0/imm32/no-imm32 -16296 0/imm32/no-imm8 -16297 0/imm32/no-disp32 -16298 0/imm32/output-is-write-only -16299 0x11/imm32/alloc-id:fake -16300 _Primitive-subtract-mem-from-reg/imm32/next -16301 _Primitive-subtract-mem-from-reg: # (payload primitive) -16302 0x11/imm32/alloc-id:fake:payload -16303 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 -16304 0x11/imm32/alloc-id:fake -16305 _string-subtract/imm32/name -16306 0x11/imm32/alloc-id:fake -16307 Single-int-var-in-mem/imm32/inouts -16308 0x11/imm32/alloc-id:fake -16309 Single-int-var-in-some-register/imm32/outputs -16310 0x11/imm32/alloc-id:fake -16311 _string_2b_subtract/imm32/subx-name -16312 1/imm32/rm32-is-first-inout -16313 3/imm32/r32-is-first-output -16314 0/imm32/no-imm32 -16315 0/imm32/no-imm8 -16316 0/imm32/no-disp32 -16317 0/imm32/output-is-write-only -16318 0x11/imm32/alloc-id:fake -16319 _Primitive-subtract-lit-from-reg/imm32/next -16320 _Primitive-subtract-lit-from-reg: # (payload primitive) -16321 0x11/imm32/alloc-id:fake:payload -16322 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 -16323 0x11/imm32/alloc-id:fake -16324 _string-subtract/imm32/name -16325 0x11/imm32/alloc-id:fake -16326 Single-lit-var/imm32/inouts -16327 0x11/imm32/alloc-id:fake -16328 Single-int-var-in-some-register/imm32/outputs -16329 0x11/imm32/alloc-id:fake -16330 _string_81_subop_subtract/imm32/subx-name -16331 3/imm32/rm32-is-first-output -16332 0/imm32/no-r32 -16333 1/imm32/imm32-is-first-inout -16334 0/imm32/no-imm8 -16335 0/imm32/no-disp32 -16336 0/imm32/output-is-write-only -16337 0x11/imm32/alloc-id:fake -16338 _Primitive-subtract-lit-from-mem/imm32/next -16339 _Primitive-subtract-lit-from-mem: # (payload primitive) -16340 0x11/imm32/alloc-id:fake:payload -16341 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 -16342 0x11/imm32/alloc-id:fake -16343 _string-subtract-from/imm32/name -16344 0x11/imm32/alloc-id:fake -16345 Int-var-and-literal/imm32/inouts -16346 0/imm32/no-outputs -16347 0/imm32/no-outputs -16348 0x11/imm32/alloc-id:fake -16349 _string_81_subop_subtract/imm32/subx-name -16350 1/imm32/rm32-is-first-inout -16351 0/imm32/no-r32 -16352 2/imm32/imm32-is-second-inout -16353 0/imm32/no-imm8 -16354 0/imm32/no-disp32 -16355 0/imm32/output-is-write-only -16356 0x11/imm32/alloc-id:fake -16357 _Primitive-and-with-eax/imm32/next -16358 # - and -16359 _Primitive-and-with-eax: # (payload primitive) -16360 0x11/imm32/alloc-id:fake:payload -16361 # var/eax <- and lit => 25/and-with-eax lit/imm32 -16362 0x11/imm32/alloc-id:fake -16363 _string-and/imm32/name +16273 Single-int-var-in-some-register/imm32/outputs +16274 0x11/imm32/alloc-id:fake +16275 _string_ff_subop_decrement/imm32/subx-name +16276 3/imm32/rm32-is-first-output +16277 0/imm32/no-r32 +16278 0/imm32/no-imm32 +16279 0/imm32/no-imm8 +16280 0/imm32/no-disp32 +16281 0/imm32/output-is-write-only +16282 0x11/imm32/alloc-id:fake +16283 _Primitive-add-to-eax/imm32/next +16284 # - add +16285 _Primitive-add-to-eax: # (payload primitive) +16286 0x11/imm32/alloc-id:fake:payload +16287 # var/eax <- add lit => 05/add-to-eax lit/imm32 +16288 0x11/imm32/alloc-id:fake +16289 _string-add/imm32/name +16290 0x11/imm32/alloc-id:fake +16291 Single-lit-var/imm32/inouts +16292 0x11/imm32/alloc-id:fake +16293 Single-int-var-in-eax/imm32/outputs +16294 0x11/imm32/alloc-id:fake +16295 _string_05_add_to_eax/imm32/subx-name +16296 0/imm32/no-rm32 +16297 0/imm32/no-r32 +16298 1/imm32/imm32-is-first-inout +16299 0/imm32/no-imm8 +16300 0/imm32/no-disp32 +16301 0/imm32/output-is-write-only +16302 0x11/imm32/alloc-id:fake +16303 _Primitive-add-reg-to-reg/imm32/next +16304 _Primitive-add-reg-to-reg: # (payload primitive) +16305 0x11/imm32/alloc-id:fake:payload +16306 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 +16307 0x11/imm32/alloc-id:fake +16308 _string-add/imm32/name +16309 0x11/imm32/alloc-id:fake +16310 Single-int-var-in-some-register/imm32/inouts +16311 0x11/imm32/alloc-id:fake +16312 Single-int-var-in-some-register/imm32/outputs +16313 0x11/imm32/alloc-id:fake +16314 _string_01_add_to/imm32/subx-name +16315 3/imm32/rm32-is-first-output +16316 1/imm32/r32-is-first-inout +16317 0/imm32/no-imm32 +16318 0/imm32/no-imm8 +16319 0/imm32/no-disp32 +16320 0/imm32/output-is-write-only +16321 0x11/imm32/alloc-id:fake +16322 _Primitive-add-reg-to-mem/imm32/next +16323 _Primitive-add-reg-to-mem: # (payload primitive) +16324 0x11/imm32/alloc-id:fake:payload +16325 # add-to var1 var2/reg => 01/add-to var1 var2/r32 +16326 0x11/imm32/alloc-id:fake +16327 _string-add-to/imm32/name +16328 0x11/imm32/alloc-id:fake +16329 Two-args-int-stack-int-reg/imm32/inouts +16330 0/imm32/no-outputs +16331 0/imm32/no-outputs +16332 0x11/imm32/alloc-id:fake +16333 _string_01_add_to/imm32/subx-name +16334 1/imm32/rm32-is-first-inout +16335 2/imm32/r32-is-second-inout +16336 0/imm32/no-imm32 +16337 0/imm32/no-imm8 +16338 0/imm32/no-disp32 +16339 0/imm32/output-is-write-only +16340 0x11/imm32/alloc-id:fake +16341 _Primitive-add-mem-to-reg/imm32/next +16342 _Primitive-add-mem-to-reg: # (payload primitive) +16343 0x11/imm32/alloc-id:fake:payload +16344 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 +16345 0x11/imm32/alloc-id:fake +16346 _string-add/imm32/name +16347 0x11/imm32/alloc-id:fake +16348 Single-int-var-in-mem/imm32/inouts +16349 0x11/imm32/alloc-id:fake +16350 Single-int-var-in-some-register/imm32/outputs +16351 0x11/imm32/alloc-id:fake +16352 _string_03_add/imm32/subx-name +16353 1/imm32/rm32-is-first-inout +16354 3/imm32/r32-is-first-output +16355 0/imm32/no-imm32 +16356 0/imm32/no-imm8 +16357 0/imm32/no-disp32 +16358 0/imm32/output-is-write-only +16359 0x11/imm32/alloc-id:fake +16360 _Primitive-add-lit-to-reg/imm32/next +16361 _Primitive-add-lit-to-reg: # (payload primitive) +16362 0x11/imm32/alloc-id:fake:payload +16363 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 16364 0x11/imm32/alloc-id:fake -16365 Single-lit-var/imm32/inouts +16365 _string-add/imm32/name 16366 0x11/imm32/alloc-id:fake -16367 Single-int-var-in-eax/imm32/outputs +16367 Single-lit-var/imm32/inouts 16368 0x11/imm32/alloc-id:fake -16369 _string_25_and_with_eax/imm32/subx-name -16370 0/imm32/no-rm32 -16371 0/imm32/no-r32 -16372 1/imm32/imm32-is-first-inout -16373 0/imm32/no-imm8 -16374 0/imm32/no-disp32 -16375 0/imm32/output-is-write-only -16376 0x11/imm32/alloc-id:fake -16377 _Primitive-and-reg-with-reg/imm32/next -16378 _Primitive-and-reg-with-reg: # (payload primitive) -16379 0x11/imm32/alloc-id:fake:payload -16380 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 -16381 0x11/imm32/alloc-id:fake -16382 _string-and/imm32/name +16369 Single-int-var-in-some-register/imm32/outputs +16370 0x11/imm32/alloc-id:fake +16371 _string_81_subop_add/imm32/subx-name +16372 3/imm32/rm32-is-first-output +16373 0/imm32/no-r32 +16374 1/imm32/imm32-is-first-inout +16375 0/imm32/no-imm8 +16376 0/imm32/no-disp32 +16377 0/imm32/output-is-write-only +16378 0x11/imm32/alloc-id:fake +16379 _Primitive-add-lit-to-mem/imm32/next +16380 _Primitive-add-lit-to-mem: # (payload primitive) +16381 0x11/imm32/alloc-id:fake:payload +16382 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 16383 0x11/imm32/alloc-id:fake -16384 Single-int-var-in-some-register/imm32/inouts +16384 _string-add-to/imm32/name 16385 0x11/imm32/alloc-id:fake -16386 Single-int-var-in-some-register/imm32/outputs -16387 0x11/imm32/alloc-id:fake -16388 _string_21_and_with/imm32/subx-name -16389 3/imm32/rm32-is-first-output -16390 1/imm32/r32-is-first-inout -16391 0/imm32/no-imm32 -16392 0/imm32/no-imm8 -16393 0/imm32/no-disp32 -16394 0/imm32/output-is-write-only -16395 0x11/imm32/alloc-id:fake -16396 _Primitive-and-reg-with-mem/imm32/next -16397 _Primitive-and-reg-with-mem: # (payload primitive) -16398 0x11/imm32/alloc-id:fake:payload -16399 # and-with var1 var2/reg => 21/and-with var1 var2/r32 -16400 0x11/imm32/alloc-id:fake -16401 _string-and-with/imm32/name -16402 0x11/imm32/alloc-id:fake -16403 Two-args-int-stack-int-reg/imm32/inouts -16404 0/imm32/no-outputs -16405 0/imm32/no-outputs -16406 0x11/imm32/alloc-id:fake -16407 _string_21_and_with/imm32/subx-name -16408 1/imm32/rm32-is-first-inout -16409 2/imm32/r32-is-second-inout -16410 0/imm32/no-imm32 -16411 0/imm32/no-imm8 -16412 0/imm32/no-disp32 -16413 0/imm32/output-is-write-only -16414 0x11/imm32/alloc-id:fake -16415 _Primitive-and-mem-with-reg/imm32/next -16416 _Primitive-and-mem-with-reg: # (payload primitive) -16417 0x11/imm32/alloc-id:fake:payload -16418 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 -16419 0x11/imm32/alloc-id:fake -16420 _string-and/imm32/name -16421 0x11/imm32/alloc-id:fake -16422 Single-int-var-in-mem/imm32/inouts -16423 0x11/imm32/alloc-id:fake -16424 Single-int-var-in-some-register/imm32/outputs -16425 0x11/imm32/alloc-id:fake -16426 _string_23_and/imm32/subx-name -16427 1/imm32/rm32-is-first-inout -16428 3/imm32/r32-is-first-output -16429 0/imm32/no-imm32 -16430 0/imm32/no-imm8 -16431 0/imm32/no-disp32 -16432 0/imm32/output-is-write-only -16433 0x11/imm32/alloc-id:fake -16434 _Primitive-and-lit-with-reg/imm32/next -16435 _Primitive-and-lit-with-reg: # (payload primitive) -16436 0x11/imm32/alloc-id:fake:payload -16437 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 -16438 0x11/imm32/alloc-id:fake -16439 _string-and/imm32/name -16440 0x11/imm32/alloc-id:fake -16441 Single-lit-var/imm32/inouts -16442 0x11/imm32/alloc-id:fake -16443 Single-int-var-in-some-register/imm32/outputs -16444 0x11/imm32/alloc-id:fake -16445 _string_81_subop_and/imm32/subx-name -16446 3/imm32/rm32-is-first-output -16447 0/imm32/no-r32 -16448 1/imm32/imm32-is-first-inout -16449 0/imm32/no-imm8 -16450 0/imm32/no-disp32 -16451 0/imm32/output-is-write-only -16452 0x11/imm32/alloc-id:fake -16453 _Primitive-and-lit-with-mem/imm32/next -16454 _Primitive-and-lit-with-mem: # (payload primitive) -16455 0x11/imm32/alloc-id:fake:payload -16456 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 -16457 0x11/imm32/alloc-id:fake -16458 _string-and-with/imm32/name -16459 0x11/imm32/alloc-id:fake -16460 Int-var-and-literal/imm32/inouts -16461 0/imm32/no-outputs -16462 0/imm32/no-outputs -16463 0x11/imm32/alloc-id:fake -16464 _string_81_subop_and/imm32/subx-name -16465 1/imm32/rm32-is-first-inout -16466 0/imm32/no-r32 -16467 2/imm32/imm32-is-second-inout -16468 0/imm32/no-imm8 -16469 0/imm32/no-disp32 -16470 0/imm32/output-is-write-only -16471 0x11/imm32/alloc-id:fake -16472 _Primitive-or-with-eax/imm32/next -16473 # - or -16474 _Primitive-or-with-eax: # (payload primitive) -16475 0x11/imm32/alloc-id:fake:payload -16476 # var/eax <- or lit => 0d/or-with-eax lit/imm32 -16477 0x11/imm32/alloc-id:fake -16478 _string-or/imm32/name +16386 Int-var-and-literal/imm32/inouts +16387 0/imm32/no-outputs +16388 0/imm32/no-outputs +16389 0x11/imm32/alloc-id:fake +16390 _string_81_subop_add/imm32/subx-name +16391 1/imm32/rm32-is-first-inout +16392 0/imm32/no-r32 +16393 2/imm32/imm32-is-second-inout +16394 0/imm32/no-imm8 +16395 0/imm32/no-disp32 +16396 0/imm32/output-is-write-only +16397 0x11/imm32/alloc-id:fake +16398 _Primitive-subtract-from-eax/imm32/next +16399 # - subtract +16400 _Primitive-subtract-from-eax: # (payload primitive) +16401 0x11/imm32/alloc-id:fake:payload +16402 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 +16403 0x11/imm32/alloc-id:fake +16404 _string-subtract/imm32/name +16405 0x11/imm32/alloc-id:fake +16406 Single-lit-var/imm32/inouts +16407 0x11/imm32/alloc-id:fake +16408 Single-int-var-in-eax/imm32/outputs +16409 0x11/imm32/alloc-id:fake +16410 _string_2d_subtract_from_eax/imm32/subx-name +16411 0/imm32/no-rm32 +16412 0/imm32/no-r32 +16413 1/imm32/imm32-is-first-inout +16414 0/imm32/no-imm8 +16415 0/imm32/no-disp32 +16416 0/imm32/output-is-write-only +16417 0x11/imm32/alloc-id:fake +16418 _Primitive-subtract-reg-from-reg/imm32/next +16419 _Primitive-subtract-reg-from-reg: # (payload primitive) +16420 0x11/imm32/alloc-id:fake:payload +16421 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 +16422 0x11/imm32/alloc-id:fake +16423 _string-subtract/imm32/name +16424 0x11/imm32/alloc-id:fake +16425 Single-int-var-in-some-register/imm32/inouts +16426 0x11/imm32/alloc-id:fake +16427 Single-int-var-in-some-register/imm32/outputs +16428 0x11/imm32/alloc-id:fake +16429 _string_29_subtract_from/imm32/subx-name +16430 3/imm32/rm32-is-first-output +16431 1/imm32/r32-is-first-inout +16432 0/imm32/no-imm32 +16433 0/imm32/no-imm8 +16434 0/imm32/no-disp32 +16435 0/imm32/output-is-write-only +16436 0x11/imm32/alloc-id:fake +16437 _Primitive-subtract-reg-from-mem/imm32/next +16438 _Primitive-subtract-reg-from-mem: # (payload primitive) +16439 0x11/imm32/alloc-id:fake:payload +16440 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 +16441 0x11/imm32/alloc-id:fake +16442 _string-subtract-from/imm32/name +16443 0x11/imm32/alloc-id:fake +16444 Two-args-int-stack-int-reg/imm32/inouts +16445 0/imm32/no-outputs +16446 0/imm32/no-outputs +16447 0x11/imm32/alloc-id:fake +16448 _string_29_subtract_from/imm32/subx-name +16449 1/imm32/rm32-is-first-inout +16450 2/imm32/r32-is-second-inout +16451 0/imm32/no-imm32 +16452 0/imm32/no-imm8 +16453 0/imm32/no-disp32 +16454 0/imm32/output-is-write-only +16455 0x11/imm32/alloc-id:fake +16456 _Primitive-subtract-mem-from-reg/imm32/next +16457 _Primitive-subtract-mem-from-reg: # (payload primitive) +16458 0x11/imm32/alloc-id:fake:payload +16459 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 +16460 0x11/imm32/alloc-id:fake +16461 _string-subtract/imm32/name +16462 0x11/imm32/alloc-id:fake +16463 Single-int-var-in-mem/imm32/inouts +16464 0x11/imm32/alloc-id:fake +16465 Single-int-var-in-some-register/imm32/outputs +16466 0x11/imm32/alloc-id:fake +16467 _string_2b_subtract/imm32/subx-name +16468 1/imm32/rm32-is-first-inout +16469 3/imm32/r32-is-first-output +16470 0/imm32/no-imm32 +16471 0/imm32/no-imm8 +16472 0/imm32/no-disp32 +16473 0/imm32/output-is-write-only +16474 0x11/imm32/alloc-id:fake +16475 _Primitive-subtract-lit-from-reg/imm32/next +16476 _Primitive-subtract-lit-from-reg: # (payload primitive) +16477 0x11/imm32/alloc-id:fake:payload +16478 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 16479 0x11/imm32/alloc-id:fake -16480 Single-lit-var/imm32/inouts +16480 _string-subtract/imm32/name 16481 0x11/imm32/alloc-id:fake -16482 Single-int-var-in-eax/imm32/outputs +16482 Single-lit-var/imm32/inouts 16483 0x11/imm32/alloc-id:fake -16484 _string_0d_or_with_eax/imm32/subx-name -16485 0/imm32/no-rm32 -16486 0/imm32/no-r32 -16487 1/imm32/imm32-is-first-inout -16488 0/imm32/no-imm8 -16489 0/imm32/no-disp32 -16490 0/imm32/output-is-write-only -16491 0x11/imm32/alloc-id:fake -16492 _Primitive-or-reg-with-reg/imm32/next -16493 _Primitive-or-reg-with-reg: # (payload primitive) -16494 0x11/imm32/alloc-id:fake:payload -16495 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 -16496 0x11/imm32/alloc-id:fake -16497 _string-or/imm32/name +16484 Single-int-var-in-some-register/imm32/outputs +16485 0x11/imm32/alloc-id:fake +16486 _string_81_subop_subtract/imm32/subx-name +16487 3/imm32/rm32-is-first-output +16488 0/imm32/no-r32 +16489 1/imm32/imm32-is-first-inout +16490 0/imm32/no-imm8 +16491 0/imm32/no-disp32 +16492 0/imm32/output-is-write-only +16493 0x11/imm32/alloc-id:fake +16494 _Primitive-subtract-lit-from-mem/imm32/next +16495 _Primitive-subtract-lit-from-mem: # (payload primitive) +16496 0x11/imm32/alloc-id:fake:payload +16497 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 16498 0x11/imm32/alloc-id:fake -16499 Single-int-var-in-some-register/imm32/inouts +16499 _string-subtract-from/imm32/name 16500 0x11/imm32/alloc-id:fake -16501 Single-int-var-in-some-register/imm32/outputs -16502 0x11/imm32/alloc-id:fake -16503 _string_09_or_with/imm32/subx-name -16504 3/imm32/rm32-is-first-output -16505 1/imm32/r32-is-first-inout -16506 0/imm32/no-imm32 -16507 0/imm32/no-imm8 -16508 0/imm32/no-disp32 -16509 0/imm32/output-is-write-only -16510 0x11/imm32/alloc-id:fake -16511 _Primitive-or-reg-with-mem/imm32/next -16512 _Primitive-or-reg-with-mem: # (payload primitive) -16513 0x11/imm32/alloc-id:fake:payload -16514 # or-with var1 var2/reg => 09/or-with var1 var2/r32 -16515 0x11/imm32/alloc-id:fake -16516 _string-or-with/imm32/name -16517 0x11/imm32/alloc-id:fake -16518 Two-args-int-stack-int-reg/imm32/inouts -16519 0/imm32/no-outputs -16520 0/imm32/no-outputs -16521 0x11/imm32/alloc-id:fake -16522 _string_09_or_with/imm32/subx-name -16523 1/imm32/rm32-is-first-inout -16524 2/imm32/r32-is-second-inout -16525 0/imm32/no-imm32 -16526 0/imm32/no-imm8 -16527 0/imm32/no-disp32 -16528 0/imm32/output-is-write-only -16529 0x11/imm32/alloc-id:fake -16530 _Primitive-or-mem-with-reg/imm32/next -16531 _Primitive-or-mem-with-reg: # (payload primitive) -16532 0x11/imm32/alloc-id:fake:payload -16533 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 -16534 0x11/imm32/alloc-id:fake -16535 _string-or/imm32/name -16536 0x11/imm32/alloc-id:fake -16537 Single-int-var-in-mem/imm32/inouts -16538 0x11/imm32/alloc-id:fake -16539 Single-int-var-in-some-register/imm32/outputs -16540 0x11/imm32/alloc-id:fake -16541 _string_0b_or/imm32/subx-name -16542 1/imm32/rm32-is-first-inout -16543 3/imm32/r32-is-first-output -16544 0/imm32/no-imm32 -16545 0/imm32/no-imm8 -16546 0/imm32/no-disp32 -16547 0/imm32/output-is-write-only -16548 0x11/imm32/alloc-id:fake -16549 _Primitive-or-lit-with-reg/imm32/next -16550 _Primitive-or-lit-with-reg: # (payload primitive) -16551 0x11/imm32/alloc-id:fake:payload -16552 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 -16553 0x11/imm32/alloc-id:fake -16554 _string-or/imm32/name -16555 0x11/imm32/alloc-id:fake -16556 Single-lit-var/imm32/inouts -16557 0x11/imm32/alloc-id:fake -16558 Single-int-var-in-some-register/imm32/outputs -16559 0x11/imm32/alloc-id:fake -16560 _string_81_subop_or/imm32/subx-name -16561 3/imm32/rm32-is-first-output -16562 0/imm32/no-r32 -16563 1/imm32/imm32-is-first-inout -16564 0/imm32/no-imm8 -16565 0/imm32/no-disp32 -16566 0/imm32/output-is-write-only -16567 0x11/imm32/alloc-id:fake -16568 _Primitive-or-lit-with-mem/imm32/next -16569 _Primitive-or-lit-with-mem: # (payload primitive) -16570 0x11/imm32/alloc-id:fake:payload -16571 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 -16572 0x11/imm32/alloc-id:fake -16573 _string-or-with/imm32/name -16574 0x11/imm32/alloc-id:fake -16575 Int-var-and-literal/imm32/inouts -16576 0/imm32/no-outputs -16577 0/imm32/no-outputs -16578 0x11/imm32/alloc-id:fake -16579 _string_81_subop_or/imm32/subx-name -16580 1/imm32/rm32-is-first-inout -16581 0/imm32/no-r32 -16582 2/imm32/imm32-is-second-inout -16583 0/imm32/no-imm8 -16584 0/imm32/no-disp32 -16585 0/imm32/output-is-write-only -16586 0x11/imm32/alloc-id:fake -16587 _Primitive-xor-with-eax/imm32/next -16588 # - xor -16589 _Primitive-xor-with-eax: # (payload primitive) -16590 0x11/imm32/alloc-id:fake:payload -16591 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 -16592 0x11/imm32/alloc-id:fake -16593 _string-xor/imm32/name +16501 Int-var-and-literal/imm32/inouts +16502 0/imm32/no-outputs +16503 0/imm32/no-outputs +16504 0x11/imm32/alloc-id:fake +16505 _string_81_subop_subtract/imm32/subx-name +16506 1/imm32/rm32-is-first-inout +16507 0/imm32/no-r32 +16508 2/imm32/imm32-is-second-inout +16509 0/imm32/no-imm8 +16510 0/imm32/no-disp32 +16511 0/imm32/output-is-write-only +16512 0x11/imm32/alloc-id:fake +16513 _Primitive-and-with-eax/imm32/next +16514 # - and +16515 _Primitive-and-with-eax: # (payload primitive) +16516 0x11/imm32/alloc-id:fake:payload +16517 # var/eax <- and lit => 25/and-with-eax lit/imm32 +16518 0x11/imm32/alloc-id:fake +16519 _string-and/imm32/name +16520 0x11/imm32/alloc-id:fake +16521 Single-lit-var/imm32/inouts +16522 0x11/imm32/alloc-id:fake +16523 Single-int-var-in-eax/imm32/outputs +16524 0x11/imm32/alloc-id:fake +16525 _string_25_and_with_eax/imm32/subx-name +16526 0/imm32/no-rm32 +16527 0/imm32/no-r32 +16528 1/imm32/imm32-is-first-inout +16529 0/imm32/no-imm8 +16530 0/imm32/no-disp32 +16531 0/imm32/output-is-write-only +16532 0x11/imm32/alloc-id:fake +16533 _Primitive-and-reg-with-reg/imm32/next +16534 _Primitive-and-reg-with-reg: # (payload primitive) +16535 0x11/imm32/alloc-id:fake:payload +16536 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 +16537 0x11/imm32/alloc-id:fake +16538 _string-and/imm32/name +16539 0x11/imm32/alloc-id:fake +16540 Single-int-var-in-some-register/imm32/inouts +16541 0x11/imm32/alloc-id:fake +16542 Single-int-var-in-some-register/imm32/outputs +16543 0x11/imm32/alloc-id:fake +16544 _string_21_and_with/imm32/subx-name +16545 3/imm32/rm32-is-first-output +16546 1/imm32/r32-is-first-inout +16547 0/imm32/no-imm32 +16548 0/imm32/no-imm8 +16549 0/imm32/no-disp32 +16550 0/imm32/output-is-write-only +16551 0x11/imm32/alloc-id:fake +16552 _Primitive-and-reg-with-mem/imm32/next +16553 _Primitive-and-reg-with-mem: # (payload primitive) +16554 0x11/imm32/alloc-id:fake:payload +16555 # and-with var1 var2/reg => 21/and-with var1 var2/r32 +16556 0x11/imm32/alloc-id:fake +16557 _string-and-with/imm32/name +16558 0x11/imm32/alloc-id:fake +16559 Two-args-int-stack-int-reg/imm32/inouts +16560 0/imm32/no-outputs +16561 0/imm32/no-outputs +16562 0x11/imm32/alloc-id:fake +16563 _string_21_and_with/imm32/subx-name +16564 1/imm32/rm32-is-first-inout +16565 2/imm32/r32-is-second-inout +16566 0/imm32/no-imm32 +16567 0/imm32/no-imm8 +16568 0/imm32/no-disp32 +16569 0/imm32/output-is-write-only +16570 0x11/imm32/alloc-id:fake +16571 _Primitive-and-mem-with-reg/imm32/next +16572 _Primitive-and-mem-with-reg: # (payload primitive) +16573 0x11/imm32/alloc-id:fake:payload +16574 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 +16575 0x11/imm32/alloc-id:fake +16576 _string-and/imm32/name +16577 0x11/imm32/alloc-id:fake +16578 Single-int-var-in-mem/imm32/inouts +16579 0x11/imm32/alloc-id:fake +16580 Single-int-var-in-some-register/imm32/outputs +16581 0x11/imm32/alloc-id:fake +16582 _string_23_and/imm32/subx-name +16583 1/imm32/rm32-is-first-inout +16584 3/imm32/r32-is-first-output +16585 0/imm32/no-imm32 +16586 0/imm32/no-imm8 +16587 0/imm32/no-disp32 +16588 0/imm32/output-is-write-only +16589 0x11/imm32/alloc-id:fake +16590 _Primitive-and-lit-with-reg/imm32/next +16591 _Primitive-and-lit-with-reg: # (payload primitive) +16592 0x11/imm32/alloc-id:fake:payload +16593 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 16594 0x11/imm32/alloc-id:fake -16595 Single-lit-var/imm32/inouts +16595 _string-and/imm32/name 16596 0x11/imm32/alloc-id:fake -16597 Single-int-var-in-eax/imm32/outputs +16597 Single-lit-var/imm32/inouts 16598 0x11/imm32/alloc-id:fake -16599 _string_35_xor_with_eax/imm32/subx-name -16600 0/imm32/no-rm32 -16601 0/imm32/no-r32 -16602 1/imm32/imm32-is-first-inout -16603 0/imm32/no-imm8 -16604 0/imm32/no-disp32 -16605 0/imm32/output-is-write-only -16606 0x11/imm32/alloc-id:fake -16607 _Primitive-xor-reg-with-reg/imm32/next -16608 _Primitive-xor-reg-with-reg: # (payload primitive) -16609 0x11/imm32/alloc-id:fake:payload -16610 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 -16611 0x11/imm32/alloc-id:fake -16612 _string-xor/imm32/name +16599 Single-int-var-in-some-register/imm32/outputs +16600 0x11/imm32/alloc-id:fake +16601 _string_81_subop_and/imm32/subx-name +16602 3/imm32/rm32-is-first-output +16603 0/imm32/no-r32 +16604 1/imm32/imm32-is-first-inout +16605 0/imm32/no-imm8 +16606 0/imm32/no-disp32 +16607 0/imm32/output-is-write-only +16608 0x11/imm32/alloc-id:fake +16609 _Primitive-and-lit-with-mem/imm32/next +16610 _Primitive-and-lit-with-mem: # (payload primitive) +16611 0x11/imm32/alloc-id:fake:payload +16612 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 16613 0x11/imm32/alloc-id:fake -16614 Single-int-var-in-some-register/imm32/inouts +16614 _string-and-with/imm32/name 16615 0x11/imm32/alloc-id:fake -16616 Single-int-var-in-some-register/imm32/outputs -16617 0x11/imm32/alloc-id:fake -16618 _string_31_xor_with/imm32/subx-name -16619 3/imm32/rm32-is-first-output -16620 1/imm32/r32-is-first-inout -16621 0/imm32/no-imm32 -16622 0/imm32/no-imm8 -16623 0/imm32/no-disp32 -16624 0/imm32/output-is-write-only -16625 0x11/imm32/alloc-id:fake -16626 _Primitive-xor-reg-with-mem/imm32/next -16627 _Primitive-xor-reg-with-mem: # (payload primitive) -16628 0x11/imm32/alloc-id:fake:payload -16629 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 -16630 0x11/imm32/alloc-id:fake -16631 _string-xor-with/imm32/name -16632 0x11/imm32/alloc-id:fake -16633 Two-args-int-stack-int-reg/imm32/inouts -16634 0/imm32/no-outputs -16635 0/imm32/no-outputs -16636 0x11/imm32/alloc-id:fake -16637 _string_31_xor_with/imm32/subx-name -16638 1/imm32/rm32-is-first-inout -16639 2/imm32/r32-is-second-inout -16640 0/imm32/no-imm32 -16641 0/imm32/no-imm8 -16642 0/imm32/no-disp32 -16643 0/imm32/output-is-write-only -16644 0x11/imm32/alloc-id:fake -16645 _Primitive-xor-mem-with-reg/imm32/next -16646 _Primitive-xor-mem-with-reg: # (payload primitive) -16647 0x11/imm32/alloc-id:fake:payload -16648 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 -16649 0x11/imm32/alloc-id:fake -16650 _string-xor/imm32/name -16651 0x11/imm32/alloc-id:fake -16652 Single-int-var-in-mem/imm32/inouts -16653 0x11/imm32/alloc-id:fake -16654 Single-int-var-in-some-register/imm32/outputs -16655 0x11/imm32/alloc-id:fake -16656 _string_33_xor/imm32/subx-name -16657 1/imm32/rm32-is-first-inout -16658 3/imm32/r32-is-first-output -16659 0/imm32/no-imm32 -16660 0/imm32/no-imm8 -16661 0/imm32/no-disp32 -16662 0/imm32/output-is-write-only -16663 0x11/imm32/alloc-id:fake -16664 _Primitive-xor-lit-with-reg/imm32/next -16665 _Primitive-xor-lit-with-reg: # (payload primitive) -16666 0x11/imm32/alloc-id:fake:payload -16667 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 -16668 0x11/imm32/alloc-id:fake -16669 _string-xor/imm32/name -16670 0x11/imm32/alloc-id:fake -16671 Single-lit-var/imm32/inouts -16672 0x11/imm32/alloc-id:fake -16673 Single-int-var-in-some-register/imm32/outputs -16674 0x11/imm32/alloc-id:fake -16675 _string_81_subop_xor/imm32/subx-name -16676 3/imm32/rm32-is-first-output -16677 0/imm32/no-r32 -16678 1/imm32/imm32-is-first-inout -16679 0/imm32/no-imm8 -16680 0/imm32/no-disp32 -16681 0/imm32/output-is-write-only -16682 0x11/imm32/alloc-id:fake -16683 _Primitive-xor-lit-with-mem/imm32/next -16684 _Primitive-xor-lit-with-mem: # (payload primitive) -16685 0x11/imm32/alloc-id:fake:payload -16686 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 -16687 0x11/imm32/alloc-id:fake -16688 _string-xor-with/imm32/name -16689 0x11/imm32/alloc-id:fake -16690 Int-var-and-literal/imm32/inouts -16691 0/imm32/no-outputs -16692 0/imm32/no-outputs -16693 0x11/imm32/alloc-id:fake -16694 _string_81_subop_xor/imm32/subx-name -16695 1/imm32/rm32-is-first-inout -16696 0/imm32/no-r32 -16697 2/imm32/imm32-is-second-inout -16698 0/imm32/no-imm8 -16699 0/imm32/no-disp32 -16700 0/imm32/output-is-write-only -16701 0x11/imm32/alloc-id:fake -16702 _Primitive-shift-reg-left-by-lit/imm32/next -16703 _Primitive-shift-reg-left-by-lit: # (payload primitive) -16704 0x11/imm32/alloc-id:fake:payload -16705 # var1/reg <- shift-left lit => c1/shift 4/subop/left var1/rm32 lit/imm32 -16706 0x11/imm32/alloc-id:fake -16707 _string-shift-left/imm32/name -16708 0x11/imm32/alloc-id:fake -16709 Single-lit-var/imm32/inouts -16710 0x11/imm32/alloc-id:fake -16711 Single-int-var-in-some-register/imm32/outputs -16712 0x11/imm32/alloc-id:fake -16713 _string_c1_subop_shift_left/imm32/subx-name -16714 3/imm32/rm32-is-first-output -16715 0/imm32/no-r32 -16716 0/imm32/no-imm32 -16717 1/imm32/imm8-is-first-inout -16718 0/imm32/no-disp32 -16719 0/imm32/output-is-write-only -16720 0x11/imm32/alloc-id:fake -16721 _Primitive-shift-reg-right-by-lit/imm32/next -16722 _Primitive-shift-reg-right-by-lit: # (payload primitive) -16723 0x11/imm32/alloc-id:fake:payload -16724 # var1/reg <- shift-right lit => c1/shift 5/subop/right var1/rm32 lit/imm32 -16725 0x11/imm32/alloc-id:fake -16726 _string-shift-right/imm32/name -16727 0x11/imm32/alloc-id:fake -16728 Single-lit-var/imm32/inouts -16729 0x11/imm32/alloc-id:fake -16730 Single-int-var-in-some-register/imm32/outputs -16731 0x11/imm32/alloc-id:fake -16732 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name -16733 3/imm32/rm32-is-first-output -16734 0/imm32/no-r32 -16735 0/imm32/no-imm32 -16736 1/imm32/imm8-is-first-inout -16737 0/imm32/no-disp32 -16738 0/imm32/output-is-write-only -16739 0x11/imm32/alloc-id:fake -16740 _Primitive-shift-reg-right-signed-by-lit/imm32/next -16741 _Primitive-shift-reg-right-signed-by-lit: # (payload primitive) -16742 0x11/imm32/alloc-id:fake:payload -16743 # var1/reg <- shift-right-signed lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 -16744 0x11/imm32/alloc-id:fake -16745 _string-shift-right-signed/imm32/name -16746 0x11/imm32/alloc-id:fake -16747 Single-lit-var/imm32/inouts +16616 Int-var-and-literal/imm32/inouts +16617 0/imm32/no-outputs +16618 0/imm32/no-outputs +16619 0x11/imm32/alloc-id:fake +16620 _string_81_subop_and/imm32/subx-name +16621 1/imm32/rm32-is-first-inout +16622 0/imm32/no-r32 +16623 2/imm32/imm32-is-second-inout +16624 0/imm32/no-imm8 +16625 0/imm32/no-disp32 +16626 0/imm32/output-is-write-only +16627 0x11/imm32/alloc-id:fake +16628 _Primitive-or-with-eax/imm32/next +16629 # - or +16630 _Primitive-or-with-eax: # (payload primitive) +16631 0x11/imm32/alloc-id:fake:payload +16632 # var/eax <- or lit => 0d/or-with-eax lit/imm32 +16633 0x11/imm32/alloc-id:fake +16634 _string-or/imm32/name +16635 0x11/imm32/alloc-id:fake +16636 Single-lit-var/imm32/inouts +16637 0x11/imm32/alloc-id:fake +16638 Single-int-var-in-eax/imm32/outputs +16639 0x11/imm32/alloc-id:fake +16640 _string_0d_or_with_eax/imm32/subx-name +16641 0/imm32/no-rm32 +16642 0/imm32/no-r32 +16643 1/imm32/imm32-is-first-inout +16644 0/imm32/no-imm8 +16645 0/imm32/no-disp32 +16646 0/imm32/output-is-write-only +16647 0x11/imm32/alloc-id:fake +16648 _Primitive-or-reg-with-reg/imm32/next +16649 _Primitive-or-reg-with-reg: # (payload primitive) +16650 0x11/imm32/alloc-id:fake:payload +16651 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 +16652 0x11/imm32/alloc-id:fake +16653 _string-or/imm32/name +16654 0x11/imm32/alloc-id:fake +16655 Single-int-var-in-some-register/imm32/inouts +16656 0x11/imm32/alloc-id:fake +16657 Single-int-var-in-some-register/imm32/outputs +16658 0x11/imm32/alloc-id:fake +16659 _string_09_or_with/imm32/subx-name +16660 3/imm32/rm32-is-first-output +16661 1/imm32/r32-is-first-inout +16662 0/imm32/no-imm32 +16663 0/imm32/no-imm8 +16664 0/imm32/no-disp32 +16665 0/imm32/output-is-write-only +16666 0x11/imm32/alloc-id:fake +16667 _Primitive-or-reg-with-mem/imm32/next +16668 _Primitive-or-reg-with-mem: # (payload primitive) +16669 0x11/imm32/alloc-id:fake:payload +16670 # or-with var1 var2/reg => 09/or-with var1 var2/r32 +16671 0x11/imm32/alloc-id:fake +16672 _string-or-with/imm32/name +16673 0x11/imm32/alloc-id:fake +16674 Two-args-int-stack-int-reg/imm32/inouts +16675 0/imm32/no-outputs +16676 0/imm32/no-outputs +16677 0x11/imm32/alloc-id:fake +16678 _string_09_or_with/imm32/subx-name +16679 1/imm32/rm32-is-first-inout +16680 2/imm32/r32-is-second-inout +16681 0/imm32/no-imm32 +16682 0/imm32/no-imm8 +16683 0/imm32/no-disp32 +16684 0/imm32/output-is-write-only +16685 0x11/imm32/alloc-id:fake +16686 _Primitive-or-mem-with-reg/imm32/next +16687 _Primitive-or-mem-with-reg: # (payload primitive) +16688 0x11/imm32/alloc-id:fake:payload +16689 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 +16690 0x11/imm32/alloc-id:fake +16691 _string-or/imm32/name +16692 0x11/imm32/alloc-id:fake +16693 Single-int-var-in-mem/imm32/inouts +16694 0x11/imm32/alloc-id:fake +16695 Single-int-var-in-some-register/imm32/outputs +16696 0x11/imm32/alloc-id:fake +16697 _string_0b_or/imm32/subx-name +16698 1/imm32/rm32-is-first-inout +16699 3/imm32/r32-is-first-output +16700 0/imm32/no-imm32 +16701 0/imm32/no-imm8 +16702 0/imm32/no-disp32 +16703 0/imm32/output-is-write-only +16704 0x11/imm32/alloc-id:fake +16705 _Primitive-or-lit-with-reg/imm32/next +16706 _Primitive-or-lit-with-reg: # (payload primitive) +16707 0x11/imm32/alloc-id:fake:payload +16708 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 +16709 0x11/imm32/alloc-id:fake +16710 _string-or/imm32/name +16711 0x11/imm32/alloc-id:fake +16712 Single-lit-var/imm32/inouts +16713 0x11/imm32/alloc-id:fake +16714 Single-int-var-in-some-register/imm32/outputs +16715 0x11/imm32/alloc-id:fake +16716 _string_81_subop_or/imm32/subx-name +16717 3/imm32/rm32-is-first-output +16718 0/imm32/no-r32 +16719 1/imm32/imm32-is-first-inout +16720 0/imm32/no-imm8 +16721 0/imm32/no-disp32 +16722 0/imm32/output-is-write-only +16723 0x11/imm32/alloc-id:fake +16724 _Primitive-or-lit-with-mem/imm32/next +16725 _Primitive-or-lit-with-mem: # (payload primitive) +16726 0x11/imm32/alloc-id:fake:payload +16727 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 +16728 0x11/imm32/alloc-id:fake +16729 _string-or-with/imm32/name +16730 0x11/imm32/alloc-id:fake +16731 Int-var-and-literal/imm32/inouts +16732 0/imm32/no-outputs +16733 0/imm32/no-outputs +16734 0x11/imm32/alloc-id:fake +16735 _string_81_subop_or/imm32/subx-name +16736 1/imm32/rm32-is-first-inout +16737 0/imm32/no-r32 +16738 2/imm32/imm32-is-second-inout +16739 0/imm32/no-imm8 +16740 0/imm32/no-disp32 +16741 0/imm32/output-is-write-only +16742 0x11/imm32/alloc-id:fake +16743 _Primitive-xor-with-eax/imm32/next +16744 # - xor +16745 _Primitive-xor-with-eax: # (payload primitive) +16746 0x11/imm32/alloc-id:fake:payload +16747 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 16748 0x11/imm32/alloc-id:fake -16749 Single-int-var-in-some-register/imm32/outputs +16749 _string-xor/imm32/name 16750 0x11/imm32/alloc-id:fake -16751 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name -16752 3/imm32/rm32-is-first-output -16753 0/imm32/no-r32 -16754 0/imm32/no-imm32 -16755 1/imm32/imm8-is-first-inout -16756 0/imm32/no-disp32 -16757 0/imm32/output-is-write-only -16758 0x11/imm32/alloc-id:fake -16759 _Primitive-shift-mem-left-by-lit/imm32/next -16760 _Primitive-shift-mem-left-by-lit: # (payload primitive) -16761 0x11/imm32/alloc-id:fake:payload -16762 # shift-left var1, lit => c1/shift 4/subop/left var1/rm32 lit/imm32 -16763 0x11/imm32/alloc-id:fake -16764 _string-shift-left/imm32/name -16765 0x11/imm32/alloc-id:fake -16766 Int-var-and-literal/imm32/inouts -16767 0/imm32/no-outputs -16768 0/imm32/no-outputs +16751 Single-lit-var/imm32/inouts +16752 0x11/imm32/alloc-id:fake +16753 Single-int-var-in-eax/imm32/outputs +16754 0x11/imm32/alloc-id:fake +16755 _string_35_xor_with_eax/imm32/subx-name +16756 0/imm32/no-rm32 +16757 0/imm32/no-r32 +16758 1/imm32/imm32-is-first-inout +16759 0/imm32/no-imm8 +16760 0/imm32/no-disp32 +16761 0/imm32/output-is-write-only +16762 0x11/imm32/alloc-id:fake +16763 _Primitive-xor-reg-with-reg/imm32/next +16764 _Primitive-xor-reg-with-reg: # (payload primitive) +16765 0x11/imm32/alloc-id:fake:payload +16766 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 +16767 0x11/imm32/alloc-id:fake +16768 _string-xor/imm32/name 16769 0x11/imm32/alloc-id:fake -16770 _string_c1_subop_shift_left/imm32/subx-name -16771 1/imm32/rm32-is-first-inout -16772 0/imm32/no-r32 -16773 0/imm32/no-imm32 -16774 2/imm32/imm8-is-second-inout -16775 0/imm32/no-disp32 -16776 0/imm32/output-is-write-only -16777 0x11/imm32/alloc-id:fake -16778 _Primitive-shift-mem-right-by-lit/imm32/next -16779 _Primitive-shift-mem-right-by-lit: # (payload primitive) -16780 0x11/imm32/alloc-id:fake:payload -16781 # shift-right var1, lit => c1/shift 5/subop/right var1/rm32 lit/imm32 -16782 0x11/imm32/alloc-id:fake -16783 _string-shift-right/imm32/name -16784 0x11/imm32/alloc-id:fake -16785 Int-var-and-literal/imm32/inouts -16786 0/imm32/no-outputs -16787 0/imm32/no-outputs +16770 Single-int-var-in-some-register/imm32/inouts +16771 0x11/imm32/alloc-id:fake +16772 Single-int-var-in-some-register/imm32/outputs +16773 0x11/imm32/alloc-id:fake +16774 _string_31_xor_with/imm32/subx-name +16775 3/imm32/rm32-is-first-output +16776 1/imm32/r32-is-first-inout +16777 0/imm32/no-imm32 +16778 0/imm32/no-imm8 +16779 0/imm32/no-disp32 +16780 0/imm32/output-is-write-only +16781 0x11/imm32/alloc-id:fake +16782 _Primitive-xor-reg-with-mem/imm32/next +16783 _Primitive-xor-reg-with-mem: # (payload primitive) +16784 0x11/imm32/alloc-id:fake:payload +16785 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 +16786 0x11/imm32/alloc-id:fake +16787 _string-xor-with/imm32/name 16788 0x11/imm32/alloc-id:fake -16789 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name -16790 1/imm32/rm32-is-first-inout -16791 0/imm32/no-r32 -16792 0/imm32/no-imm32 -16793 2/imm32/imm8-is-second-inout -16794 0/imm32/no-disp32 -16795 0/imm32/output-is-write-only -16796 0x11/imm32/alloc-id:fake -16797 _Primitive-shift-mem-right-signed-by-lit/imm32/next -16798 _Primitive-shift-mem-right-signed-by-lit: # (payload primitive) -16799 0x11/imm32/alloc-id:fake:payload -16800 # shift-right-signed var1, lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 -16801 0x11/imm32/alloc-id:fake -16802 _string-shift-right-signed/imm32/name -16803 0x11/imm32/alloc-id:fake -16804 Int-var-and-literal/imm32/inouts -16805 0/imm32/no-outputs -16806 0/imm32/no-outputs +16789 Two-args-int-stack-int-reg/imm32/inouts +16790 0/imm32/no-outputs +16791 0/imm32/no-outputs +16792 0x11/imm32/alloc-id:fake +16793 _string_31_xor_with/imm32/subx-name +16794 1/imm32/rm32-is-first-inout +16795 2/imm32/r32-is-second-inout +16796 0/imm32/no-imm32 +16797 0/imm32/no-imm8 +16798 0/imm32/no-disp32 +16799 0/imm32/output-is-write-only +16800 0x11/imm32/alloc-id:fake +16801 _Primitive-xor-mem-with-reg/imm32/next +16802 _Primitive-xor-mem-with-reg: # (payload primitive) +16803 0x11/imm32/alloc-id:fake:payload +16804 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 +16805 0x11/imm32/alloc-id:fake +16806 _string-xor/imm32/name 16807 0x11/imm32/alloc-id:fake -16808 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name -16809 1/imm32/rm32-is-first-inout -16810 0/imm32/no-r32 -16811 0/imm32/no-imm32 -16812 2/imm32/imm8-is-second-inout -16813 0/imm32/no-disp32 -16814 0/imm32/output-is-write-only -16815 0x11/imm32/alloc-id:fake -16816 _Primitive-copy-to-eax/imm32/next -16817 # - copy -16818 _Primitive-copy-to-eax: # (payload primitive) -16819 0x11/imm32/alloc-id:fake:payload -16820 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 -16821 0x11/imm32/alloc-id:fake -16822 _string-copy/imm32/name -16823 0x11/imm32/alloc-id:fake -16824 Single-lit-var/imm32/inouts -16825 0x11/imm32/alloc-id:fake -16826 Single-int-var-in-eax/imm32/outputs -16827 0x11/imm32/alloc-id:fake -16828 _string_b8_copy_to_eax/imm32/subx-name -16829 0/imm32/no-rm32 -16830 0/imm32/no-r32 -16831 1/imm32/imm32-is-first-inout -16832 0/imm32/no-imm8 -16833 0/imm32/no-disp32 -16834 1/imm32/output-is-write-only -16835 0x11/imm32/alloc-id:fake -16836 _Primitive-copy-to-ecx/imm32/next -16837 _Primitive-copy-to-ecx: # (payload primitive) -16838 0x11/imm32/alloc-id:fake:payload -16839 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 -16840 0x11/imm32/alloc-id:fake -16841 _string-copy/imm32/name -16842 0x11/imm32/alloc-id:fake -16843 Single-lit-var/imm32/inouts -16844 0x11/imm32/alloc-id:fake -16845 Single-int-var-in-ecx/imm32/outputs -16846 0x11/imm32/alloc-id:fake -16847 _string_b9_copy_to_ecx/imm32/subx-name -16848 0/imm32/no-rm32 -16849 0/imm32/no-r32 -16850 1/imm32/imm32-is-first-inout -16851 0/imm32/no-imm8 -16852 0/imm32/no-disp32 -16853 1/imm32/output-is-write-only -16854 0x11/imm32/alloc-id:fake -16855 _Primitive-copy-to-edx/imm32/next -16856 _Primitive-copy-to-edx: # (payload primitive) -16857 0x11/imm32/alloc-id:fake:payload -16858 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 -16859 0x11/imm32/alloc-id:fake -16860 _string-copy/imm32/name -16861 0x11/imm32/alloc-id:fake -16862 Single-lit-var/imm32/inouts -16863 0x11/imm32/alloc-id:fake -16864 Single-int-var-in-edx/imm32/outputs -16865 0x11/imm32/alloc-id:fake -16866 _string_ba_copy_to_edx/imm32/subx-name -16867 0/imm32/no-rm32 -16868 0/imm32/no-r32 -16869 1/imm32/imm32-is-first-inout -16870 0/imm32/no-imm8 -16871 0/imm32/no-disp32 -16872 1/imm32/output-is-write-only -16873 0x11/imm32/alloc-id:fake -16874 _Primitive-copy-to-ebx/imm32/next -16875 _Primitive-copy-to-ebx: # (payload primitive) -16876 0x11/imm32/alloc-id:fake:payload -16877 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 -16878 0x11/imm32/alloc-id:fake -16879 _string-copy/imm32/name -16880 0x11/imm32/alloc-id:fake -16881 Single-lit-var/imm32/inouts -16882 0x11/imm32/alloc-id:fake -16883 Single-int-var-in-ebx/imm32/outputs -16884 0x11/imm32/alloc-id:fake -16885 _string_bb_copy_to_ebx/imm32/subx-name -16886 0/imm32/no-rm32 -16887 0/imm32/no-r32 -16888 1/imm32/imm32-is-first-inout -16889 0/imm32/no-imm8 -16890 0/imm32/no-disp32 -16891 1/imm32/output-is-write-only -16892 0x11/imm32/alloc-id:fake -16893 _Primitive-copy-to-esi/imm32/next -16894 _Primitive-copy-to-esi: # (payload primitive) -16895 0x11/imm32/alloc-id:fake:payload -16896 # var/esi <- copy lit => be/copy-to-esi lit/imm32 -16897 0x11/imm32/alloc-id:fake -16898 _string-copy/imm32/name -16899 0x11/imm32/alloc-id:fake -16900 Single-lit-var/imm32/inouts -16901 0x11/imm32/alloc-id:fake -16902 Single-int-var-in-esi/imm32/outputs -16903 0x11/imm32/alloc-id:fake -16904 _string_be_copy_to_esi/imm32/subx-name -16905 0/imm32/no-rm32 -16906 0/imm32/no-r32 -16907 1/imm32/imm32-is-first-inout -16908 0/imm32/no-imm8 -16909 0/imm32/no-disp32 -16910 1/imm32/output-is-write-only -16911 0x11/imm32/alloc-id:fake -16912 _Primitive-copy-to-edi/imm32/next -16913 _Primitive-copy-to-edi: # (payload primitive) -16914 0x11/imm32/alloc-id:fake:payload -16915 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 -16916 0x11/imm32/alloc-id:fake -16917 _string-copy/imm32/name -16918 0x11/imm32/alloc-id:fake -16919 Single-lit-var/imm32/inouts -16920 0x11/imm32/alloc-id:fake -16921 Single-int-var-in-edi/imm32/outputs -16922 0x11/imm32/alloc-id:fake -16923 _string_bf_copy_to_edi/imm32/subx-name -16924 0/imm32/no-rm32 -16925 0/imm32/no-r32 -16926 1/imm32/imm32-is-first-inout -16927 0/imm32/no-imm8 -16928 0/imm32/no-disp32 -16929 1/imm32/output-is-write-only -16930 0x11/imm32/alloc-id:fake -16931 _Primitive-copy-reg-to-reg/imm32/next -16932 _Primitive-copy-reg-to-reg: # (payload primitive) -16933 0x11/imm32/alloc-id:fake:payload -16934 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 -16935 0x11/imm32/alloc-id:fake -16936 _string-copy/imm32/name -16937 0x11/imm32/alloc-id:fake -16938 Single-int-var-in-some-register/imm32/inouts -16939 0x11/imm32/alloc-id:fake -16940 Single-int-var-in-some-register/imm32/outputs -16941 0x11/imm32/alloc-id:fake -16942 _string_89_<-/imm32/subx-name -16943 3/imm32/rm32-is-first-output -16944 1/imm32/r32-is-first-inout -16945 0/imm32/no-imm32 -16946 0/imm32/no-imm8 -16947 0/imm32/no-disp32 -16948 1/imm32/output-is-write-only -16949 0x11/imm32/alloc-id:fake -16950 _Primitive-copy-reg-to-mem/imm32/next -16951 _Primitive-copy-reg-to-mem: # (payload primitive) -16952 0x11/imm32/alloc-id:fake:payload -16953 # copy-to var1 var2/reg => 89/<- var1 var2/r32 -16954 0x11/imm32/alloc-id:fake -16955 _string-copy-to/imm32/name -16956 0x11/imm32/alloc-id:fake -16957 Two-args-int-stack-int-reg/imm32/inouts -16958 0/imm32/no-outputs -16959 0/imm32/no-outputs -16960 0x11/imm32/alloc-id:fake -16961 _string_89_<-/imm32/subx-name -16962 1/imm32/rm32-is-first-inout -16963 2/imm32/r32-is-second-inout -16964 0/imm32/no-imm32 -16965 0/imm32/no-imm8 -16966 0/imm32/no-disp32 -16967 1/imm32/output-is-write-only -16968 0x11/imm32/alloc-id:fake -16969 _Primitive-copy-mem-to-reg/imm32/next -16970 _Primitive-copy-mem-to-reg: # (payload primitive) -16971 0x11/imm32/alloc-id:fake:payload -16972 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 -16973 0x11/imm32/alloc-id:fake -16974 _string-copy/imm32/name -16975 0x11/imm32/alloc-id:fake -16976 Single-int-var-in-mem/imm32/inouts +16808 Single-int-var-in-mem/imm32/inouts +16809 0x11/imm32/alloc-id:fake +16810 Single-int-var-in-some-register/imm32/outputs +16811 0x11/imm32/alloc-id:fake +16812 _string_33_xor/imm32/subx-name +16813 1/imm32/rm32-is-first-inout +16814 3/imm32/r32-is-first-output +16815 0/imm32/no-imm32 +16816 0/imm32/no-imm8 +16817 0/imm32/no-disp32 +16818 0/imm32/output-is-write-only +16819 0x11/imm32/alloc-id:fake +16820 _Primitive-xor-lit-with-reg/imm32/next +16821 _Primitive-xor-lit-with-reg: # (payload primitive) +16822 0x11/imm32/alloc-id:fake:payload +16823 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 +16824 0x11/imm32/alloc-id:fake +16825 _string-xor/imm32/name +16826 0x11/imm32/alloc-id:fake +16827 Single-lit-var/imm32/inouts +16828 0x11/imm32/alloc-id:fake +16829 Single-int-var-in-some-register/imm32/outputs +16830 0x11/imm32/alloc-id:fake +16831 _string_81_subop_xor/imm32/subx-name +16832 3/imm32/rm32-is-first-output +16833 0/imm32/no-r32 +16834 1/imm32/imm32-is-first-inout +16835 0/imm32/no-imm8 +16836 0/imm32/no-disp32 +16837 0/imm32/output-is-write-only +16838 0x11/imm32/alloc-id:fake +16839 _Primitive-xor-lit-with-mem/imm32/next +16840 _Primitive-xor-lit-with-mem: # (payload primitive) +16841 0x11/imm32/alloc-id:fake:payload +16842 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 +16843 0x11/imm32/alloc-id:fake +16844 _string-xor-with/imm32/name +16845 0x11/imm32/alloc-id:fake +16846 Int-var-and-literal/imm32/inouts +16847 0/imm32/no-outputs +16848 0/imm32/no-outputs +16849 0x11/imm32/alloc-id:fake +16850 _string_81_subop_xor/imm32/subx-name +16851 1/imm32/rm32-is-first-inout +16852 0/imm32/no-r32 +16853 2/imm32/imm32-is-second-inout +16854 0/imm32/no-imm8 +16855 0/imm32/no-disp32 +16856 0/imm32/output-is-write-only +16857 0x11/imm32/alloc-id:fake +16858 _Primitive-shift-reg-left-by-lit/imm32/next +16859 _Primitive-shift-reg-left-by-lit: # (payload primitive) +16860 0x11/imm32/alloc-id:fake:payload +16861 # var1/reg <- shift-left lit => c1/shift 4/subop/left var1/rm32 lit/imm32 +16862 0x11/imm32/alloc-id:fake +16863 _string-shift-left/imm32/name +16864 0x11/imm32/alloc-id:fake +16865 Single-lit-var/imm32/inouts +16866 0x11/imm32/alloc-id:fake +16867 Single-int-var-in-some-register/imm32/outputs +16868 0x11/imm32/alloc-id:fake +16869 _string_c1_subop_shift_left/imm32/subx-name +16870 3/imm32/rm32-is-first-output +16871 0/imm32/no-r32 +16872 0/imm32/no-imm32 +16873 1/imm32/imm8-is-first-inout +16874 0/imm32/no-disp32 +16875 0/imm32/output-is-write-only +16876 0x11/imm32/alloc-id:fake +16877 _Primitive-shift-reg-right-by-lit/imm32/next +16878 _Primitive-shift-reg-right-by-lit: # (payload primitive) +16879 0x11/imm32/alloc-id:fake:payload +16880 # var1/reg <- shift-right lit => c1/shift 5/subop/right var1/rm32 lit/imm32 +16881 0x11/imm32/alloc-id:fake +16882 _string-shift-right/imm32/name +16883 0x11/imm32/alloc-id:fake +16884 Single-lit-var/imm32/inouts +16885 0x11/imm32/alloc-id:fake +16886 Single-int-var-in-some-register/imm32/outputs +16887 0x11/imm32/alloc-id:fake +16888 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name +16889 3/imm32/rm32-is-first-output +16890 0/imm32/no-r32 +16891 0/imm32/no-imm32 +16892 1/imm32/imm8-is-first-inout +16893 0/imm32/no-disp32 +16894 0/imm32/output-is-write-only +16895 0x11/imm32/alloc-id:fake +16896 _Primitive-shift-reg-right-signed-by-lit/imm32/next +16897 _Primitive-shift-reg-right-signed-by-lit: # (payload primitive) +16898 0x11/imm32/alloc-id:fake:payload +16899 # var1/reg <- shift-right-signed lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 +16900 0x11/imm32/alloc-id:fake +16901 _string-shift-right-signed/imm32/name +16902 0x11/imm32/alloc-id:fake +16903 Single-lit-var/imm32/inouts +16904 0x11/imm32/alloc-id:fake +16905 Single-int-var-in-some-register/imm32/outputs +16906 0x11/imm32/alloc-id:fake +16907 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name +16908 3/imm32/rm32-is-first-output +16909 0/imm32/no-r32 +16910 0/imm32/no-imm32 +16911 1/imm32/imm8-is-first-inout +16912 0/imm32/no-disp32 +16913 0/imm32/output-is-write-only +16914 0x11/imm32/alloc-id:fake +16915 _Primitive-shift-mem-left-by-lit/imm32/next +16916 _Primitive-shift-mem-left-by-lit: # (payload primitive) +16917 0x11/imm32/alloc-id:fake:payload +16918 # shift-left var1, lit => c1/shift 4/subop/left var1/rm32 lit/imm32 +16919 0x11/imm32/alloc-id:fake +16920 _string-shift-left/imm32/name +16921 0x11/imm32/alloc-id:fake +16922 Int-var-and-literal/imm32/inouts +16923 0/imm32/no-outputs +16924 0/imm32/no-outputs +16925 0x11/imm32/alloc-id:fake +16926 _string_c1_subop_shift_left/imm32/subx-name +16927 1/imm32/rm32-is-first-inout +16928 0/imm32/no-r32 +16929 0/imm32/no-imm32 +16930 2/imm32/imm8-is-second-inout +16931 0/imm32/no-disp32 +16932 0/imm32/output-is-write-only +16933 0x11/imm32/alloc-id:fake +16934 _Primitive-shift-mem-right-by-lit/imm32/next +16935 _Primitive-shift-mem-right-by-lit: # (payload primitive) +16936 0x11/imm32/alloc-id:fake:payload +16937 # shift-right var1, lit => c1/shift 5/subop/right var1/rm32 lit/imm32 +16938 0x11/imm32/alloc-id:fake +16939 _string-shift-right/imm32/name +16940 0x11/imm32/alloc-id:fake +16941 Int-var-and-literal/imm32/inouts +16942 0/imm32/no-outputs +16943 0/imm32/no-outputs +16944 0x11/imm32/alloc-id:fake +16945 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name +16946 1/imm32/rm32-is-first-inout +16947 0/imm32/no-r32 +16948 0/imm32/no-imm32 +16949 2/imm32/imm8-is-second-inout +16950 0/imm32/no-disp32 +16951 0/imm32/output-is-write-only +16952 0x11/imm32/alloc-id:fake +16953 _Primitive-shift-mem-right-signed-by-lit/imm32/next +16954 _Primitive-shift-mem-right-signed-by-lit: # (payload primitive) +16955 0x11/imm32/alloc-id:fake:payload +16956 # shift-right-signed var1, lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 +16957 0x11/imm32/alloc-id:fake +16958 _string-shift-right-signed/imm32/name +16959 0x11/imm32/alloc-id:fake +16960 Int-var-and-literal/imm32/inouts +16961 0/imm32/no-outputs +16962 0/imm32/no-outputs +16963 0x11/imm32/alloc-id:fake +16964 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name +16965 1/imm32/rm32-is-first-inout +16966 0/imm32/no-r32 +16967 0/imm32/no-imm32 +16968 2/imm32/imm8-is-second-inout +16969 0/imm32/no-disp32 +16970 0/imm32/output-is-write-only +16971 0x11/imm32/alloc-id:fake +16972 _Primitive-copy-to-eax/imm32/next +16973 # - copy +16974 _Primitive-copy-to-eax: # (payload primitive) +16975 0x11/imm32/alloc-id:fake:payload +16976 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 16977 0x11/imm32/alloc-id:fake -16978 Single-int-var-in-some-register/imm32/outputs +16978 _string-copy/imm32/name 16979 0x11/imm32/alloc-id:fake -16980 _string_8b_->/imm32/subx-name -16981 1/imm32/rm32-is-first-inout -16982 3/imm32/r32-is-first-output -16983 0/imm32/no-imm32 -16984 0/imm32/no-imm8 -16985 0/imm32/no-disp32 -16986 1/imm32/output-is-write-only -16987 0x11/imm32/alloc-id:fake -16988 _Primitive-copy-lit-to-reg/imm32/next -16989 _Primitive-copy-lit-to-reg: # (payload primitive) -16990 0x11/imm32/alloc-id:fake:payload -16991 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 -16992 0x11/imm32/alloc-id:fake -16993 _string-copy/imm32/name -16994 0x11/imm32/alloc-id:fake -16995 Single-lit-var/imm32/inouts +16980 Single-lit-var/imm32/inouts +16981 0x11/imm32/alloc-id:fake +16982 Single-int-var-in-eax/imm32/outputs +16983 0x11/imm32/alloc-id:fake +16984 _string_b8_copy_to_eax/imm32/subx-name +16985 0/imm32/no-rm32 +16986 0/imm32/no-r32 +16987 1/imm32/imm32-is-first-inout +16988 0/imm32/no-imm8 +16989 0/imm32/no-disp32 +16990 1/imm32/output-is-write-only +16991 0x11/imm32/alloc-id:fake +16992 _Primitive-copy-to-ecx/imm32/next +16993 _Primitive-copy-to-ecx: # (payload primitive) +16994 0x11/imm32/alloc-id:fake:payload +16995 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 16996 0x11/imm32/alloc-id:fake -16997 Single-int-var-in-some-register/imm32/outputs +16997 _string-copy/imm32/name 16998 0x11/imm32/alloc-id:fake -16999 _string_c7_subop_copy/imm32/subx-name -17000 3/imm32/rm32-is-first-output -17001 0/imm32/no-r32 -17002 1/imm32/imm32-is-first-inout -17003 0/imm32/no-imm8 -17004 0/imm32/no-disp32 -17005 1/imm32/output-is-write-only -17006 0x11/imm32/alloc-id:fake -17007 _Primitive-copy-lit-to-mem/imm32/next -17008 _Primitive-copy-lit-to-mem: # (payload primitive) -17009 0x11/imm32/alloc-id:fake:payload -17010 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 -17011 0x11/imm32/alloc-id:fake -17012 _string-copy-to/imm32/name -17013 0x11/imm32/alloc-id:fake -17014 Int-var-and-literal/imm32/inouts -17015 0/imm32/no-outputs -17016 0/imm32/no-outputs +16999 Single-lit-var/imm32/inouts +17000 0x11/imm32/alloc-id:fake +17001 Single-int-var-in-ecx/imm32/outputs +17002 0x11/imm32/alloc-id:fake +17003 _string_b9_copy_to_ecx/imm32/subx-name +17004 0/imm32/no-rm32 +17005 0/imm32/no-r32 +17006 1/imm32/imm32-is-first-inout +17007 0/imm32/no-imm8 +17008 0/imm32/no-disp32 +17009 1/imm32/output-is-write-only +17010 0x11/imm32/alloc-id:fake +17011 _Primitive-copy-to-edx/imm32/next +17012 _Primitive-copy-to-edx: # (payload primitive) +17013 0x11/imm32/alloc-id:fake:payload +17014 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 +17015 0x11/imm32/alloc-id:fake +17016 _string-copy/imm32/name 17017 0x11/imm32/alloc-id:fake -17018 _string_c7_subop_copy/imm32/subx-name -17019 1/imm32/rm32-is-first-inout -17020 0/imm32/no-r32 -17021 2/imm32/imm32-is-second-inout -17022 0/imm32/no-imm8 -17023 0/imm32/no-disp32 -17024 1/imm32/output-is-write-only -17025 0x11/imm32/alloc-id:fake -17026 _Primitive-copy-byte-from-reg/imm32/next -17027 # - copy byte -17028 _Primitive-copy-byte-from-reg: -17029 0x11/imm32/alloc-id:fake:payload -17030 # var/reg <- copy-byte var2/reg2 => 8a/byte-> %var2 var/r32 -17031 0x11/imm32/alloc-id:fake -17032 _string-copy-byte/imm32/name -17033 0x11/imm32/alloc-id:fake -17034 Single-byte-var-in-some-register/imm32/inouts -17035 0x11/imm32/alloc-id:fake -17036 Single-byte-var-in-some-register/imm32/outputs -17037 0x11/imm32/alloc-id:fake -17038 _string_8a_copy_byte/imm32/subx-name -17039 1/imm32/rm32-is-first-inout -17040 3/imm32/r32-is-first-output -17041 0/imm32/no-imm32 -17042 0/imm32/no-imm8 -17043 0/imm32/no-disp32 -17044 1/imm32/output-is-write-only -17045 0x11/imm32/alloc-id:fake -17046 _Primitive-copy-byte-from-mem/imm32/next -17047 _Primitive-copy-byte-from-mem: -17048 0x11/imm32/alloc-id:fake:payload -17049 # var/reg <- copy-byte *var2/reg2 => 8a/byte-> *var2 var/r32 -17050 0x11/imm32/alloc-id:fake -17051 _string-copy-byte/imm32/name -17052 0x11/imm32/alloc-id:fake -17053 Single-byte-var-in-mem/imm32/inouts -17054 0x11/imm32/alloc-id:fake -17055 Single-byte-var-in-some-register/imm32/outputs -17056 0x11/imm32/alloc-id:fake -17057 _string_8a_copy_byte/imm32/subx-name -17058 1/imm32/rm32-is-first-inout -17059 3/imm32/r32-is-first-output -17060 0/imm32/no-imm32 -17061 0/imm32/no-imm8 -17062 0/imm32/no-disp32 -17063 1/imm32/output-is-write-only -17064 0x11/imm32/alloc-id:fake -17065 _Primitive-copy-byte-to-mem/imm32/next -17066 _Primitive-copy-byte-to-mem: -17067 0x11/imm32/alloc-id:fake:payload -17068 # copy-byte-to *var1/reg1, var2/reg2 => 88/byte<- *reg1 reg2/r32 -17069 0x11/imm32/alloc-id:fake -17070 _string-copy-byte-to/imm32/name -17071 0x11/imm32/alloc-id:fake -17072 Two-args-byte-stack-byte-reg/imm32/inouts -17073 0/imm32/no-outputs -17074 0/imm32/no-outputs -17075 0x11/imm32/alloc-id:fake -17076 _string_88_copy_byte/imm32/subx-name -17077 1/imm32/rm32-is-first-inout -17078 2/imm32/r32-is-second-inout -17079 0/imm32/no-imm32 -17080 0/imm32/no-imm8 -17081 0/imm32/no-disp32 -17082 0/imm32/output-is-write-only -17083 0x11/imm32/alloc-id:fake -17084 _Primitive-address/imm32/next -17085 # - address -17086 _Primitive-address: # (payload primitive) -17087 0x11/imm32/alloc-id:fake:payload -17088 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 -17089 0x11/imm32/alloc-id:fake -17090 _string-address/imm32/name +17018 Single-lit-var/imm32/inouts +17019 0x11/imm32/alloc-id:fake +17020 Single-int-var-in-edx/imm32/outputs +17021 0x11/imm32/alloc-id:fake +17022 _string_ba_copy_to_edx/imm32/subx-name +17023 0/imm32/no-rm32 +17024 0/imm32/no-r32 +17025 1/imm32/imm32-is-first-inout +17026 0/imm32/no-imm8 +17027 0/imm32/no-disp32 +17028 1/imm32/output-is-write-only +17029 0x11/imm32/alloc-id:fake +17030 _Primitive-copy-to-ebx/imm32/next +17031 _Primitive-copy-to-ebx: # (payload primitive) +17032 0x11/imm32/alloc-id:fake:payload +17033 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 +17034 0x11/imm32/alloc-id:fake +17035 _string-copy/imm32/name +17036 0x11/imm32/alloc-id:fake +17037 Single-lit-var/imm32/inouts +17038 0x11/imm32/alloc-id:fake +17039 Single-int-var-in-ebx/imm32/outputs +17040 0x11/imm32/alloc-id:fake +17041 _string_bb_copy_to_ebx/imm32/subx-name +17042 0/imm32/no-rm32 +17043 0/imm32/no-r32 +17044 1/imm32/imm32-is-first-inout +17045 0/imm32/no-imm8 +17046 0/imm32/no-disp32 +17047 1/imm32/output-is-write-only +17048 0x11/imm32/alloc-id:fake +17049 _Primitive-copy-to-esi/imm32/next +17050 _Primitive-copy-to-esi: # (payload primitive) +17051 0x11/imm32/alloc-id:fake:payload +17052 # var/esi <- copy lit => be/copy-to-esi lit/imm32 +17053 0x11/imm32/alloc-id:fake +17054 _string-copy/imm32/name +17055 0x11/imm32/alloc-id:fake +17056 Single-lit-var/imm32/inouts +17057 0x11/imm32/alloc-id:fake +17058 Single-int-var-in-esi/imm32/outputs +17059 0x11/imm32/alloc-id:fake +17060 _string_be_copy_to_esi/imm32/subx-name +17061 0/imm32/no-rm32 +17062 0/imm32/no-r32 +17063 1/imm32/imm32-is-first-inout +17064 0/imm32/no-imm8 +17065 0/imm32/no-disp32 +17066 1/imm32/output-is-write-only +17067 0x11/imm32/alloc-id:fake +17068 _Primitive-copy-to-edi/imm32/next +17069 _Primitive-copy-to-edi: # (payload primitive) +17070 0x11/imm32/alloc-id:fake:payload +17071 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 +17072 0x11/imm32/alloc-id:fake +17073 _string-copy/imm32/name +17074 0x11/imm32/alloc-id:fake +17075 Single-lit-var/imm32/inouts +17076 0x11/imm32/alloc-id:fake +17077 Single-int-var-in-edi/imm32/outputs +17078 0x11/imm32/alloc-id:fake +17079 _string_bf_copy_to_edi/imm32/subx-name +17080 0/imm32/no-rm32 +17081 0/imm32/no-r32 +17082 1/imm32/imm32-is-first-inout +17083 0/imm32/no-imm8 +17084 0/imm32/no-disp32 +17085 1/imm32/output-is-write-only +17086 0x11/imm32/alloc-id:fake +17087 _Primitive-copy-reg-to-reg/imm32/next +17088 _Primitive-copy-reg-to-reg: # (payload primitive) +17089 0x11/imm32/alloc-id:fake:payload +17090 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 17091 0x11/imm32/alloc-id:fake -17092 Single-int-var-in-mem/imm32/inouts +17092 _string-copy/imm32/name 17093 0x11/imm32/alloc-id:fake -17094 Single-addr-var-in-some-register/imm32/outputs +17094 Single-int-var-in-some-register/imm32/inouts 17095 0x11/imm32/alloc-id:fake -17096 _string_8d_copy_address/imm32/subx-name -17097 1/imm32/rm32-is-first-inout -17098 3/imm32/r32-is-first-output -17099 0/imm32/no-imm32 -17100 0/imm32/no-imm8 -17101 0/imm32/no-disp32 -17102 1/imm32/output-is-write-only -17103 0x11/imm32/alloc-id:fake -17104 _Primitive-compare-reg-with-reg/imm32/next -17105 # - compare -17106 _Primitive-compare-reg-with-reg: # (payload primitive) -17107 0x11/imm32/alloc-id:fake:payload -17108 # compare var1/reg1 var2/reg2 => 39/compare var1/rm32 var2/r32 -17109 0x11/imm32/alloc-id:fake -17110 _string-compare/imm32/name -17111 0x11/imm32/alloc-id:fake -17112 Two-int-args-in-regs/imm32/inouts -17113 0/imm32/no-outputs +17096 Single-int-var-in-some-register/imm32/outputs +17097 0x11/imm32/alloc-id:fake +17098 _string_89_<-/imm32/subx-name +17099 3/imm32/rm32-is-first-output +17100 1/imm32/r32-is-first-inout +17101 0/imm32/no-imm32 +17102 0/imm32/no-imm8 +17103 0/imm32/no-disp32 +17104 1/imm32/output-is-write-only +17105 0x11/imm32/alloc-id:fake +17106 _Primitive-copy-reg-to-mem/imm32/next +17107 _Primitive-copy-reg-to-mem: # (payload primitive) +17108 0x11/imm32/alloc-id:fake:payload +17109 # copy-to var1 var2/reg => 89/<- var1 var2/r32 +17110 0x11/imm32/alloc-id:fake +17111 _string-copy-to/imm32/name +17112 0x11/imm32/alloc-id:fake +17113 Two-args-int-stack-int-reg/imm32/inouts 17114 0/imm32/no-outputs -17115 0x11/imm32/alloc-id:fake -17116 _string_39_compare->/imm32/subx-name -17117 1/imm32/rm32-is-first-inout -17118 2/imm32/r32-is-second-inout -17119 0/imm32/no-imm32 -17120 0/imm32/no-imm8 -17121 0/imm32/no-disp32 -17122 0/imm32/output-is-write-only -17123 0x11/imm32/alloc-id:fake -17124 _Primitive-compare-mem-with-reg/imm32/next -17125 _Primitive-compare-mem-with-reg: # (payload primitive) -17126 0x11/imm32/alloc-id:fake:payload -17127 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 -17128 0x11/imm32/alloc-id:fake -17129 _string-compare/imm32/name -17130 0x11/imm32/alloc-id:fake -17131 Two-args-int-stack-int-reg/imm32/inouts -17132 0/imm32/no-outputs -17133 0/imm32/no-outputs -17134 0x11/imm32/alloc-id:fake -17135 _string_39_compare->/imm32/subx-name -17136 1/imm32/rm32-is-first-inout -17137 2/imm32/r32-is-second-inout -17138 0/imm32/no-imm32 -17139 0/imm32/no-imm8 -17140 0/imm32/no-disp32 -17141 0/imm32/output-is-write-only -17142 0x11/imm32/alloc-id:fake -17143 _Primitive-compare-reg-with-mem/imm32/next -17144 _Primitive-compare-reg-with-mem: # (payload primitive) -17145 0x11/imm32/alloc-id:fake:payload -17146 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 -17147 0x11/imm32/alloc-id:fake -17148 _string-compare/imm32/name -17149 0x11/imm32/alloc-id:fake -17150 Two-args-int-reg-int-stack/imm32/inouts -17151 0/imm32/no-outputs -17152 0/imm32/no-outputs -17153 0x11/imm32/alloc-id:fake -17154 _string_3b_compare<-/imm32/subx-name -17155 2/imm32/rm32-is-second-inout -17156 1/imm32/r32-is-first-inout -17157 0/imm32/no-imm32 -17158 0/imm32/no-imm8 -17159 0/imm32/no-disp32 -17160 0/imm32/output-is-write-only -17161 0x11/imm32/alloc-id:fake -17162 _Primitive-compare-eax-with-literal/imm32/next -17163 _Primitive-compare-eax-with-literal: # (payload primitive) -17164 0x11/imm32/alloc-id:fake:payload -17165 # compare var1/eax n => 3d/compare-eax-with n/imm32 -17166 0x11/imm32/alloc-id:fake -17167 _string-compare/imm32/name -17168 0x11/imm32/alloc-id:fake -17169 Two-args-int-eax-int-literal/imm32/inouts -17170 0/imm32/no-outputs +17115 0/imm32/no-outputs +17116 0x11/imm32/alloc-id:fake +17117 _string_89_<-/imm32/subx-name +17118 1/imm32/rm32-is-first-inout +17119 2/imm32/r32-is-second-inout +17120 0/imm32/no-imm32 +17121 0/imm32/no-imm8 +17122 0/imm32/no-disp32 +17123 1/imm32/output-is-write-only +17124 0x11/imm32/alloc-id:fake +17125 _Primitive-copy-mem-to-reg/imm32/next +17126 _Primitive-copy-mem-to-reg: # (payload primitive) +17127 0x11/imm32/alloc-id:fake:payload +17128 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 +17129 0x11/imm32/alloc-id:fake +17130 _string-copy/imm32/name +17131 0x11/imm32/alloc-id:fake +17132 Single-int-var-in-mem/imm32/inouts +17133 0x11/imm32/alloc-id:fake +17134 Single-int-var-in-some-register/imm32/outputs +17135 0x11/imm32/alloc-id:fake +17136 _string_8b_->/imm32/subx-name +17137 1/imm32/rm32-is-first-inout +17138 3/imm32/r32-is-first-output +17139 0/imm32/no-imm32 +17140 0/imm32/no-imm8 +17141 0/imm32/no-disp32 +17142 1/imm32/output-is-write-only +17143 0x11/imm32/alloc-id:fake +17144 _Primitive-copy-lit-to-reg/imm32/next +17145 _Primitive-copy-lit-to-reg: # (payload primitive) +17146 0x11/imm32/alloc-id:fake:payload +17147 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 +17148 0x11/imm32/alloc-id:fake +17149 _string-copy/imm32/name +17150 0x11/imm32/alloc-id:fake +17151 Single-lit-var/imm32/inouts +17152 0x11/imm32/alloc-id:fake +17153 Single-int-var-in-some-register/imm32/outputs +17154 0x11/imm32/alloc-id:fake +17155 _string_c7_subop_copy/imm32/subx-name +17156 3/imm32/rm32-is-first-output +17157 0/imm32/no-r32 +17158 1/imm32/imm32-is-first-inout +17159 0/imm32/no-imm8 +17160 0/imm32/no-disp32 +17161 1/imm32/output-is-write-only +17162 0x11/imm32/alloc-id:fake +17163 _Primitive-copy-lit-to-mem/imm32/next +17164 _Primitive-copy-lit-to-mem: # (payload primitive) +17165 0x11/imm32/alloc-id:fake:payload +17166 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 +17167 0x11/imm32/alloc-id:fake +17168 _string-copy-to/imm32/name +17169 0x11/imm32/alloc-id:fake +17170 Int-var-and-literal/imm32/inouts 17171 0/imm32/no-outputs -17172 0x11/imm32/alloc-id:fake -17173 _string_3d_compare_eax_with/imm32/subx-name -17174 0/imm32/no-rm32 -17175 0/imm32/no-r32 -17176 2/imm32/imm32-is-second-inout -17177 0/imm32/no-imm8 -17178 0/imm32/no-disp32 -17179 0/imm32/output-is-write-only -17180 0x11/imm32/alloc-id:fake -17181 _Primitive-compare-reg-with-literal/imm32/next -17182 _Primitive-compare-reg-with-literal: # (payload primitive) -17183 0x11/imm32/alloc-id:fake:payload -17184 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 -17185 0x11/imm32/alloc-id:fake -17186 _string-compare/imm32/name +17172 0/imm32/no-outputs +17173 0x11/imm32/alloc-id:fake +17174 _string_c7_subop_copy/imm32/subx-name +17175 1/imm32/rm32-is-first-inout +17176 0/imm32/no-r32 +17177 2/imm32/imm32-is-second-inout +17178 0/imm32/no-imm8 +17179 0/imm32/no-disp32 +17180 1/imm32/output-is-write-only +17181 0x11/imm32/alloc-id:fake +17182 _Primitive-copy-byte-from-reg/imm32/next +17183 # - copy byte +17184 _Primitive-copy-byte-from-reg: +17185 0x11/imm32/alloc-id:fake:payload +17186 # var/reg <- copy-byte var2/reg2 => 8a/byte-> %var2 var/r32 17187 0x11/imm32/alloc-id:fake -17188 Int-var-in-register-and-literal/imm32/inouts -17189 0/imm32/no-outputs -17190 0/imm32/no-outputs +17188 _string-copy-byte/imm32/name +17189 0x11/imm32/alloc-id:fake +17190 Single-byte-var-in-some-register/imm32/inouts 17191 0x11/imm32/alloc-id:fake -17192 _string_81_subop_compare/imm32/subx-name -17193 1/imm32/rm32-is-first-inout -17194 0/imm32/no-r32 -17195 2/imm32/imm32-is-second-inout -17196 0/imm32/no-imm8 -17197 0/imm32/no-disp32 -17198 0/imm32/output-is-write-only -17199 0x11/imm32/alloc-id:fake -17200 _Primitive-compare-mem-with-literal/imm32/next -17201 _Primitive-compare-mem-with-literal: # (payload primitive) -17202 0x11/imm32/alloc-id:fake:payload -17203 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 -17204 0x11/imm32/alloc-id:fake -17205 _string-compare/imm32/name +17192 Single-byte-var-in-some-register/imm32/outputs +17193 0x11/imm32/alloc-id:fake +17194 _string_8a_copy_byte/imm32/subx-name +17195 1/imm32/rm32-is-first-inout +17196 3/imm32/r32-is-first-output +17197 0/imm32/no-imm32 +17198 0/imm32/no-imm8 +17199 0/imm32/no-disp32 +17200 1/imm32/output-is-write-only +17201 0x11/imm32/alloc-id:fake +17202 _Primitive-copy-byte-from-mem/imm32/next +17203 _Primitive-copy-byte-from-mem: +17204 0x11/imm32/alloc-id:fake:payload +17205 # var/reg <- copy-byte *var2/reg2 => 8a/byte-> *var2 var/r32 17206 0x11/imm32/alloc-id:fake -17207 Int-var-and-literal/imm32/inouts -17208 0/imm32/no-outputs -17209 0/imm32/no-outputs +17207 _string-copy-byte/imm32/name +17208 0x11/imm32/alloc-id:fake +17209 Single-byte-var-in-mem/imm32/inouts 17210 0x11/imm32/alloc-id:fake -17211 _string_81_subop_compare/imm32/subx-name -17212 1/imm32/rm32-is-first-inout -17213 0/imm32/no-r32 -17214 2/imm32/imm32-is-second-inout -17215 0/imm32/no-imm8 -17216 0/imm32/no-disp32 -17217 0/imm32/output-is-write-only -17218 0x11/imm32/alloc-id:fake -17219 _Primitive-multiply-reg-by-reg/imm32/next -17220 # - multiply -17221 _Primitive-multiply-reg-by-reg: # (payload primitive) -17222 0x11/imm32/alloc-id:fake:payload -17223 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 -17224 0x11/imm32/alloc-id:fake -17225 _string-multiply/imm32/name -17226 0x11/imm32/alloc-id:fake -17227 Single-int-var-in-some-register/imm32/inouts -17228 0x11/imm32/alloc-id:fake -17229 Single-int-var-in-some-register/imm32/outputs -17230 0x11/imm32/alloc-id:fake -17231 _string_0f_af_multiply/imm32/subx-name -17232 1/imm32/rm32-is-first-inout -17233 3/imm32/r32-is-first-output -17234 0/imm32/no-imm32 -17235 0/imm32/no-imm8 -17236 0/imm32/no-disp32 -17237 0/imm32/output-is-write-only -17238 0x11/imm32/alloc-id:fake -17239 _Primitive-multiply-reg-by-mem/imm32/next -17240 _Primitive-multiply-reg-by-mem: # (payload primitive) -17241 0x11/imm32/alloc-id:fake:payload -17242 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 -17243 0x11/imm32/alloc-id:fake -17244 _string-multiply/imm32/name +17211 Single-byte-var-in-some-register/imm32/outputs +17212 0x11/imm32/alloc-id:fake +17213 _string_8a_copy_byte/imm32/subx-name +17214 1/imm32/rm32-is-first-inout +17215 3/imm32/r32-is-first-output +17216 0/imm32/no-imm32 +17217 0/imm32/no-imm8 +17218 0/imm32/no-disp32 +17219 1/imm32/output-is-write-only +17220 0x11/imm32/alloc-id:fake +17221 _Primitive-copy-byte-to-mem/imm32/next +17222 _Primitive-copy-byte-to-mem: +17223 0x11/imm32/alloc-id:fake:payload +17224 # copy-byte-to *var1/reg1, var2/reg2 => 88/byte<- *reg1 reg2/r32 +17225 0x11/imm32/alloc-id:fake +17226 _string-copy-byte-to/imm32/name +17227 0x11/imm32/alloc-id:fake +17228 Two-args-byte-stack-byte-reg/imm32/inouts +17229 0/imm32/no-outputs +17230 0/imm32/no-outputs +17231 0x11/imm32/alloc-id:fake +17232 _string_88_copy_byte/imm32/subx-name +17233 1/imm32/rm32-is-first-inout +17234 2/imm32/r32-is-second-inout +17235 0/imm32/no-imm32 +17236 0/imm32/no-imm8 +17237 0/imm32/no-disp32 +17238 0/imm32/output-is-write-only +17239 0x11/imm32/alloc-id:fake +17240 _Primitive-address/imm32/next +17241 # - address +17242 _Primitive-address: # (payload primitive) +17243 0x11/imm32/alloc-id:fake:payload +17244 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 17245 0x11/imm32/alloc-id:fake -17246 Single-int-var-in-mem/imm32/inouts +17246 _string-address/imm32/name 17247 0x11/imm32/alloc-id:fake -17248 Single-int-var-in-some-register/imm32/outputs +17248 Single-int-var-in-mem/imm32/inouts 17249 0x11/imm32/alloc-id:fake -17250 _string_0f_af_multiply/imm32/subx-name -17251 1/imm32/rm32-is-first-inout -17252 3/imm32/r32-is-first-output -17253 0/imm32/no-imm32 -17254 0/imm32/no-imm8 -17255 0/imm32/no-disp32 -17256 0/imm32/output-is-write-only -17257 0x11/imm32/alloc-id:fake -17258 _Primitive-break-if-addr</imm32/next -17259 # - branches -17260 _Primitive-break-if-addr<: # (payload primitive) -17261 0x11/imm32/alloc-id:fake:payload -17262 0x11/imm32/alloc-id:fake -17263 _string-break-if-addr</imm32/name -17264 0/imm32/no-inouts -17265 0/imm32/no-inouts -17266 0/imm32/no-outputs -17267 0/imm32/no-outputs -17268 0x11/imm32/alloc-id:fake -17269 _string_0f_82_jump_break/imm32/subx-name -17270 0/imm32/no-rm32 -17271 0/imm32/no-r32 -17272 0/imm32/no-imm32 -17273 0/imm32/no-imm8 -17274 0/imm32/no-disp32 -17275 0/imm32/no-output -17276 0x11/imm32/alloc-id:fake -17277 _Primitive-break-if-addr>=/imm32/next -17278 _Primitive-break-if-addr>=: # (payload primitive) -17279 0x11/imm32/alloc-id:fake:payload -17280 0x11/imm32/alloc-id:fake -17281 _string-break-if-addr>=/imm32/name -17282 0/imm32/no-inouts -17283 0/imm32/no-inouts -17284 0/imm32/no-outputs -17285 0/imm32/no-outputs +17250 Single-addr-var-in-some-register/imm32/outputs +17251 0x11/imm32/alloc-id:fake +17252 _string_8d_copy_address/imm32/subx-name +17253 1/imm32/rm32-is-first-inout +17254 3/imm32/r32-is-first-output +17255 0/imm32/no-imm32 +17256 0/imm32/no-imm8 +17257 0/imm32/no-disp32 +17258 1/imm32/output-is-write-only +17259 0x11/imm32/alloc-id:fake +17260 _Primitive-compare-reg-with-reg/imm32/next +17261 # - compare +17262 _Primitive-compare-reg-with-reg: # (payload primitive) +17263 0x11/imm32/alloc-id:fake:payload +17264 # compare var1/reg1 var2/reg2 => 39/compare var1/rm32 var2/r32 +17265 0x11/imm32/alloc-id:fake +17266 _string-compare/imm32/name +17267 0x11/imm32/alloc-id:fake +17268 Two-int-args-in-regs/imm32/inouts +17269 0/imm32/no-outputs +17270 0/imm32/no-outputs +17271 0x11/imm32/alloc-id:fake +17272 _string_39_compare->/imm32/subx-name +17273 1/imm32/rm32-is-first-inout +17274 2/imm32/r32-is-second-inout +17275 0/imm32/no-imm32 +17276 0/imm32/no-imm8 +17277 0/imm32/no-disp32 +17278 0/imm32/output-is-write-only +17279 0x11/imm32/alloc-id:fake +17280 _Primitive-compare-mem-with-reg/imm32/next +17281 _Primitive-compare-mem-with-reg: # (payload primitive) +17282 0x11/imm32/alloc-id:fake:payload +17283 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 +17284 0x11/imm32/alloc-id:fake +17285 _string-compare/imm32/name 17286 0x11/imm32/alloc-id:fake -17287 _string_0f_83_jump_break/imm32/subx-name -17288 0/imm32/no-rm32 -17289 0/imm32/no-r32 -17290 0/imm32/no-imm32 -17291 0/imm32/no-imm8 -17292 0/imm32/no-disp32 -17293 0/imm32/no-output -17294 0x11/imm32/alloc-id:fake -17295 _Primitive-break-if-=/imm32/next -17296 _Primitive-break-if-=: # (payload primitive) -17297 0x11/imm32/alloc-id:fake:payload +17287 Two-args-int-stack-int-reg/imm32/inouts +17288 0/imm32/no-outputs +17289 0/imm32/no-outputs +17290 0x11/imm32/alloc-id:fake +17291 _string_39_compare->/imm32/subx-name +17292 1/imm32/rm32-is-first-inout +17293 2/imm32/r32-is-second-inout +17294 0/imm32/no-imm32 +17295 0/imm32/no-imm8 +17296 0/imm32/no-disp32 +17297 0/imm32/output-is-write-only 17298 0x11/imm32/alloc-id:fake -17299 _string-break-if-=/imm32/name -17300 0/imm32/no-inouts -17301 0/imm32/no-inouts -17302 0/imm32/no-outputs -17303 0/imm32/no-outputs -17304 0x11/imm32/alloc-id:fake -17305 _string_0f_84_jump_break/imm32/subx-name -17306 0/imm32/no-rm32 -17307 0/imm32/no-r32 -17308 0/imm32/no-imm32 -17309 0/imm32/no-imm8 -17310 0/imm32/no-disp32 -17311 0/imm32/no-output -17312 0x11/imm32/alloc-id:fake -17313 _Primitive-break-if-!=/imm32/next -17314 _Primitive-break-if-!=: # (payload primitive) -17315 0x11/imm32/alloc-id:fake:payload -17316 0x11/imm32/alloc-id:fake -17317 _string-break-if-!=/imm32/name -17318 0/imm32/no-inouts -17319 0/imm32/no-inouts -17320 0/imm32/no-outputs -17321 0/imm32/no-outputs +17299 _Primitive-compare-reg-with-mem/imm32/next +17300 _Primitive-compare-reg-with-mem: # (payload primitive) +17301 0x11/imm32/alloc-id:fake:payload +17302 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 +17303 0x11/imm32/alloc-id:fake +17304 _string-compare/imm32/name +17305 0x11/imm32/alloc-id:fake +17306 Two-args-int-reg-int-stack/imm32/inouts +17307 0/imm32/no-outputs +17308 0/imm32/no-outputs +17309 0x11/imm32/alloc-id:fake +17310 _string_3b_compare<-/imm32/subx-name +17311 2/imm32/rm32-is-second-inout +17312 1/imm32/r32-is-first-inout +17313 0/imm32/no-imm32 +17314 0/imm32/no-imm8 +17315 0/imm32/no-disp32 +17316 0/imm32/output-is-write-only +17317 0x11/imm32/alloc-id:fake +17318 _Primitive-compare-eax-with-literal/imm32/next +17319 _Primitive-compare-eax-with-literal: # (payload primitive) +17320 0x11/imm32/alloc-id:fake:payload +17321 # compare var1/eax n => 3d/compare-eax-with n/imm32 17322 0x11/imm32/alloc-id:fake -17323 _string_0f_85_jump_break/imm32/subx-name -17324 0/imm32/no-rm32 -17325 0/imm32/no-r32 -17326 0/imm32/no-imm32 -17327 0/imm32/no-imm8 -17328 0/imm32/no-disp32 -17329 0/imm32/no-output -17330 0x11/imm32/alloc-id:fake -17331 _Primitive-break-if-addr<=/imm32/next -17332 _Primitive-break-if-addr<=: # (payload primitive) -17333 0x11/imm32/alloc-id:fake:payload -17334 0x11/imm32/alloc-id:fake -17335 _string-break-if-addr<=/imm32/name -17336 0/imm32/no-inouts -17337 0/imm32/no-inouts -17338 0/imm32/no-outputs -17339 0/imm32/no-outputs -17340 0x11/imm32/alloc-id:fake -17341 _string_0f_86_jump_break/imm32/subx-name -17342 0/imm32/no-rm32 -17343 0/imm32/no-r32 -17344 0/imm32/no-imm32 -17345 0/imm32/no-imm8 -17346 0/imm32/no-disp32 -17347 0/imm32/no-output -17348 0x11/imm32/alloc-id:fake -17349 _Primitive-break-if-addr>/imm32/next -17350 _Primitive-break-if-addr>: # (payload primitive) -17351 0x11/imm32/alloc-id:fake:payload -17352 0x11/imm32/alloc-id:fake -17353 _string-break-if-addr>/imm32/name -17354 0/imm32/no-inouts -17355 0/imm32/no-inouts -17356 0/imm32/no-outputs -17357 0/imm32/no-outputs -17358 0x11/imm32/alloc-id:fake -17359 _string_0f_87_jump_break/imm32/subx-name -17360 0/imm32/no-rm32 -17361 0/imm32/no-r32 -17362 0/imm32/no-imm32 -17363 0/imm32/no-imm8 -17364 0/imm32/no-disp32 -17365 0/imm32/no-output +17323 _string-compare/imm32/name +17324 0x11/imm32/alloc-id:fake +17325 Two-args-int-eax-int-literal/imm32/inouts +17326 0/imm32/no-outputs +17327 0/imm32/no-outputs +17328 0x11/imm32/alloc-id:fake +17329 _string_3d_compare_eax_with/imm32/subx-name +17330 0/imm32/no-rm32 +17331 0/imm32/no-r32 +17332 2/imm32/imm32-is-second-inout +17333 0/imm32/no-imm8 +17334 0/imm32/no-disp32 +17335 0/imm32/output-is-write-only +17336 0x11/imm32/alloc-id:fake +17337 _Primitive-compare-reg-with-literal/imm32/next +17338 _Primitive-compare-reg-with-literal: # (payload primitive) +17339 0x11/imm32/alloc-id:fake:payload +17340 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 +17341 0x11/imm32/alloc-id:fake +17342 _string-compare/imm32/name +17343 0x11/imm32/alloc-id:fake +17344 Int-var-in-register-and-literal/imm32/inouts +17345 0/imm32/no-outputs +17346 0/imm32/no-outputs +17347 0x11/imm32/alloc-id:fake +17348 _string_81_subop_compare/imm32/subx-name +17349 1/imm32/rm32-is-first-inout +17350 0/imm32/no-r32 +17351 2/imm32/imm32-is-second-inout +17352 0/imm32/no-imm8 +17353 0/imm32/no-disp32 +17354 0/imm32/output-is-write-only +17355 0x11/imm32/alloc-id:fake +17356 _Primitive-compare-mem-with-literal/imm32/next +17357 _Primitive-compare-mem-with-literal: # (payload primitive) +17358 0x11/imm32/alloc-id:fake:payload +17359 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 +17360 0x11/imm32/alloc-id:fake +17361 _string-compare/imm32/name +17362 0x11/imm32/alloc-id:fake +17363 Int-var-and-literal/imm32/inouts +17364 0/imm32/no-outputs +17365 0/imm32/no-outputs 17366 0x11/imm32/alloc-id:fake -17367 _Primitive-break-if-</imm32/next -17368 _Primitive-break-if-<: # (payload primitive) -17369 0x11/imm32/alloc-id:fake:payload -17370 0x11/imm32/alloc-id:fake -17371 _string-break-if-</imm32/name -17372 0/imm32/no-inouts -17373 0/imm32/no-inouts -17374 0/imm32/no-outputs -17375 0/imm32/no-outputs -17376 0x11/imm32/alloc-id:fake -17377 _string_0f_8c_jump_break/imm32/subx-name -17378 0/imm32/no-rm32 -17379 0/imm32/no-r32 -17380 0/imm32/no-imm32 -17381 0/imm32/no-imm8 -17382 0/imm32/no-disp32 -17383 0/imm32/no-output +17367 _string_81_subop_compare/imm32/subx-name +17368 1/imm32/rm32-is-first-inout +17369 0/imm32/no-r32 +17370 2/imm32/imm32-is-second-inout +17371 0/imm32/no-imm8 +17372 0/imm32/no-disp32 +17373 0/imm32/output-is-write-only +17374 0x11/imm32/alloc-id:fake +17375 _Primitive-multiply-reg-by-reg/imm32/next +17376 # - multiply +17377 _Primitive-multiply-reg-by-reg: # (payload primitive) +17378 0x11/imm32/alloc-id:fake:payload +17379 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +17380 0x11/imm32/alloc-id:fake +17381 _string-multiply/imm32/name +17382 0x11/imm32/alloc-id:fake +17383 Single-int-var-in-some-register/imm32/inouts 17384 0x11/imm32/alloc-id:fake -17385 _Primitive-break-if->=/imm32/next -17386 _Primitive-break-if->=: # (payload primitive) -17387 0x11/imm32/alloc-id:fake:payload -17388 0x11/imm32/alloc-id:fake -17389 _string-break-if->=/imm32/name -17390 0/imm32/no-inouts -17391 0/imm32/no-inouts -17392 0/imm32/no-outputs -17393 0/imm32/no-outputs +17385 Single-int-var-in-some-register/imm32/outputs +17386 0x11/imm32/alloc-id:fake +17387 _string_0f_af_multiply/imm32/subx-name +17388 1/imm32/rm32-is-first-inout +17389 3/imm32/r32-is-first-output +17390 0/imm32/no-imm32 +17391 0/imm32/no-imm8 +17392 0/imm32/no-disp32 +17393 0/imm32/output-is-write-only 17394 0x11/imm32/alloc-id:fake -17395 _string_0f_8d_jump_break/imm32/subx-name -17396 0/imm32/no-rm32 -17397 0/imm32/no-r32 -17398 0/imm32/no-imm32 -17399 0/imm32/no-imm8 -17400 0/imm32/no-disp32 -17401 0/imm32/no-output -17402 0x11/imm32/alloc-id:fake -17403 _Primitive-break-if-<=/imm32/next -17404 _Primitive-break-if-<=: # (payload primitive) -17405 0x11/imm32/alloc-id:fake:payload -17406 0x11/imm32/alloc-id:fake -17407 _string-break-if-<=/imm32/name -17408 0/imm32/no-inouts -17409 0/imm32/no-inouts -17410 0/imm32/no-outputs -17411 0/imm32/no-outputs -17412 0x11/imm32/alloc-id:fake -17413 _string_0f_8e_jump_break/imm32/subx-name -17414 0/imm32/no-rm32 -17415 0/imm32/no-r32 -17416 0/imm32/no-imm32 -17417 0/imm32/no-imm8 -17418 0/imm32/no-disp32 -17419 0/imm32/no-output -17420 0x11/imm32/alloc-id:fake -17421 _Primitive-break-if->/imm32/next -17422 _Primitive-break-if->: # (payload primitive) -17423 0x11/imm32/alloc-id:fake:payload +17395 _Primitive-multiply-reg-by-mem/imm32/next +17396 _Primitive-multiply-reg-by-mem: # (payload primitive) +17397 0x11/imm32/alloc-id:fake:payload +17398 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +17399 0x11/imm32/alloc-id:fake +17400 _string-multiply/imm32/name +17401 0x11/imm32/alloc-id:fake +17402 Single-int-var-in-mem/imm32/inouts +17403 0x11/imm32/alloc-id:fake +17404 Single-int-var-in-some-register/imm32/outputs +17405 0x11/imm32/alloc-id:fake +17406 _string_0f_af_multiply/imm32/subx-name +17407 1/imm32/rm32-is-first-inout +17408 3/imm32/r32-is-first-output +17409 0/imm32/no-imm32 +17410 0/imm32/no-imm8 +17411 0/imm32/no-disp32 +17412 0/imm32/output-is-write-only +17413 0x11/imm32/alloc-id:fake +17414 _Primitive-break-if-addr</imm32/next +17415 # - branches +17416 _Primitive-break-if-addr<: # (payload primitive) +17417 0x11/imm32/alloc-id:fake:payload +17418 0x11/imm32/alloc-id:fake +17419 _string-break-if-addr</imm32/name +17420 0/imm32/no-inouts +17421 0/imm32/no-inouts +17422 0/imm32/no-outputs +17423 0/imm32/no-outputs 17424 0x11/imm32/alloc-id:fake -17425 _string-break-if->/imm32/name -17426 0/imm32/no-inouts -17427 0/imm32/no-inouts -17428 0/imm32/no-outputs -17429 0/imm32/no-outputs -17430 0x11/imm32/alloc-id:fake -17431 _string_0f_8f_jump_break/imm32/subx-name -17432 0/imm32/no-rm32 -17433 0/imm32/no-r32 -17434 0/imm32/no-imm32 -17435 0/imm32/no-imm8 -17436 0/imm32/no-disp32 -17437 0/imm32/no-output -17438 0x11/imm32/alloc-id:fake -17439 _Primitive-break/imm32/next -17440 _Primitive-break: # (payload primitive) -17441 0x11/imm32/alloc-id:fake:payload +17425 _string_0f_82_jump_break/imm32/subx-name +17426 0/imm32/no-rm32 +17427 0/imm32/no-r32 +17428 0/imm32/no-imm32 +17429 0/imm32/no-imm8 +17430 0/imm32/no-disp32 +17431 0/imm32/no-output +17432 0x11/imm32/alloc-id:fake +17433 _Primitive-break-if-addr>=/imm32/next +17434 _Primitive-break-if-addr>=: # (payload primitive) +17435 0x11/imm32/alloc-id:fake:payload +17436 0x11/imm32/alloc-id:fake +17437 _string-break-if-addr>=/imm32/name +17438 0/imm32/no-inouts +17439 0/imm32/no-inouts +17440 0/imm32/no-outputs +17441 0/imm32/no-outputs 17442 0x11/imm32/alloc-id:fake -17443 _string-break/imm32/name -17444 0/imm32/no-inouts -17445 0/imm32/no-inouts -17446 0/imm32/no-outputs -17447 0/imm32/no-outputs -17448 0x11/imm32/alloc-id:fake -17449 _string_e9_jump_break/imm32/subx-name -17450 0/imm32/no-rm32 -17451 0/imm32/no-r32 -17452 0/imm32/no-imm32 -17453 0/imm32/no-imm8 -17454 0/imm32/no-disp32 -17455 0/imm32/no-output -17456 0x11/imm32/alloc-id:fake -17457 _Primitive-loop-if-addr</imm32/next -17458 _Primitive-loop-if-addr<: # (payload primitive) -17459 0x11/imm32/alloc-id:fake:payload +17443 _string_0f_83_jump_break/imm32/subx-name +17444 0/imm32/no-rm32 +17445 0/imm32/no-r32 +17446 0/imm32/no-imm32 +17447 0/imm32/no-imm8 +17448 0/imm32/no-disp32 +17449 0/imm32/no-output +17450 0x11/imm32/alloc-id:fake +17451 _Primitive-break-if-=/imm32/next +17452 _Primitive-break-if-=: # (payload primitive) +17453 0x11/imm32/alloc-id:fake:payload +17454 0x11/imm32/alloc-id:fake +17455 _string-break-if-=/imm32/name +17456 0/imm32/no-inouts +17457 0/imm32/no-inouts +17458 0/imm32/no-outputs +17459 0/imm32/no-outputs 17460 0x11/imm32/alloc-id:fake -17461 _string-loop-if-addr</imm32/name -17462 0/imm32/no-inouts -17463 0/imm32/no-inouts -17464 0/imm32/no-outputs -17465 0/imm32/no-outputs -17466 0x11/imm32/alloc-id:fake -17467 _string_0f_82_jump_loop/imm32/subx-name -17468 0/imm32/no-rm32 -17469 0/imm32/no-r32 -17470 0/imm32/no-imm32 -17471 0/imm32/no-imm8 -17472 0/imm32/no-disp32 -17473 0/imm32/no-output -17474 0x11/imm32/alloc-id:fake -17475 _Primitive-loop-if-addr>=/imm32/next -17476 _Primitive-loop-if-addr>=: # (payload primitive) -17477 0x11/imm32/alloc-id:fake:payload +17461 _string_0f_84_jump_break/imm32/subx-name +17462 0/imm32/no-rm32 +17463 0/imm32/no-r32 +17464 0/imm32/no-imm32 +17465 0/imm32/no-imm8 +17466 0/imm32/no-disp32 +17467 0/imm32/no-output +17468 0x11/imm32/alloc-id:fake +17469 _Primitive-break-if-!=/imm32/next +17470 _Primitive-break-if-!=: # (payload primitive) +17471 0x11/imm32/alloc-id:fake:payload +17472 0x11/imm32/alloc-id:fake +17473 _string-break-if-!=/imm32/name +17474 0/imm32/no-inouts +17475 0/imm32/no-inouts +17476 0/imm32/no-outputs +17477 0/imm32/no-outputs 17478 0x11/imm32/alloc-id:fake -17479 _string-loop-if-addr>=/imm32/name -17480 0/imm32/no-inouts -17481 0/imm32/no-inouts -17482 0/imm32/no-outputs -17483 0/imm32/no-outputs -17484 0x11/imm32/alloc-id:fake -17485 _string_0f_83_jump_loop/imm32/subx-name -17486 0/imm32/no-rm32 -17487 0/imm32/no-r32 -17488 0/imm32/no-imm32 -17489 0/imm32/no-imm8 -17490 0/imm32/no-disp32 -17491 0/imm32/no-output -17492 0x11/imm32/alloc-id:fake -17493 _Primitive-loop-if-=/imm32/next -17494 _Primitive-loop-if-=: # (payload primitive) -17495 0x11/imm32/alloc-id:fake:payload +17479 _string_0f_85_jump_break/imm32/subx-name +17480 0/imm32/no-rm32 +17481 0/imm32/no-r32 +17482 0/imm32/no-imm32 +17483 0/imm32/no-imm8 +17484 0/imm32/no-disp32 +17485 0/imm32/no-output +17486 0x11/imm32/alloc-id:fake +17487 _Primitive-break-if-addr<=/imm32/next +17488 _Primitive-break-if-addr<=: # (payload primitive) +17489 0x11/imm32/alloc-id:fake:payload +17490 0x11/imm32/alloc-id:fake +17491 _string-break-if-addr<=/imm32/name +17492 0/imm32/no-inouts +17493 0/imm32/no-inouts +17494 0/imm32/no-outputs +17495 0/imm32/no-outputs 17496 0x11/imm32/alloc-id:fake -17497 _string-loop-if-=/imm32/name -17498 0/imm32/no-inouts -17499 0/imm32/no-inouts -17500 0/imm32/no-outputs -17501 0/imm32/no-outputs -17502 0x11/imm32/alloc-id:fake -17503 _string_0f_84_jump_loop/imm32/subx-name -17504 0/imm32/no-rm32 -17505 0/imm32/no-r32 -17506 0/imm32/no-imm32 -17507 0/imm32/no-imm8 -17508 0/imm32/no-disp32 -17509 0/imm32/no-output -17510 0x11/imm32/alloc-id:fake -17511 _Primitive-loop-if-!=/imm32/next -17512 _Primitive-loop-if-!=: # (payload primitive) -17513 0x11/imm32/alloc-id:fake:payload +17497 _string_0f_86_jump_break/imm32/subx-name +17498 0/imm32/no-rm32 +17499 0/imm32/no-r32 +17500 0/imm32/no-imm32 +17501 0/imm32/no-imm8 +17502 0/imm32/no-disp32 +17503 0/imm32/no-output +17504 0x11/imm32/alloc-id:fake +17505 _Primitive-break-if-addr>/imm32/next +17506 _Primitive-break-if-addr>: # (payload primitive) +17507 0x11/imm32/alloc-id:fake:payload +17508 0x11/imm32/alloc-id:fake +17509 _string-break-if-addr>/imm32/name +17510 0/imm32/no-inouts +17511 0/imm32/no-inouts +17512 0/imm32/no-outputs +17513 0/imm32/no-outputs 17514 0x11/imm32/alloc-id:fake -17515 _string-loop-if-!=/imm32/name -17516 0/imm32/no-inouts -17517 0/imm32/no-inouts -17518 0/imm32/no-outputs -17519 0/imm32/no-outputs -17520 0x11/imm32/alloc-id:fake -17521 _string_0f_85_jump_loop/imm32/subx-name -17522 0/imm32/no-rm32 -17523 0/imm32/no-r32 -17524 0/imm32/no-imm32 -17525 0/imm32/no-imm8 -17526 0/imm32/no-disp32 -17527 0/imm32/no-output -17528 0x11/imm32/alloc-id:fake -17529 _Primitive-loop-if-addr<=/imm32/next -17530 _Primitive-loop-if-addr<=: # (payload primitive) -17531 0x11/imm32/alloc-id:fake:payload +17515 _string_0f_87_jump_break/imm32/subx-name +17516 0/imm32/no-rm32 +17517 0/imm32/no-r32 +17518 0/imm32/no-imm32 +17519 0/imm32/no-imm8 +17520 0/imm32/no-disp32 +17521 0/imm32/no-output +17522 0x11/imm32/alloc-id:fake +17523 _Primitive-break-if-</imm32/next +17524 _Primitive-break-if-<: # (payload primitive) +17525 0x11/imm32/alloc-id:fake:payload +17526 0x11/imm32/alloc-id:fake +17527 _string-break-if-</imm32/name +17528 0/imm32/no-inouts +17529 0/imm32/no-inouts +17530 0/imm32/no-outputs +17531 0/imm32/no-outputs 17532 0x11/imm32/alloc-id:fake -17533 _string-loop-if-addr<=/imm32/name -17534 0/imm32/no-inouts -17535 0/imm32/no-inouts -17536 0/imm32/no-outputs -17537 0/imm32/no-outputs -17538 0x11/imm32/alloc-id:fake -17539 _string_0f_86_jump_loop/imm32/subx-name -17540 0/imm32/no-rm32 -17541 0/imm32/no-r32 -17542 0/imm32/no-imm32 -17543 0/imm32/no-imm8 -17544 0/imm32/no-disp32 -17545 0/imm32/no-output -17546 0x11/imm32/alloc-id:fake -17547 _Primitive-loop-if-addr>/imm32/next -17548 _Primitive-loop-if-addr>: # (payload primitive) -17549 0x11/imm32/alloc-id:fake:payload +17533 _string_0f_8c_jump_break/imm32/subx-name +17534 0/imm32/no-rm32 +17535 0/imm32/no-r32 +17536 0/imm32/no-imm32 +17537 0/imm32/no-imm8 +17538 0/imm32/no-disp32 +17539 0/imm32/no-output +17540 0x11/imm32/alloc-id:fake +17541 _Primitive-break-if->=/imm32/next +17542 _Primitive-break-if->=: # (payload primitive) +17543 0x11/imm32/alloc-id:fake:payload +17544 0x11/imm32/alloc-id:fake +17545 _string-break-if->=/imm32/name +17546 0/imm32/no-inouts +17547 0/imm32/no-inouts +17548 0/imm32/no-outputs +17549 0/imm32/no-outputs 17550 0x11/imm32/alloc-id:fake -17551 _string-loop-if-addr>/imm32/name -17552 0/imm32/no-inouts -17553 0/imm32/no-inouts -17554 0/imm32/no-outputs -17555 0/imm32/no-outputs -17556 0x11/imm32/alloc-id:fake -17557 _string_0f_87_jump_loop/imm32/subx-name -17558 0/imm32/no-rm32 -17559 0/imm32/no-r32 -17560 0/imm32/no-imm32 -17561 0/imm32/no-imm8 -17562 0/imm32/no-disp32 -17563 0/imm32/no-output -17564 0x11/imm32/alloc-id:fake -17565 _Primitive-loop-if-</imm32/next -17566 _Primitive-loop-if-<: # (payload primitive) -17567 0x11/imm32/alloc-id:fake:payload +17551 _string_0f_8d_jump_break/imm32/subx-name +17552 0/imm32/no-rm32 +17553 0/imm32/no-r32 +17554 0/imm32/no-imm32 +17555 0/imm32/no-imm8 +17556 0/imm32/no-disp32 +17557 0/imm32/no-output +17558 0x11/imm32/alloc-id:fake +17559 _Primitive-break-if-<=/imm32/next +17560 _Primitive-break-if-<=: # (payload primitive) +17561 0x11/imm32/alloc-id:fake:payload +17562 0x11/imm32/alloc-id:fake +17563 _string-break-if-<=/imm32/name +17564 0/imm32/no-inouts +17565 0/imm32/no-inouts +17566 0/imm32/no-outputs +17567 0/imm32/no-outputs 17568 0x11/imm32/alloc-id:fake -17569 _string-loop-if-</imm32/name -17570 0/imm32/no-inouts -17571 0/imm32/no-inouts -17572 0/imm32/no-outputs -17573 0/imm32/no-outputs -17574 0x11/imm32/alloc-id:fake -17575 _string_0f_8c_jump_loop/imm32/subx-name -17576 0/imm32/no-rm32 -17577 0/imm32/no-r32 -17578 0/imm32/no-imm32 -17579 0/imm32/no-imm8 -17580 0/imm32/no-disp32 -17581 0/imm32/no-output -17582 0x11/imm32/alloc-id:fake -17583 _Primitive-loop-if->=/imm32/next -17584 _Primitive-loop-if->=: # (payload primitive) -17585 0x11/imm32/alloc-id:fake:payload +17569 _string_0f_8e_jump_break/imm32/subx-name +17570 0/imm32/no-rm32 +17571 0/imm32/no-r32 +17572 0/imm32/no-imm32 +17573 0/imm32/no-imm8 +17574 0/imm32/no-disp32 +17575 0/imm32/no-output +17576 0x11/imm32/alloc-id:fake +17577 _Primitive-break-if->/imm32/next +17578 _Primitive-break-if->: # (payload primitive) +17579 0x11/imm32/alloc-id:fake:payload +17580 0x11/imm32/alloc-id:fake +17581 _string-break-if->/imm32/name +17582 0/imm32/no-inouts +17583 0/imm32/no-inouts +17584 0/imm32/no-outputs +17585 0/imm32/no-outputs 17586 0x11/imm32/alloc-id:fake -17587 _string-loop-if->=/imm32/name -17588 0/imm32/no-inouts -17589 0/imm32/no-inouts -17590 0/imm32/no-outputs -17591 0/imm32/no-outputs -17592 0x11/imm32/alloc-id:fake -17593 _string_0f_8d_jump_loop/imm32/subx-name -17594 0/imm32/no-rm32 -17595 0/imm32/no-r32 -17596 0/imm32/no-imm32 -17597 0/imm32/no-imm8 -17598 0/imm32/no-disp32 -17599 0/imm32/no-output -17600 0x11/imm32/alloc-id:fake -17601 _Primitive-loop-if-<=/imm32/next -17602 _Primitive-loop-if-<=: # (payload primitive) -17603 0x11/imm32/alloc-id:fake:payload +17587 _string_0f_8f_jump_break/imm32/subx-name +17588 0/imm32/no-rm32 +17589 0/imm32/no-r32 +17590 0/imm32/no-imm32 +17591 0/imm32/no-imm8 +17592 0/imm32/no-disp32 +17593 0/imm32/no-output +17594 0x11/imm32/alloc-id:fake +17595 _Primitive-break/imm32/next +17596 _Primitive-break: # (payload primitive) +17597 0x11/imm32/alloc-id:fake:payload +17598 0x11/imm32/alloc-id:fake +17599 _string-break/imm32/name +17600 0/imm32/no-inouts +17601 0/imm32/no-inouts +17602 0/imm32/no-outputs +17603 0/imm32/no-outputs 17604 0x11/imm32/alloc-id:fake -17605 _string-loop-if-<=/imm32/name -17606 0/imm32/no-inouts -17607 0/imm32/no-inouts -17608 0/imm32/no-outputs -17609 0/imm32/no-outputs -17610 0x11/imm32/alloc-id:fake -17611 _string_0f_8e_jump_loop/imm32/subx-name -17612 0/imm32/no-rm32 -17613 0/imm32/no-r32 -17614 0/imm32/no-imm32 -17615 0/imm32/no-imm8 -17616 0/imm32/no-disp32 -17617 0/imm32/no-output -17618 0x11/imm32/alloc-id:fake -17619 _Primitive-loop-if->/imm32/next -17620 _Primitive-loop-if->: # (payload primitive) -17621 0x11/imm32/alloc-id:fake:payload +17605 _string_e9_jump_break/imm32/subx-name +17606 0/imm32/no-rm32 +17607 0/imm32/no-r32 +17608 0/imm32/no-imm32 +17609 0/imm32/no-imm8 +17610 0/imm32/no-disp32 +17611 0/imm32/no-output +17612 0x11/imm32/alloc-id:fake +17613 _Primitive-loop-if-addr</imm32/next +17614 _Primitive-loop-if-addr<: # (payload primitive) +17615 0x11/imm32/alloc-id:fake:payload +17616 0x11/imm32/alloc-id:fake +17617 _string-loop-if-addr</imm32/name +17618 0/imm32/no-inouts +17619 0/imm32/no-inouts +17620 0/imm32/no-outputs +17621 0/imm32/no-outputs 17622 0x11/imm32/alloc-id:fake -17623 _string-loop-if->/imm32/name -17624 0/imm32/no-inouts -17625 0/imm32/no-inouts -17626 0/imm32/no-outputs -17627 0/imm32/no-outputs -17628 0x11/imm32/alloc-id:fake -17629 _string_0f_8f_jump_loop/imm32/subx-name -17630 0/imm32/no-rm32 -17631 0/imm32/no-r32 -17632 0/imm32/no-imm32 -17633 0/imm32/no-imm8 -17634 0/imm32/no-disp32 -17635 0/imm32/no-output -17636 0x11/imm32/alloc-id:fake -17637 _Primitive-loop/imm32/next # we probably don't need an unconditional break -17638 _Primitive-loop: # (payload primitive) -17639 0x11/imm32/alloc-id:fake:payload +17623 _string_0f_82_jump_loop/imm32/subx-name +17624 0/imm32/no-rm32 +17625 0/imm32/no-r32 +17626 0/imm32/no-imm32 +17627 0/imm32/no-imm8 +17628 0/imm32/no-disp32 +17629 0/imm32/no-output +17630 0x11/imm32/alloc-id:fake +17631 _Primitive-loop-if-addr>=/imm32/next +17632 _Primitive-loop-if-addr>=: # (payload primitive) +17633 0x11/imm32/alloc-id:fake:payload +17634 0x11/imm32/alloc-id:fake +17635 _string-loop-if-addr>=/imm32/name +17636 0/imm32/no-inouts +17637 0/imm32/no-inouts +17638 0/imm32/no-outputs +17639 0/imm32/no-outputs 17640 0x11/imm32/alloc-id:fake -17641 _string-loop/imm32/name -17642 0/imm32/no-inouts -17643 0/imm32/no-inouts -17644 0/imm32/no-outputs -17645 0/imm32/no-outputs -17646 0x11/imm32/alloc-id:fake -17647 _string_e9_jump_loop/imm32/subx-name -17648 0/imm32/no-rm32 -17649 0/imm32/no-r32 -17650 0/imm32/no-imm32 -17651 0/imm32/no-imm8 -17652 0/imm32/no-disp32 -17653 0/imm32/no-output -17654 0x11/imm32/alloc-id:fake -17655 _Primitive-break-if-addr<-named/imm32/next -17656 # - branches to named blocks -17657 _Primitive-break-if-addr<-named: # (payload primitive) -17658 0x11/imm32/alloc-id:fake:payload -17659 0x11/imm32/alloc-id:fake -17660 _string-break-if-addr</imm32/name -17661 0x11/imm32/alloc-id:fake -17662 Single-lit-var/imm32/inouts -17663 0/imm32/no-outputs -17664 0/imm32/no-outputs -17665 0x11/imm32/alloc-id:fake -17666 _string_0f_82_jump_label/imm32/subx-name -17667 0/imm32/no-rm32 -17668 0/imm32/no-r32 -17669 0/imm32/no-imm32 -17670 0/imm32/no-imm8 -17671 1/imm32/disp32-is-first-inout -17672 0/imm32/no-output -17673 0x11/imm32/alloc-id:fake -17674 _Primitive-break-if-addr>=-named/imm32/next -17675 _Primitive-break-if-addr>=-named: # (payload primitive) -17676 0x11/imm32/alloc-id:fake:payload -17677 0x11/imm32/alloc-id:fake -17678 _string-break-if-addr>=/imm32/name -17679 0x11/imm32/alloc-id:fake -17680 Single-lit-var/imm32/inouts -17681 0/imm32/no-outputs -17682 0/imm32/no-outputs -17683 0x11/imm32/alloc-id:fake -17684 _string_0f_83_jump_label/imm32/subx-name -17685 0/imm32/no-rm32 -17686 0/imm32/no-r32 -17687 0/imm32/no-imm32 -17688 0/imm32/no-imm8 -17689 1/imm32/disp32-is-first-inout -17690 0/imm32/no-output -17691 0x11/imm32/alloc-id:fake -17692 _Primitive-break-if-=-named/imm32/next -17693 _Primitive-break-if-=-named: # (payload primitive) -17694 0x11/imm32/alloc-id:fake:payload -17695 0x11/imm32/alloc-id:fake -17696 _string-break-if-=/imm32/name -17697 0x11/imm32/alloc-id:fake -17698 Single-lit-var/imm32/inouts -17699 0/imm32/no-outputs -17700 0/imm32/no-outputs -17701 0x11/imm32/alloc-id:fake -17702 _string_0f_84_jump_label/imm32/subx-name -17703 0/imm32/no-rm32 -17704 0/imm32/no-r32 -17705 0/imm32/no-imm32 -17706 0/imm32/no-imm8 -17707 1/imm32/disp32-is-first-inout -17708 0/imm32/no-output -17709 0x11/imm32/alloc-id:fake -17710 _Primitive-break-if-!=-named/imm32/next -17711 _Primitive-break-if-!=-named: # (payload primitive) -17712 0x11/imm32/alloc-id:fake:payload -17713 0x11/imm32/alloc-id:fake -17714 _string-break-if-!=/imm32/name -17715 0x11/imm32/alloc-id:fake -17716 Single-lit-var/imm32/inouts -17717 0/imm32/no-outputs -17718 0/imm32/no-outputs -17719 0x11/imm32/alloc-id:fake -17720 _string_0f_85_jump_label/imm32/subx-name -17721 0/imm32/no-rm32 -17722 0/imm32/no-r32 -17723 0/imm32/no-imm32 -17724 0/imm32/no-imm8 -17725 1/imm32/disp32-is-first-inout -17726 0/imm32/no-output -17727 0x11/imm32/alloc-id:fake -17728 _Primitive-break-if-addr<=-named/imm32/next -17729 _Primitive-break-if-addr<=-named: # (payload primitive) -17730 0x11/imm32/alloc-id:fake:payload -17731 0x11/imm32/alloc-id:fake -17732 _string-break-if-addr<=/imm32/name -17733 0x11/imm32/alloc-id:fake -17734 Single-lit-var/imm32/inouts -17735 0/imm32/no-outputs -17736 0/imm32/no-outputs -17737 0x11/imm32/alloc-id:fake -17738 _string_0f_86_jump_label/imm32/subx-name -17739 0/imm32/no-rm32 -17740 0/imm32/no-r32 -17741 0/imm32/no-imm32 -17742 0/imm32/no-imm8 -17743 1/imm32/disp32-is-first-inout -17744 0/imm32/no-output -17745 0x11/imm32/alloc-id:fake -17746 _Primitive-break-if-addr>-named/imm32/next -17747 _Primitive-break-if-addr>-named: # (payload primitive) -17748 0x11/imm32/alloc-id:fake:payload -17749 0x11/imm32/alloc-id:fake -17750 _string-break-if-addr>/imm32/name -17751 0x11/imm32/alloc-id:fake -17752 Single-lit-var/imm32/inouts -17753 0/imm32/no-outputs -17754 0/imm32/no-outputs -17755 0x11/imm32/alloc-id:fake -17756 _string_0f_87_jump_label/imm32/subx-name -17757 0/imm32/no-rm32 -17758 0/imm32/no-r32 -17759 0/imm32/no-imm32 -17760 0/imm32/no-imm8 -17761 1/imm32/disp32-is-first-inout -17762 0/imm32/no-output -17763 0x11/imm32/alloc-id:fake -17764 _Primitive-break-if-<-named/imm32/next -17765 _Primitive-break-if-<-named: # (payload primitive) -17766 0x11/imm32/alloc-id:fake:payload -17767 0x11/imm32/alloc-id:fake -17768 _string-break-if-</imm32/name -17769 0x11/imm32/alloc-id:fake -17770 Single-lit-var/imm32/inouts -17771 0/imm32/no-outputs -17772 0/imm32/no-outputs -17773 0x11/imm32/alloc-id:fake -17774 _string_0f_8c_jump_label/imm32/subx-name -17775 0/imm32/no-rm32 -17776 0/imm32/no-r32 -17777 0/imm32/no-imm32 -17778 0/imm32/no-imm8 -17779 1/imm32/disp32-is-first-inout -17780 0/imm32/no-output -17781 0x11/imm32/alloc-id:fake -17782 _Primitive-break-if->=-named/imm32/next -17783 _Primitive-break-if->=-named: # (payload primitive) -17784 0x11/imm32/alloc-id:fake:payload -17785 0x11/imm32/alloc-id:fake -17786 _string-break-if->=/imm32/name -17787 0x11/imm32/alloc-id:fake -17788 Single-lit-var/imm32/inouts -17789 0/imm32/no-outputs -17790 0/imm32/no-outputs -17791 0x11/imm32/alloc-id:fake -17792 _string_0f_8d_jump_label/imm32/subx-name -17793 0/imm32/no-rm32 -17794 0/imm32/no-r32 -17795 0/imm32/no-imm32 -17796 0/imm32/no-imm8 -17797 1/imm32/disp32-is-first-inout -17798 0/imm32/no-output -17799 0x11/imm32/alloc-id:fake -17800 _Primitive-break-if-<=-named/imm32/next -17801 _Primitive-break-if-<=-named: # (payload primitive) -17802 0x11/imm32/alloc-id:fake:payload -17803 0x11/imm32/alloc-id:fake -17804 _string-break-if-<=/imm32/name -17805 0x11/imm32/alloc-id:fake -17806 Single-lit-var/imm32/inouts -17807 0/imm32/no-outputs -17808 0/imm32/no-outputs -17809 0x11/imm32/alloc-id:fake -17810 _string_0f_8e_jump_label/imm32/subx-name -17811 0/imm32/no-rm32 -17812 0/imm32/no-r32 -17813 0/imm32/no-imm32 -17814 0/imm32/no-imm8 -17815 1/imm32/disp32-is-first-inout -17816 0/imm32/no-output +17641 _string_0f_83_jump_loop/imm32/subx-name +17642 0/imm32/no-rm32 +17643 0/imm32/no-r32 +17644 0/imm32/no-imm32 +17645 0/imm32/no-imm8 +17646 0/imm32/no-disp32 +17647 0/imm32/no-output +17648 0x11/imm32/alloc-id:fake +17649 _Primitive-loop-if-=/imm32/next +17650 _Primitive-loop-if-=: # (payload primitive) +17651 0x11/imm32/alloc-id:fake:payload +17652 0x11/imm32/alloc-id:fake +17653 _string-loop-if-=/imm32/name +17654 0/imm32/no-inouts +17655 0/imm32/no-inouts +17656 0/imm32/no-outputs +17657 0/imm32/no-outputs +17658 0x11/imm32/alloc-id:fake +17659 _string_0f_84_jump_loop/imm32/subx-name +17660 0/imm32/no-rm32 +17661 0/imm32/no-r32 +17662 0/imm32/no-imm32 +17663 0/imm32/no-imm8 +17664 0/imm32/no-disp32 +17665 0/imm32/no-output +17666 0x11/imm32/alloc-id:fake +17667 _Primitive-loop-if-!=/imm32/next +17668 _Primitive-loop-if-!=: # (payload primitive) +17669 0x11/imm32/alloc-id:fake:payload +17670 0x11/imm32/alloc-id:fake +17671 _string-loop-if-!=/imm32/name +17672 0/imm32/no-inouts +17673 0/imm32/no-inouts +17674 0/imm32/no-outputs +17675 0/imm32/no-outputs +17676 0x11/imm32/alloc-id:fake +17677 _string_0f_85_jump_loop/imm32/subx-name +17678 0/imm32/no-rm32 +17679 0/imm32/no-r32 +17680 0/imm32/no-imm32 +17681 0/imm32/no-imm8 +17682 0/imm32/no-disp32 +17683 0/imm32/no-output +17684 0x11/imm32/alloc-id:fake +17685 _Primitive-loop-if-addr<=/imm32/next +17686 _Primitive-loop-if-addr<=: # (payload primitive) +17687 0x11/imm32/alloc-id:fake:payload +17688 0x11/imm32/alloc-id:fake +17689 _string-loop-if-addr<=/imm32/name +17690 0/imm32/no-inouts +17691 0/imm32/no-inouts +17692 0/imm32/no-outputs +17693 0/imm32/no-outputs +17694 0x11/imm32/alloc-id:fake +17695 _string_0f_86_jump_loop/imm32/subx-name +17696 0/imm32/no-rm32 +17697 0/imm32/no-r32 +17698 0/imm32/no-imm32 +17699 0/imm32/no-imm8 +17700 0/imm32/no-disp32 +17701 0/imm32/no-output +17702 0x11/imm32/alloc-id:fake +17703 _Primitive-loop-if-addr>/imm32/next +17704 _Primitive-loop-if-addr>: # (payload primitive) +17705 0x11/imm32/alloc-id:fake:payload +17706 0x11/imm32/alloc-id:fake +17707 _string-loop-if-addr>/imm32/name +17708 0/imm32/no-inouts +17709 0/imm32/no-inouts +17710 0/imm32/no-outputs +17711 0/imm32/no-outputs +17712 0x11/imm32/alloc-id:fake +17713 _string_0f_87_jump_loop/imm32/subx-name +17714 0/imm32/no-rm32 +17715 0/imm32/no-r32 +17716 0/imm32/no-imm32 +17717 0/imm32/no-imm8 +17718 0/imm32/no-disp32 +17719 0/imm32/no-output +17720 0x11/imm32/alloc-id:fake +17721 _Primitive-loop-if-</imm32/next +17722 _Primitive-loop-if-<: # (payload primitive) +17723 0x11/imm32/alloc-id:fake:payload +17724 0x11/imm32/alloc-id:fake +17725 _string-loop-if-</imm32/name +17726 0/imm32/no-inouts +17727 0/imm32/no-inouts +17728 0/imm32/no-outputs +17729 0/imm32/no-outputs +17730 0x11/imm32/alloc-id:fake +17731 _string_0f_8c_jump_loop/imm32/subx-name +17732 0/imm32/no-rm32 +17733 0/imm32/no-r32 +17734 0/imm32/no-imm32 +17735 0/imm32/no-imm8 +17736 0/imm32/no-disp32 +17737 0/imm32/no-output +17738 0x11/imm32/alloc-id:fake +17739 _Primitive-loop-if->=/imm32/next +17740 _Primitive-loop-if->=: # (payload primitive) +17741 0x11/imm32/alloc-id:fake:payload +17742 0x11/imm32/alloc-id:fake +17743 _string-loop-if->=/imm32/name +17744 0/imm32/no-inouts +17745 0/imm32/no-inouts +17746 0/imm32/no-outputs +17747 0/imm32/no-outputs +17748 0x11/imm32/alloc-id:fake +17749 _string_0f_8d_jump_loop/imm32/subx-name +17750 0/imm32/no-rm32 +17751 0/imm32/no-r32 +17752 0/imm32/no-imm32 +17753 0/imm32/no-imm8 +17754 0/imm32/no-disp32 +17755 0/imm32/no-output +17756 0x11/imm32/alloc-id:fake +17757 _Primitive-loop-if-<=/imm32/next +17758 _Primitive-loop-if-<=: # (payload primitive) +17759 0x11/imm32/alloc-id:fake:payload +17760 0x11/imm32/alloc-id:fake +17761 _string-loop-if-<=/imm32/name +17762 0/imm32/no-inouts +17763 0/imm32/no-inouts +17764 0/imm32/no-outputs +17765 0/imm32/no-outputs +17766 0x11/imm32/alloc-id:fake +17767 _string_0f_8e_jump_loop/imm32/subx-name +17768 0/imm32/no-rm32 +17769 0/imm32/no-r32 +17770 0/imm32/no-imm32 +17771 0/imm32/no-imm8 +17772 0/imm32/no-disp32 +17773 0/imm32/no-output +17774 0x11/imm32/alloc-id:fake +17775 _Primitive-loop-if->/imm32/next +17776 _Primitive-loop-if->: # (payload primitive) +17777 0x11/imm32/alloc-id:fake:payload +17778 0x11/imm32/alloc-id:fake +17779 _string-loop-if->/imm32/name +17780 0/imm32/no-inouts +17781 0/imm32/no-inouts +17782 0/imm32/no-outputs +17783 0/imm32/no-outputs +17784 0x11/imm32/alloc-id:fake +17785 _string_0f_8f_jump_loop/imm32/subx-name +17786 0/imm32/no-rm32 +17787 0/imm32/no-r32 +17788 0/imm32/no-imm32 +17789 0/imm32/no-imm8 +17790 0/imm32/no-disp32 +17791 0/imm32/no-output +17792 0x11/imm32/alloc-id:fake +17793 _Primitive-loop/imm32/next # we probably don't need an unconditional break +17794 _Primitive-loop: # (payload primitive) +17795 0x11/imm32/alloc-id:fake:payload +17796 0x11/imm32/alloc-id:fake +17797 _string-loop/imm32/name +17798 0/imm32/no-inouts +17799 0/imm32/no-inouts +17800 0/imm32/no-outputs +17801 0/imm32/no-outputs +17802 0x11/imm32/alloc-id:fake +17803 _string_e9_jump_loop/imm32/subx-name +17804 0/imm32/no-rm32 +17805 0/imm32/no-r32 +17806 0/imm32/no-imm32 +17807 0/imm32/no-imm8 +17808 0/imm32/no-disp32 +17809 0/imm32/no-output +17810 0x11/imm32/alloc-id:fake +17811 _Primitive-break-if-addr<-named/imm32/next +17812 # - branches to named blocks +17813 _Primitive-break-if-addr<-named: # (payload primitive) +17814 0x11/imm32/alloc-id:fake:payload +17815 0x11/imm32/alloc-id:fake +17816 _string-break-if-addr</imm32/name 17817 0x11/imm32/alloc-id:fake -17818 _Primitive-break-if->-named/imm32/next -17819 _Primitive-break-if->-named: # (payload primitive) -17820 0x11/imm32/alloc-id:fake:payload +17818 Single-lit-var/imm32/inouts +17819 0/imm32/no-outputs +17820 0/imm32/no-outputs 17821 0x11/imm32/alloc-id:fake -17822 _string-break-if->/imm32/name -17823 0x11/imm32/alloc-id:fake -17824 Single-lit-var/imm32/inouts -17825 0/imm32/no-outputs -17826 0/imm32/no-outputs -17827 0x11/imm32/alloc-id:fake -17828 _string_0f_8f_jump_label/imm32/subx-name -17829 0/imm32/no-rm32 -17830 0/imm32/no-r32 -17831 0/imm32/no-imm32 -17832 0/imm32/no-imm8 -17833 1/imm32/disp32-is-first-inout -17834 0/imm32/no-output +17822 _string_0f_82_jump_label/imm32/subx-name +17823 0/imm32/no-rm32 +17824 0/imm32/no-r32 +17825 0/imm32/no-imm32 +17826 0/imm32/no-imm8 +17827 1/imm32/disp32-is-first-inout +17828 0/imm32/no-output +17829 0x11/imm32/alloc-id:fake +17830 _Primitive-break-if-addr>=-named/imm32/next +17831 _Primitive-break-if-addr>=-named: # (payload primitive) +17832 0x11/imm32/alloc-id:fake:payload +17833 0x11/imm32/alloc-id:fake +17834 _string-break-if-addr>=/imm32/name 17835 0x11/imm32/alloc-id:fake -17836 _Primitive-break-named/imm32/next -17837 _Primitive-break-named: # (payload primitive) -17838 0x11/imm32/alloc-id:fake:payload +17836 Single-lit-var/imm32/inouts +17837 0/imm32/no-outputs +17838 0/imm32/no-outputs 17839 0x11/imm32/alloc-id:fake -17840 _string-break/imm32/name -17841 0x11/imm32/alloc-id:fake -17842 Single-lit-var/imm32/inouts -17843 0/imm32/no-outputs -17844 0/imm32/no-outputs -17845 0x11/imm32/alloc-id:fake -17846 _string_e9_jump_label/imm32/subx-name -17847 0/imm32/no-rm32 -17848 0/imm32/no-r32 -17849 0/imm32/no-imm32 -17850 0/imm32/no-imm8 -17851 1/imm32/disp32-is-first-inout -17852 0/imm32/no-output +17840 _string_0f_83_jump_label/imm32/subx-name +17841 0/imm32/no-rm32 +17842 0/imm32/no-r32 +17843 0/imm32/no-imm32 +17844 0/imm32/no-imm8 +17845 1/imm32/disp32-is-first-inout +17846 0/imm32/no-output +17847 0x11/imm32/alloc-id:fake +17848 _Primitive-break-if-=-named/imm32/next +17849 _Primitive-break-if-=-named: # (payload primitive) +17850 0x11/imm32/alloc-id:fake:payload +17851 0x11/imm32/alloc-id:fake +17852 _string-break-if-=/imm32/name 17853 0x11/imm32/alloc-id:fake -17854 _Primitive-loop-if-addr<-named/imm32/next -17855 _Primitive-loop-if-addr<-named: # (payload primitive) -17856 0x11/imm32/alloc-id:fake:payload +17854 Single-lit-var/imm32/inouts +17855 0/imm32/no-outputs +17856 0/imm32/no-outputs 17857 0x11/imm32/alloc-id:fake -17858 _string-loop-if-addr</imm32/name -17859 0x11/imm32/alloc-id:fake -17860 Single-lit-var/imm32/inouts -17861 0/imm32/no-outputs -17862 0/imm32/no-outputs -17863 0x11/imm32/alloc-id:fake -17864 _string_0f_82_jump_label/imm32/subx-name -17865 0/imm32/no-rm32 -17866 0/imm32/no-r32 -17867 0/imm32/no-imm32 -17868 0/imm32/no-imm8 -17869 1/imm32/disp32-is-first-inout -17870 0/imm32/no-output +17858 _string_0f_84_jump_label/imm32/subx-name +17859 0/imm32/no-rm32 +17860 0/imm32/no-r32 +17861 0/imm32/no-imm32 +17862 0/imm32/no-imm8 +17863 1/imm32/disp32-is-first-inout +17864 0/imm32/no-output +17865 0x11/imm32/alloc-id:fake +17866 _Primitive-break-if-!=-named/imm32/next +17867 _Primitive-break-if-!=-named: # (payload primitive) +17868 0x11/imm32/alloc-id:fake:payload +17869 0x11/imm32/alloc-id:fake +17870 _string-break-if-!=/imm32/name 17871 0x11/imm32/alloc-id:fake -17872 _Primitive-loop-if-addr>=-named/imm32/next -17873 _Primitive-loop-if-addr>=-named: # (payload primitive) -17874 0x11/imm32/alloc-id:fake:payload +17872 Single-lit-var/imm32/inouts +17873 0/imm32/no-outputs +17874 0/imm32/no-outputs 17875 0x11/imm32/alloc-id:fake -17876 _string-loop-if-addr>=/imm32/name -17877 0x11/imm32/alloc-id:fake -17878 Single-lit-var/imm32/inouts -17879 0/imm32/no-outputs -17880 0/imm32/no-outputs -17881 0x11/imm32/alloc-id:fake -17882 _string_0f_83_jump_label/imm32/subx-name -17883 0/imm32/no-rm32 -17884 0/imm32/no-r32 -17885 0/imm32/no-imm32 -17886 0/imm32/no-imm8 -17887 1/imm32/disp32-is-first-inout -17888 0/imm32/no-output +17876 _string_0f_85_jump_label/imm32/subx-name +17877 0/imm32/no-rm32 +17878 0/imm32/no-r32 +17879 0/imm32/no-imm32 +17880 0/imm32/no-imm8 +17881 1/imm32/disp32-is-first-inout +17882 0/imm32/no-output +17883 0x11/imm32/alloc-id:fake +17884 _Primitive-break-if-addr<=-named/imm32/next +17885 _Primitive-break-if-addr<=-named: # (payload primitive) +17886 0x11/imm32/alloc-id:fake:payload +17887 0x11/imm32/alloc-id:fake +17888 _string-break-if-addr<=/imm32/name 17889 0x11/imm32/alloc-id:fake -17890 _Primitive-loop-if-=-named/imm32/next -17891 _Primitive-loop-if-=-named: # (payload primitive) -17892 0x11/imm32/alloc-id:fake:payload +17890 Single-lit-var/imm32/inouts +17891 0/imm32/no-outputs +17892 0/imm32/no-outputs 17893 0x11/imm32/alloc-id:fake -17894 _string-loop-if-=/imm32/name -17895 0x11/imm32/alloc-id:fake -17896 Single-lit-var/imm32/inouts -17897 0/imm32/no-outputs -17898 0/imm32/no-outputs -17899 0x11/imm32/alloc-id:fake -17900 _string_0f_84_jump_label/imm32/subx-name -17901 0/imm32/no-rm32 -17902 0/imm32/no-r32 -17903 0/imm32/no-imm32 -17904 0/imm32/no-imm8 -17905 1/imm32/disp32-is-first-inout -17906 0/imm32/no-output +17894 _string_0f_86_jump_label/imm32/subx-name +17895 0/imm32/no-rm32 +17896 0/imm32/no-r32 +17897 0/imm32/no-imm32 +17898 0/imm32/no-imm8 +17899 1/imm32/disp32-is-first-inout +17900 0/imm32/no-output +17901 0x11/imm32/alloc-id:fake +17902 _Primitive-break-if-addr>-named/imm32/next +17903 _Primitive-break-if-addr>-named: # (payload primitive) +17904 0x11/imm32/alloc-id:fake:payload +17905 0x11/imm32/alloc-id:fake +17906 _string-break-if-addr>/imm32/name 17907 0x11/imm32/alloc-id:fake -17908 _Primitive-loop-if-!=-named/imm32/next -17909 _Primitive-loop-if-!=-named: # (payload primitive) -17910 0x11/imm32/alloc-id:fake:payload +17908 Single-lit-var/imm32/inouts +17909 0/imm32/no-outputs +17910 0/imm32/no-outputs 17911 0x11/imm32/alloc-id:fake -17912 _string-loop-if-!=/imm32/name -17913 0x11/imm32/alloc-id:fake -17914 Single-lit-var/imm32/inouts -17915 0/imm32/no-outputs -17916 0/imm32/no-outputs -17917 0x11/imm32/alloc-id:fake -17918 _string_0f_85_jump_label/imm32/subx-name -17919 0/imm32/no-rm32 -17920 0/imm32/no-r32 -17921 0/imm32/no-imm32 -17922 0/imm32/no-imm8 -17923 1/imm32/disp32-is-first-inout -17924 0/imm32/no-output +17912 _string_0f_87_jump_label/imm32/subx-name +17913 0/imm32/no-rm32 +17914 0/imm32/no-r32 +17915 0/imm32/no-imm32 +17916 0/imm32/no-imm8 +17917 1/imm32/disp32-is-first-inout +17918 0/imm32/no-output +17919 0x11/imm32/alloc-id:fake +17920 _Primitive-break-if-<-named/imm32/next +17921 _Primitive-break-if-<-named: # (payload primitive) +17922 0x11/imm32/alloc-id:fake:payload +17923 0x11/imm32/alloc-id:fake +17924 _string-break-if-</imm32/name 17925 0x11/imm32/alloc-id:fake -17926 _Primitive-loop-if-addr<=-named/imm32/next -17927 _Primitive-loop-if-addr<=-named: # (payload primitive) -17928 0x11/imm32/alloc-id:fake:payload +17926 Single-lit-var/imm32/inouts +17927 0/imm32/no-outputs +17928 0/imm32/no-outputs 17929 0x11/imm32/alloc-id:fake -17930 _string-loop-if-addr<=/imm32/name -17931 0x11/imm32/alloc-id:fake -17932 Single-lit-var/imm32/inouts -17933 0/imm32/no-outputs -17934 0/imm32/no-outputs -17935 0x11/imm32/alloc-id:fake -17936 _string_0f_86_jump_label/imm32/subx-name -17937 0/imm32/no-rm32 -17938 0/imm32/no-r32 -17939 0/imm32/no-imm32 -17940 0/imm32/no-imm8 -17941 1/imm32/disp32-is-first-inout -17942 0/imm32/no-output +17930 _string_0f_8c_jump_label/imm32/subx-name +17931 0/imm32/no-rm32 +17932 0/imm32/no-r32 +17933 0/imm32/no-imm32 +17934 0/imm32/no-imm8 +17935 1/imm32/disp32-is-first-inout +17936 0/imm32/no-output +17937 0x11/imm32/alloc-id:fake +17938 _Primitive-break-if->=-named/imm32/next +17939 _Primitive-break-if->=-named: # (payload primitive) +17940 0x11/imm32/alloc-id:fake:payload +17941 0x11/imm32/alloc-id:fake +17942 _string-break-if->=/imm32/name 17943 0x11/imm32/alloc-id:fake -17944 _Primitive-loop-if-addr>-named/imm32/next -17945 _Primitive-loop-if-addr>-named: # (payload primitive) -17946 0x11/imm32/alloc-id:fake:payload +17944 Single-lit-var/imm32/inouts +17945 0/imm32/no-outputs +17946 0/imm32/no-outputs 17947 0x11/imm32/alloc-id:fake -17948 _string-loop-if-addr>/imm32/name -17949 0x11/imm32/alloc-id:fake -17950 Single-lit-var/imm32/inouts -17951 0/imm32/no-outputs -17952 0/imm32/no-outputs -17953 0x11/imm32/alloc-id:fake -17954 _string_0f_87_jump_label/imm32/subx-name -17955 0/imm32/no-rm32 -17956 0/imm32/no-r32 -17957 0/imm32/no-imm32 -17958 0/imm32/no-imm8 -17959 1/imm32/disp32-is-first-inout -17960 0/imm32/no-output +17948 _string_0f_8d_jump_label/imm32/subx-name +17949 0/imm32/no-rm32 +17950 0/imm32/no-r32 +17951 0/imm32/no-imm32 +17952 0/imm32/no-imm8 +17953 1/imm32/disp32-is-first-inout +17954 0/imm32/no-output +17955 0x11/imm32/alloc-id:fake +17956 _Primitive-break-if-<=-named/imm32/next +17957 _Primitive-break-if-<=-named: # (payload primitive) +17958 0x11/imm32/alloc-id:fake:payload +17959 0x11/imm32/alloc-id:fake +17960 _string-break-if-<=/imm32/name 17961 0x11/imm32/alloc-id:fake -17962 _Primitive-loop-if-<-named/imm32/next -17963 _Primitive-loop-if-<-named: # (payload primitive) -17964 0x11/imm32/alloc-id:fake:payload +17962 Single-lit-var/imm32/inouts +17963 0/imm32/no-outputs +17964 0/imm32/no-outputs 17965 0x11/imm32/alloc-id:fake -17966 _string-loop-if-</imm32/name -17967 0x11/imm32/alloc-id:fake -17968 Single-lit-var/imm32/inouts -17969 0/imm32/no-outputs -17970 0/imm32/no-outputs -17971 0x11/imm32/alloc-id:fake -17972 _string_0f_8c_jump_label/imm32/subx-name -17973 0/imm32/no-rm32 -17974 0/imm32/no-r32 -17975 0/imm32/no-imm32 -17976 0/imm32/no-imm8 -17977 1/imm32/disp32-is-first-inout -17978 0/imm32/no-output +17966 _string_0f_8e_jump_label/imm32/subx-name +17967 0/imm32/no-rm32 +17968 0/imm32/no-r32 +17969 0/imm32/no-imm32 +17970 0/imm32/no-imm8 +17971 1/imm32/disp32-is-first-inout +17972 0/imm32/no-output +17973 0x11/imm32/alloc-id:fake +17974 _Primitive-break-if->-named/imm32/next +17975 _Primitive-break-if->-named: # (payload primitive) +17976 0x11/imm32/alloc-id:fake:payload +17977 0x11/imm32/alloc-id:fake +17978 _string-break-if->/imm32/name 17979 0x11/imm32/alloc-id:fake -17980 _Primitive-loop-if->=-named/imm32/next -17981 _Primitive-loop-if->=-named: # (payload primitive) -17982 0x11/imm32/alloc-id:fake:payload +17980 Single-lit-var/imm32/inouts +17981 0/imm32/no-outputs +17982 0/imm32/no-outputs 17983 0x11/imm32/alloc-id:fake -17984 _string-loop-if->=/imm32/name -17985 0x11/imm32/alloc-id:fake -17986 Single-lit-var/imm32/inouts -17987 0/imm32/no-outputs -17988 0/imm32/no-outputs -17989 0x11/imm32/alloc-id:fake -17990 _string_0f_8d_jump_label/imm32/subx-name -17991 0/imm32/no-rm32 -17992 0/imm32/no-r32 -17993 0/imm32/no-imm32 -17994 0/imm32/no-imm8 -17995 1/imm32/disp32-is-first-inout -17996 0/imm32/no-output +17984 _string_0f_8f_jump_label/imm32/subx-name +17985 0/imm32/no-rm32 +17986 0/imm32/no-r32 +17987 0/imm32/no-imm32 +17988 0/imm32/no-imm8 +17989 1/imm32/disp32-is-first-inout +17990 0/imm32/no-output +17991 0x11/imm32/alloc-id:fake +17992 _Primitive-break-named/imm32/next +17993 _Primitive-break-named: # (payload primitive) +17994 0x11/imm32/alloc-id:fake:payload +17995 0x11/imm32/alloc-id:fake +17996 _string-break/imm32/name 17997 0x11/imm32/alloc-id:fake -17998 _Primitive-loop-if-<=-named/imm32/next -17999 _Primitive-loop-if-<=-named: # (payload primitive) -18000 0x11/imm32/alloc-id:fake:payload +17998 Single-lit-var/imm32/inouts +17999 0/imm32/no-outputs +18000 0/imm32/no-outputs 18001 0x11/imm32/alloc-id:fake -18002 _string-loop-if-<=/imm32/name -18003 0x11/imm32/alloc-id:fake -18004 Single-lit-var/imm32/inouts -18005 0/imm32/no-outputs -18006 0/imm32/no-outputs -18007 0x11/imm32/alloc-id:fake -18008 _string_0f_8e_jump_label/imm32/subx-name -18009 0/imm32/no-rm32 -18010 0/imm32/no-r32 -18011 0/imm32/no-imm32 -18012 0/imm32/no-imm8 -18013 1/imm32/disp32-is-first-inout -18014 0/imm32/no-output +18002 _string_e9_jump_label/imm32/subx-name +18003 0/imm32/no-rm32 +18004 0/imm32/no-r32 +18005 0/imm32/no-imm32 +18006 0/imm32/no-imm8 +18007 1/imm32/disp32-is-first-inout +18008 0/imm32/no-output +18009 0x11/imm32/alloc-id:fake +18010 _Primitive-loop-if-addr<-named/imm32/next +18011 _Primitive-loop-if-addr<-named: # (payload primitive) +18012 0x11/imm32/alloc-id:fake:payload +18013 0x11/imm32/alloc-id:fake +18014 _string-loop-if-addr</imm32/name 18015 0x11/imm32/alloc-id:fake -18016 _Primitive-loop-if->-named/imm32/next -18017 _Primitive-loop-if->-named: # (payload primitive) -18018 0x11/imm32/alloc-id:fake:payload +18016 Single-lit-var/imm32/inouts +18017 0/imm32/no-outputs +18018 0/imm32/no-outputs 18019 0x11/imm32/alloc-id:fake -18020 _string-loop-if->/imm32/name -18021 0x11/imm32/alloc-id:fake -18022 Single-lit-var/imm32/inouts -18023 0/imm32/no-outputs -18024 0/imm32/no-outputs -18025 0x11/imm32/alloc-id:fake -18026 _string_0f_8f_jump_label/imm32/subx-name -18027 0/imm32/no-rm32 -18028 0/imm32/no-r32 -18029 0/imm32/no-imm32 -18030 0/imm32/no-imm8 -18031 1/imm32/disp32-is-first-inout -18032 0/imm32/no-output +18020 _string_0f_82_jump_label/imm32/subx-name +18021 0/imm32/no-rm32 +18022 0/imm32/no-r32 +18023 0/imm32/no-imm32 +18024 0/imm32/no-imm8 +18025 1/imm32/disp32-is-first-inout +18026 0/imm32/no-output +18027 0x11/imm32/alloc-id:fake +18028 _Primitive-loop-if-addr>=-named/imm32/next +18029 _Primitive-loop-if-addr>=-named: # (payload primitive) +18030 0x11/imm32/alloc-id:fake:payload +18031 0x11/imm32/alloc-id:fake +18032 _string-loop-if-addr>=/imm32/name 18033 0x11/imm32/alloc-id:fake -18034 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break -18035 _Primitive-loop-named: # (payload primitive) -18036 0x11/imm32/alloc-id:fake:payload +18034 Single-lit-var/imm32/inouts +18035 0/imm32/no-outputs +18036 0/imm32/no-outputs 18037 0x11/imm32/alloc-id:fake -18038 _string-loop/imm32/name -18039 0x11/imm32/alloc-id:fake -18040 Single-lit-var/imm32/inouts -18041 0/imm32/no-outputs -18042 0/imm32/no-outputs -18043 0x11/imm32/alloc-id:fake -18044 _string_e9_jump_label/imm32/subx-name -18045 0/imm32/no-rm32 -18046 0/imm32/no-r32 -18047 0/imm32/no-imm32 -18048 0/imm32/no-imm8 -18049 1/imm32/disp32-is-first-inout -18050 0/imm32/no-output -18051 0/imm32/next -18052 0/imm32/next -18053 -18054 # string literals for Mu instructions -18055 _string-add: # (payload array byte) -18056 0x11/imm32/alloc-id:fake:payload -18057 # "add" -18058 0x3/imm32/size -18059 0x61/a 0x64/d 0x64/d -18060 _string-address: # (payload array byte) -18061 0x11/imm32/alloc-id:fake:payload -18062 # "address" -18063 0x7/imm32/size -18064 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s -18065 _string-add-to: # (payload array byte) +18038 _string_0f_83_jump_label/imm32/subx-name +18039 0/imm32/no-rm32 +18040 0/imm32/no-r32 +18041 0/imm32/no-imm32 +18042 0/imm32/no-imm8 +18043 1/imm32/disp32-is-first-inout +18044 0/imm32/no-output +18045 0x11/imm32/alloc-id:fake +18046 _Primitive-loop-if-=-named/imm32/next +18047 _Primitive-loop-if-=-named: # (payload primitive) +18048 0x11/imm32/alloc-id:fake:payload +18049 0x11/imm32/alloc-id:fake +18050 _string-loop-if-=/imm32/name +18051 0x11/imm32/alloc-id:fake +18052 Single-lit-var/imm32/inouts +18053 0/imm32/no-outputs +18054 0/imm32/no-outputs +18055 0x11/imm32/alloc-id:fake +18056 _string_0f_84_jump_label/imm32/subx-name +18057 0/imm32/no-rm32 +18058 0/imm32/no-r32 +18059 0/imm32/no-imm32 +18060 0/imm32/no-imm8 +18061 1/imm32/disp32-is-first-inout +18062 0/imm32/no-output +18063 0x11/imm32/alloc-id:fake +18064 _Primitive-loop-if-!=-named/imm32/next +18065 _Primitive-loop-if-!=-named: # (payload primitive) 18066 0x11/imm32/alloc-id:fake:payload -18067 # "add-to" -18068 0x6/imm32/size -18069 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -18070 _string-and: # (payload array byte) -18071 0x11/imm32/alloc-id:fake:payload -18072 # "and" -18073 0x3/imm32/size -18074 0x61/a 0x6e/n 0x64/d -18075 _string-and-with: # (payload array byte) -18076 0x11/imm32/alloc-id:fake:payload -18077 # "and-with" -18078 0x8/imm32/size -18079 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18080 _string-break: # (payload array byte) -18081 0x11/imm32/alloc-id:fake:payload -18082 # "break" -18083 0x5/imm32/size -18084 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k -18085 _string-break-if-<: # (payload array byte) -18086 0x11/imm32/alloc-id:fake:payload -18087 # "break-if-<" -18088 0xa/imm32/size -18089 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -18090 _string-break-if-<=: # (payload array byte) -18091 0x11/imm32/alloc-id:fake:payload -18092 # "break-if-<=" -18093 0xb/imm32/size -18094 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -18095 _string-break-if-=: # (payload array byte) -18096 0x11/imm32/alloc-id:fake:payload -18097 # "break-if-=" -18098 0xa/imm32/size -18099 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -18100 _string-break-if->: # (payload array byte) -18101 0x11/imm32/alloc-id:fake:payload -18102 # "break-if->" -18103 0xa/imm32/size -18104 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -18105 _string-break-if->=: # (payload array byte) -18106 0x11/imm32/alloc-id:fake:payload -18107 # "break-if->=" -18108 0xb/imm32/size -18109 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -18110 _string-break-if-!=: # (payload array byte) -18111 0x11/imm32/alloc-id:fake:payload -18112 # "break-if-!=" -18113 0xb/imm32/size -18114 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -18115 _string-break-if-addr<: # (payload array byte) -18116 0x11/imm32/alloc-id:fake:payload -18117 # "break-if-addr<" -18118 0xe/imm32/size -18119 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< -18120 _string-break-if-addr<=: # (payload array byte) -18121 0x11/imm32/alloc-id:fake:payload -18122 # "break-if-addr<=" -18123 0xf/imm32/size -18124 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= -18125 _string-break-if-addr>: # (payload array byte) -18126 0x11/imm32/alloc-id:fake:payload -18127 # "break-if-addr>" -18128 0xe/imm32/size -18129 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> -18130 _string-break-if-addr>=: # (payload array byte) -18131 0x11/imm32/alloc-id:fake:payload -18132 # "break-if-addr>=" -18133 0xf/imm32/size -18134 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= -18135 _string-compare: # (payload array byte) -18136 0x11/imm32/alloc-id:fake:payload -18137 # "compare" -18138 0x7/imm32/size -18139 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e -18140 _string-copy: # (payload array byte) -18141 0x11/imm32/alloc-id:fake:payload -18142 # "copy" -18143 0x4/imm32/size -18144 0x63/c 0x6f/o 0x70/p 0x79/y -18145 _string-copy-to: # (payload array byte) -18146 0x11/imm32/alloc-id:fake:payload -18147 # "copy-to" -18148 0x7/imm32/size -18149 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o -18150 _string-copy-byte: -18151 0x11/imm32/alloc-id:fake:payload -18152 # "copy-byte" -18153 0x9/imm32/size -18154 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e -18155 _string-copy-byte-to: +18067 0x11/imm32/alloc-id:fake +18068 _string-loop-if-!=/imm32/name +18069 0x11/imm32/alloc-id:fake +18070 Single-lit-var/imm32/inouts +18071 0/imm32/no-outputs +18072 0/imm32/no-outputs +18073 0x11/imm32/alloc-id:fake +18074 _string_0f_85_jump_label/imm32/subx-name +18075 0/imm32/no-rm32 +18076 0/imm32/no-r32 +18077 0/imm32/no-imm32 +18078 0/imm32/no-imm8 +18079 1/imm32/disp32-is-first-inout +18080 0/imm32/no-output +18081 0x11/imm32/alloc-id:fake +18082 _Primitive-loop-if-addr<=-named/imm32/next +18083 _Primitive-loop-if-addr<=-named: # (payload primitive) +18084 0x11/imm32/alloc-id:fake:payload +18085 0x11/imm32/alloc-id:fake +18086 _string-loop-if-addr<=/imm32/name +18087 0x11/imm32/alloc-id:fake +18088 Single-lit-var/imm32/inouts +18089 0/imm32/no-outputs +18090 0/imm32/no-outputs +18091 0x11/imm32/alloc-id:fake +18092 _string_0f_86_jump_label/imm32/subx-name +18093 0/imm32/no-rm32 +18094 0/imm32/no-r32 +18095 0/imm32/no-imm32 +18096 0/imm32/no-imm8 +18097 1/imm32/disp32-is-first-inout +18098 0/imm32/no-output +18099 0x11/imm32/alloc-id:fake +18100 _Primitive-loop-if-addr>-named/imm32/next +18101 _Primitive-loop-if-addr>-named: # (payload primitive) +18102 0x11/imm32/alloc-id:fake:payload +18103 0x11/imm32/alloc-id:fake +18104 _string-loop-if-addr>/imm32/name +18105 0x11/imm32/alloc-id:fake +18106 Single-lit-var/imm32/inouts +18107 0/imm32/no-outputs +18108 0/imm32/no-outputs +18109 0x11/imm32/alloc-id:fake +18110 _string_0f_87_jump_label/imm32/subx-name +18111 0/imm32/no-rm32 +18112 0/imm32/no-r32 +18113 0/imm32/no-imm32 +18114 0/imm32/no-imm8 +18115 1/imm32/disp32-is-first-inout +18116 0/imm32/no-output +18117 0x11/imm32/alloc-id:fake +18118 _Primitive-loop-if-<-named/imm32/next +18119 _Primitive-loop-if-<-named: # (payload primitive) +18120 0x11/imm32/alloc-id:fake:payload +18121 0x11/imm32/alloc-id:fake +18122 _string-loop-if-</imm32/name +18123 0x11/imm32/alloc-id:fake +18124 Single-lit-var/imm32/inouts +18125 0/imm32/no-outputs +18126 0/imm32/no-outputs +18127 0x11/imm32/alloc-id:fake +18128 _string_0f_8c_jump_label/imm32/subx-name +18129 0/imm32/no-rm32 +18130 0/imm32/no-r32 +18131 0/imm32/no-imm32 +18132 0/imm32/no-imm8 +18133 1/imm32/disp32-is-first-inout +18134 0/imm32/no-output +18135 0x11/imm32/alloc-id:fake +18136 _Primitive-loop-if->=-named/imm32/next +18137 _Primitive-loop-if->=-named: # (payload primitive) +18138 0x11/imm32/alloc-id:fake:payload +18139 0x11/imm32/alloc-id:fake +18140 _string-loop-if->=/imm32/name +18141 0x11/imm32/alloc-id:fake +18142 Single-lit-var/imm32/inouts +18143 0/imm32/no-outputs +18144 0/imm32/no-outputs +18145 0x11/imm32/alloc-id:fake +18146 _string_0f_8d_jump_label/imm32/subx-name +18147 0/imm32/no-rm32 +18148 0/imm32/no-r32 +18149 0/imm32/no-imm32 +18150 0/imm32/no-imm8 +18151 1/imm32/disp32-is-first-inout +18152 0/imm32/no-output +18153 0x11/imm32/alloc-id:fake +18154 _Primitive-loop-if-<=-named/imm32/next +18155 _Primitive-loop-if-<=-named: # (payload primitive) 18156 0x11/imm32/alloc-id:fake:payload -18157 # "copy-byte-to" -18158 0xc/imm32/size -18159 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x74/t 0x6f/o -18160 _string-decrement: # (payload array byte) -18161 0x11/imm32/alloc-id:fake:payload -18162 # "decrement" -18163 0x9/imm32/size -18164 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -18165 _string-increment: # (payload array byte) -18166 0x11/imm32/alloc-id:fake:payload -18167 # "increment" -18168 0x9/imm32/size -18169 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -18170 _string-loop: # (payload array byte) -18171 0x11/imm32/alloc-id:fake:payload -18172 # "loop" -18173 0x4/imm32/size -18174 0x6c/l 0x6f/o 0x6f/o 0x70/p -18175 _string-loop-if-<: # (payload array byte) -18176 0x11/imm32/alloc-id:fake:payload -18177 # "loop-if-<" -18178 0x9/imm32/size -18179 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -18180 _string-loop-if-<=: # (payload array byte) -18181 0x11/imm32/alloc-id:fake:payload -18182 # "loop-if-<=" -18183 0xa/imm32/size -18184 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -18185 _string-loop-if-=: # (payload array byte) -18186 0x11/imm32/alloc-id:fake:payload -18187 # "loop-if-=" -18188 0x9/imm32/size -18189 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -18190 _string-loop-if->: # (payload array byte) -18191 0x11/imm32/alloc-id:fake:payload -18192 # "loop-if->" -18193 0x9/imm32/size -18194 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -18195 _string-loop-if->=: # (payload array byte) -18196 0x11/imm32/alloc-id:fake:payload -18197 # "loop-if->=" -18198 0xa/imm32/size -18199 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -18200 _string-loop-if-!=: # (payload array byte) -18201 0x11/imm32/alloc-id:fake:payload -18202 # "loop-if-!=" -18203 0xa/imm32/size -18204 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -18205 _string-loop-if-addr<: # (payload array byte) -18206 0x11/imm32/alloc-id:fake:payload -18207 # "loop-if-addr<" -18208 0xd/imm32/size -18209 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< -18210 _string-loop-if-addr<=: # (payload array byte) -18211 0x11/imm32/alloc-id:fake:payload -18212 # "loop-if-addr<=" -18213 0xe/imm32/size -18214 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= -18215 _string-loop-if-addr>: # (payload array byte) -18216 0x11/imm32/alloc-id:fake:payload -18217 # "loop-if-addr>" -18218 0xd/imm32/size -18219 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> -18220 _string-loop-if-addr>=: # (payload array byte) -18221 0x11/imm32/alloc-id:fake:payload -18222 # "loop-if-addr>=" -18223 0xe/imm32/size -18224 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= -18225 _string-multiply: # (payload array byte) -18226 0x11/imm32/alloc-id:fake:payload -18227 # "multiply" -18228 0x8/imm32/size -18229 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y -18230 _string-or: # (payload array byte) -18231 0x11/imm32/alloc-id:fake:payload -18232 # "or" -18233 0x2/imm32/size -18234 0x6f/o 0x72/r -18235 _string-or-with: # (payload array byte) -18236 0x11/imm32/alloc-id:fake:payload -18237 # "or-with" -18238 0x7/imm32/size -18239 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18240 _string-subtract: # (payload array byte) -18241 0x11/imm32/alloc-id:fake:payload -18242 # "subtract" -18243 0x8/imm32/size -18244 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -18245 _string-subtract-from: # (payload array byte) -18246 0x11/imm32/alloc-id:fake:payload -18247 # "subtract-from" -18248 0xd/imm32/size -18249 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m -18250 _string-xor: # (payload array byte) -18251 0x11/imm32/alloc-id:fake:payload -18252 # "xor" -18253 0x3/imm32/size -18254 0x78/x 0x6f/o 0x72/r -18255 _string-xor-with: # (payload array byte) -18256 0x11/imm32/alloc-id:fake:payload -18257 # "xor-with" -18258 0x8/imm32/size -18259 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18260 _string-shift-left: # (payload array byte) -18261 0x11/imm32/alloc-id:fake:payload -18262 # "shift-left" -18263 0xa/imm32/size -18264 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x6c/l 0x65/e 0x66/f 0x74/t -18265 _string-shift-right: # (payload array byte) -18266 0x11/imm32/alloc-id:fake:payload -18267 # "shift-right" -18268 0xb/imm32/size -18269 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t -18270 _string-shift-right-signed: # (payload array byte) -18271 0x11/imm32/alloc-id:fake:payload -18272 # "shift-right-signed" -18273 0x12/imm32/size -18274 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n 0x65/e 0x64/d -18275 -18276 # string literals for SubX instructions -18277 _string_01_add_to: # (payload array byte) -18278 0x11/imm32/alloc-id:fake:payload -18279 # "01/add-to" -18280 0x9/imm32/size -18281 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -18282 _string_03_add: # (payload array byte) -18283 0x11/imm32/alloc-id:fake:payload -18284 # "03/add" -18285 0x6/imm32/size -18286 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d -18287 _string_05_add_to_eax: # (payload array byte) -18288 0x11/imm32/alloc-id:fake:payload -18289 # "05/add-to-eax" -18290 0xd/imm32/size -18291 0x30/0 0x35/5 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x -18292 _string_09_or_with: # (payload array byte) -18293 0x11/imm32/alloc-id:fake:payload -18294 # "09/or-with" -18295 0xa/imm32/size -18296 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18297 _string_0b_or: # (payload array byte) -18298 0x11/imm32/alloc-id:fake:payload -18299 # "0b/or" -18300 0x5/imm32/size -18301 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r -18302 _string_0d_or_with_eax: # (payload array byte) -18303 0x11/imm32/alloc-id:fake:payload -18304 # "0d/or-with-eax" -18305 0xe/imm32/size -18306 0x30/0 0x64/d 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x -18307 _string_0f_82_jump_label: # (payload array byte) -18308 0x11/imm32/alloc-id:fake:payload -18309 # "0f 82/jump-if-addr<" -18310 0x13/imm32/size -18311 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< -18312 _string_0f_82_jump_break: # (payload array byte) -18313 0x11/imm32/alloc-id:fake:payload -18314 # "0f 82/jump-if-addr< break/disp32" -18315 0x20/imm32/size -18316 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18317 _string_0f_82_jump_loop: # (payload array byte) -18318 0x11/imm32/alloc-id:fake:payload -18319 # "0f 82/jump-if-addr< loop/disp32" -18320 0x1f/imm32/size -18321 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18322 _string_0f_83_jump_label: # (payload array byte) -18323 0x11/imm32/alloc-id:fake:payload -18324 # "0f 83/jump-if-addr>=" -18325 0x14/imm32/size -18326 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= -18327 _string_0f_83_jump_break: # (payload array byte) -18328 0x11/imm32/alloc-id:fake:payload -18329 # "0f 83/jump-if-addr>= break/disp32" -18330 0x21/imm32/size -18331 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18332 _string_0f_83_jump_loop: # (payload array byte) -18333 0x11/imm32/alloc-id:fake:payload -18334 # "0f 83/jump-if-addr>= loop/disp32" -18335 0x20/imm32/size -18336 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18337 _string_0f_84_jump_label: # (payload array byte) -18338 0x11/imm32/alloc-id:fake:payload -18339 # "0f 84/jump-if-=" -18340 0xf/imm32/size -18341 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -18342 _string_0f_84_jump_break: # (payload array byte) -18343 0x11/imm32/alloc-id:fake:payload -18344 # "0f 84/jump-if-= break/disp32" -18345 0x1c/imm32/size -18346 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18347 _string_0f_84_jump_loop: # (payload array byte) -18348 0x11/imm32/alloc-id:fake:payload -18349 # "0f 84/jump-if-= loop/disp32" -18350 0x1b/imm32/size -18351 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18352 _string_0f_85_jump_label: # (payload array byte) -18353 0x11/imm32/alloc-id:fake:payload -18354 # "0f 85/jump-if-!=" -18355 0x10/imm32/size -18356 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -18357 _string_0f_85_jump_break: # (payload array byte) -18358 0x11/imm32/alloc-id:fake:payload -18359 # "0f 85/jump-if-!= break/disp32" -18360 0x1d/imm32/size -18361 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18362 _string_0f_85_jump_loop: # (payload array byte) -18363 0x11/imm32/alloc-id:fake:payload -18364 # "0f 85/jump-if-!= loop/disp32" -18365 0x1c/imm32/size -18366 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18367 _string_0f_86_jump_label: # (payload array byte) -18368 0x11/imm32/alloc-id:fake:payload -18369 # "0f 86/jump-if-addr<=" -18370 0x14/imm32/size -18371 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= -18372 _string_0f_86_jump_break: # (payload array byte) -18373 0x11/imm32/alloc-id:fake:payload -18374 # "0f 86/jump-if-addr<= break/disp32" -18375 0x21/imm32/size -18376 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18377 _string_0f_86_jump_loop: # (payload array byte) -18378 0x11/imm32/alloc-id:fake:payload -18379 # "0f 86/jump-if-addr<= loop/disp32" -18380 0x20/imm32/size -18381 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18382 _string_0f_87_jump_label: # (payload array byte) -18383 0x11/imm32/alloc-id:fake:payload -18384 # "0f 87/jump-if-addr>" -18385 0x13/imm32/size -18386 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> -18387 _string_0f_87_jump_break: # (payload array byte) -18388 0x11/imm32/alloc-id:fake:payload -18389 # "0f 87/jump-if-addr> break/disp32" -18390 0x20/imm32/size -18391 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18392 _string_0f_87_jump_loop: # (payload array byte) -18393 0x11/imm32/alloc-id:fake:payload -18394 # "0f 87/jump-if-addr> loop/disp32" -18395 0x1f/imm32/size -18396 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18397 _string_0f_8c_jump_label: # (payload array byte) -18398 0x11/imm32/alloc-id:fake:payload -18399 # "0f 8c/jump-if-<" -18400 0xf/imm32/size -18401 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -18402 _string_0f_8c_jump_break: # (payload array byte) -18403 0x11/imm32/alloc-id:fake:payload -18404 # "0f 8c/jump-if-< break/disp32" -18405 0x1c/imm32/size -18406 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18407 _string_0f_8c_jump_loop: # (payload array byte) -18408 0x11/imm32/alloc-id:fake:payload -18409 # "0f 8c/jump-if-< loop/disp32" -18410 0x1b/imm32/size -18411 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18412 _string_0f_8d_jump_label: # (payload array byte) -18413 0x11/imm32/alloc-id:fake:payload -18414 # "0f 8d/jump-if->=" -18415 0x10/imm32/size -18416 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -18417 _string_0f_8d_jump_break: # (payload array byte) -18418 0x11/imm32/alloc-id:fake:payload -18419 # "0f 8d/jump-if->= break/disp32" -18420 0x1d/imm32/size -18421 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18422 _string_0f_8d_jump_loop: # (payload array byte) -18423 0x11/imm32/alloc-id:fake:payload -18424 # "0f 8d/jump-if->= loop/disp32" -18425 0x1c/imm32/size -18426 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18427 _string_0f_8e_jump_label: # (payload array byte) -18428 0x11/imm32/alloc-id:fake:payload -18429 # "0f 8e/jump-if-<=" -18430 0x10/imm32/size -18431 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -18432 _string_0f_8e_jump_break: # (payload array byte) -18433 0x11/imm32/alloc-id:fake:payload -18434 # "0f 8e/jump-if-<= break/disp32" -18435 0x1d/imm32/size -18436 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18437 _string_0f_8e_jump_loop: # (payload array byte) -18438 0x11/imm32/alloc-id:fake:payload -18439 # "0f 8e/jump-if-<= loop/disp32" -18440 0x1c/imm32/size -18441 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18442 _string_0f_8f_jump_label: # (payload array byte) -18443 0x11/imm32/alloc-id:fake:payload -18444 # "0f 8f/jump-if->" -18445 0xf/imm32/size -18446 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -18447 _string_0f_8f_jump_break: # (payload array byte) -18448 0x11/imm32/alloc-id:fake:payload -18449 # "0f 8f/jump-if-> break/disp32" -18450 0x1c/imm32/size -18451 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18452 _string_0f_8f_jump_loop: # (payload array byte) -18453 0x11/imm32/alloc-id:fake:payload -18454 # "0f 8f/jump-if-> loop/disp32" -18455 0x1b/imm32/size -18456 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18457 _string_0f_af_multiply: # (payload array byte) -18458 0x11/imm32/alloc-id:fake:payload -18459 # "0f af/multiply" -18460 0xe/imm32/size -18461 0x30/0 0x66/f 0x20/space 0x61/a 0x66/f 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y -18462 _string_21_and_with: # (payload array byte) -18463 0x11/imm32/alloc-id:fake:payload -18464 # "21/and-with" -18465 0xb/imm32/size -18466 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18467 _string_23_and: # (payload array byte) -18468 0x11/imm32/alloc-id:fake:payload -18469 # "23/and" -18470 0x6/imm32/size -18471 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d -18472 _string_25_and_with_eax: # (payload array byte) -18473 0x11/imm32/alloc-id:fake:payload -18474 # "25/and-with-eax" -18475 0xf/imm32/size -18476 0x32/2 0x35/5 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x -18477 _string_29_subtract_from: # (payload array byte) -18478 0x11/imm32/alloc-id:fake:payload -18479 # "29/subtract-from" -18480 0x10/imm32/size -18481 0x32/2 0x39/9 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m -18482 _string_2b_subtract: # (payload array byte) -18483 0x11/imm32/alloc-id:fake:payload -18484 # "2b/subtract" -18485 0xb/imm32/size -18486 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -18487 _string_2d_subtract_from_eax: # (payload array byte) -18488 0x11/imm32/alloc-id:fake:payload -18489 # "2d/subtract-from-eax" -18490 0x14/imm32/size -18491 0x32/2 0x64/d 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m 0x2d/dash 0x65/e 0x61/a 0x78/x -18492 _string_31_xor_with: # (payload array byte) -18493 0x11/imm32/alloc-id:fake:payload -18494 # "31/xor-with" -18495 0xb/imm32/size -18496 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18497 _string_33_xor: # (payload array byte) -18498 0x11/imm32/alloc-id:fake:payload -18499 # "33/xor" -18500 0x6/imm32/size -18501 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r -18502 _string_35_xor_with_eax: # (payload array byte) -18503 0x11/imm32/alloc-id:fake:payload -18504 # "35/xor-with-eax" -18505 0xf/imm32/size -18506 0x33/3 0x35/5 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x -18507 _string_39_compare->: # (payload array byte) -18508 0x11/imm32/alloc-id:fake:payload -18509 # "39/compare->" -18510 0xc/imm32/size -18511 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> -18512 _string_3b_compare<-: # (payload array byte) -18513 0x11/imm32/alloc-id:fake:payload -18514 # "3b/compare<-" -18515 0xc/imm32/size -18516 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash -18517 _string_3d_compare_eax_with: # (payload array byte) -18518 0x11/imm32/alloc-id:fake:payload -18519 # "3d/compare-eax-with" -18520 0x13/imm32/size -18521 0x33/3 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x65/e 0x61/a 0x78/x 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -18522 _string_40_increment_eax: # (payload array byte) -18523 0x11/imm32/alloc-id:fake:payload -18524 # "40/increment-eax" -18525 0x10/imm32/size -18526 0x34/4 0x30/0 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x -18527 _string_41_increment_ecx: # (payload array byte) -18528 0x11/imm32/alloc-id:fake:payload -18529 # "41/increment-ecx" -18530 0x10/imm32/size -18531 0x34/4 0x31/1 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x -18532 _string_42_increment_edx: # (payload array byte) -18533 0x11/imm32/alloc-id:fake:payload -18534 # "42/increment-edx" -18535 0x10/imm32/size -18536 0x34/4 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x -18537 _string_43_increment_ebx: # (payload array byte) -18538 0x11/imm32/alloc-id:fake:payload -18539 # "43/increment-ebx" -18540 0x10/imm32/size -18541 0x34/4 0x33/3 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x -18542 _string_46_increment_esi: # (payload array byte) -18543 0x11/imm32/alloc-id:fake:payload -18544 # "46/increment-esi" -18545 0x10/imm32/size -18546 0x34/4 0x36/6 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i -18547 _string_47_increment_edi: # (payload array byte) -18548 0x11/imm32/alloc-id:fake:payload -18549 # "47/increment-edi" -18550 0x10/imm32/size -18551 0x34/4 0x37/7 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i -18552 _string_48_decrement_eax: # (payload array byte) -18553 0x11/imm32/alloc-id:fake:payload -18554 # "48/decrement-eax" -18555 0x10/imm32/size -18556 0x34/4 0x38/8 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x -18557 _string_49_decrement_ecx: # (payload array byte) -18558 0x11/imm32/alloc-id:fake:payload -18559 # "49/decrement-ecx" -18560 0x10/imm32/size -18561 0x34/4 0x39/9 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x -18562 _string_4a_decrement_edx: # (payload array byte) -18563 0x11/imm32/alloc-id:fake:payload -18564 # "4a/decrement-edx" -18565 0x10/imm32/size -18566 0x34/4 0x61/a 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x -18567 _string_4b_decrement_ebx: # (payload array byte) -18568 0x11/imm32/alloc-id:fake:payload -18569 # "4b/decrement-ebx" -18570 0x10/imm32/size -18571 0x34/4 0x62/b 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x -18572 _string_4e_decrement_esi: # (payload array byte) -18573 0x11/imm32/alloc-id:fake:payload -18574 # "4e/decrement-esi" -18575 0x10/imm32/size -18576 0x34/4 0x65/e 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i -18577 _string_4f_decrement_edi: # (payload array byte) -18578 0x11/imm32/alloc-id:fake:payload -18579 # "4f/decrement-edi" -18580 0x10/imm32/size -18581 0x34/4 0x66/f 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i -18582 _string_81_subop_add: # (payload array byte) -18583 0x11/imm32/alloc-id:fake:payload -18584 # "81 0/subop/add" -18585 0xe/imm32/size -18586 0x38/8 0x31/1 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x64/d 0x64/d -18587 _string_81_subop_or: # (payload array byte) -18588 0x11/imm32/alloc-id:fake:payload -18589 # "81 1/subop/or" -18590 0xd/imm32/size -18591 0x38/8 0x31/1 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6f/o 0x72/r -18592 _string_81_subop_and: # (payload array byte) -18593 0x11/imm32/alloc-id:fake:payload -18594 # "81 4/subop/and" -18595 0xe/imm32/size -18596 0x38/8 0x31/1 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x6e/n 0x64/d -18597 _string_81_subop_subtract: # (payload array byte) -18598 0x11/imm32/alloc-id:fake:payload -18599 # "81 5/subop/subtract" -18600 0x13/imm32/size -18601 0x38/8 0x31/1 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -18602 _string_81_subop_xor: # (payload array byte) -18603 0x11/imm32/alloc-id:fake:payload -18604 # "81 6/subop/xor" -18605 0xe/imm32/size -18606 0x38/8 0x31/1 0x20/space 0x36/6 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x78/x 0x6f/o 0x72/r -18607 _string_81_subop_compare: # (payload array byte) -18608 0x11/imm32/alloc-id:fake:payload -18609 # "81 7/subop/compare" -18610 0x12/imm32/size -18611 0x38/8 0x31/1 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e -18612 _string_89_<-: # (payload array byte) -18613 0x11/imm32/alloc-id:fake:payload -18614 # "89/<-" -18615 0x5/imm32/size -18616 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash -18617 _string_8b_->: # (payload array byte) -18618 0x11/imm32/alloc-id:fake:payload -18619 # "8b/->" -18620 0x5/imm32/size -18621 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> -18622 _string_8a_copy_byte: -18623 0x11/imm32/alloc-id:fake:payload -18624 # "8a/byte->" -18625 0x9/imm32/size -18626 0x38/8 0x61/a 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x3e/> -18627 _string_88_copy_byte: -18628 0x11/imm32/alloc-id:fake:payload -18629 # "88/byte<-" -18630 0x9/imm32/size -18631 0x38/8 0x38/8 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x3c/< 0x2d/- -18632 _string_8d_copy_address: # (payload array byte) -18633 0x11/imm32/alloc-id:fake:payload -18634 # "8d/copy-address" -18635 0xf/imm32/size -18636 0x38/8 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s -18637 _string_b8_copy_to_eax: # (payload array byte) -18638 0x11/imm32/alloc-id:fake:payload -18639 # "b8/copy-to-eax" -18640 0xe/imm32/size -18641 0x62/b 0x38/8 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x -18642 _string_b9_copy_to_ecx: # (payload array byte) -18643 0x11/imm32/alloc-id:fake:payload -18644 # "b9/copy-to-ecx" -18645 0xe/imm32/size -18646 0x62/b 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x63/c 0x78/x -18647 _string_ba_copy_to_edx: # (payload array byte) -18648 0x11/imm32/alloc-id:fake:payload -18649 # "ba/copy-to-edx" -18650 0xe/imm32/size -18651 0x62/b 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x78/x -18652 _string_bb_copy_to_ebx: # (payload array byte) -18653 0x11/imm32/alloc-id:fake:payload -18654 # "bb/copy-to-ebx" -18655 0xe/imm32/size -18656 0x62/b 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x62/b 0x78/x -18657 _string_be_copy_to_esi: # (payload array byte) -18658 0x11/imm32/alloc-id:fake:payload -18659 # "be/copy-to-esi" -18660 0xe/imm32/size -18661 0x62/b 0x65/e 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x73/s 0x69/i -18662 _string_bf_copy_to_edi: # (payload array byte) -18663 0x11/imm32/alloc-id:fake:payload -18664 # "bf/copy-to-edi" -18665 0xe/imm32/size -18666 0x62/b 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x69/i -18667 _string_c7_subop_copy: # (payload array byte) -18668 0x11/imm32/alloc-id:fake:payload -18669 # "c7 0/subop/copy" -18670 0xf/imm32/size -18671 0x63/c 0x37/7 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y -18672 _string_e9_jump_label: # (payload array byte) -18673 0x11/imm32/alloc-id:fake:payload -18674 # "e9/jump" -18675 0x7/imm32/size -18676 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p -18677 _string_e9_jump_break: # (payload array byte) -18678 0x11/imm32/alloc-id:fake:payload -18679 # "e9/jump break/disp32" -18680 0x14/imm32/size -18681 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18682 _string_e9_jump_loop: # (payload array byte) -18683 0x11/imm32/alloc-id:fake:payload -18684 # "e9/jump loop/disp32" -18685 0x13/imm32/size -18686 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 -18687 _string_ff_subop_increment: # (payload array byte) -18688 0x11/imm32/alloc-id:fake:payload -18689 # "ff 0/subop/increment" -18690 0x14/imm32/size -18691 0x66/f 0x66/f 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -18692 _string_ff_subop_decrement: # (payload array byte) -18693 0x11/imm32/alloc-id:fake:payload -18694 # "ff 1/subop/decrement" -18695 0x14/imm32/size -18696 0x66/f 0x66/f 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -18697 _string_c1_subop_shift_left: # (payload array byte) -18698 0x11/imm32/alloc-id:fake:payload -18699 # "c1/shift 4/subop/left" -18700 0x15/imm32/size -18701 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6c/l 0x65/e 0x66/f 0x74/t -18702 _string_c1_subop_shift_right_padding_zeroes: # (payload array byte) -18703 0x11/imm32/alloc-id:fake:payload -18704 # "c1/shift 5/subop/right-padding-zeroes" -18705 0x25/imm32/size -18706 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x61/a 0x64/d 0x64/d 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x7a/z 0x65/e 0x72/r 0x6f/o 0x65/e 0x73/s -18707 _string_c1_subop_shift_right_preserving_sign: # (payload array byte) -18708 0x11/imm32/alloc-id:fake:payload -18709 # "c1/shift 7/subop/right-preserving-sign" -18710 0x26/imm32/size -18711 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x72/r 0x65/e 0x73/s 0x65/e 0x72/r 0x76/v 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n -18712 -18713 Single-int-var-in-mem: # (payload list var) +18157 0x11/imm32/alloc-id:fake +18158 _string-loop-if-<=/imm32/name +18159 0x11/imm32/alloc-id:fake +18160 Single-lit-var/imm32/inouts +18161 0/imm32/no-outputs +18162 0/imm32/no-outputs +18163 0x11/imm32/alloc-id:fake +18164 _string_0f_8e_jump_label/imm32/subx-name +18165 0/imm32/no-rm32 +18166 0/imm32/no-r32 +18167 0/imm32/no-imm32 +18168 0/imm32/no-imm8 +18169 1/imm32/disp32-is-first-inout +18170 0/imm32/no-output +18171 0x11/imm32/alloc-id:fake +18172 _Primitive-loop-if->-named/imm32/next +18173 _Primitive-loop-if->-named: # (payload primitive) +18174 0x11/imm32/alloc-id:fake:payload +18175 0x11/imm32/alloc-id:fake +18176 _string-loop-if->/imm32/name +18177 0x11/imm32/alloc-id:fake +18178 Single-lit-var/imm32/inouts +18179 0/imm32/no-outputs +18180 0/imm32/no-outputs +18181 0x11/imm32/alloc-id:fake +18182 _string_0f_8f_jump_label/imm32/subx-name +18183 0/imm32/no-rm32 +18184 0/imm32/no-r32 +18185 0/imm32/no-imm32 +18186 0/imm32/no-imm8 +18187 1/imm32/disp32-is-first-inout +18188 0/imm32/no-output +18189 0x11/imm32/alloc-id:fake +18190 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break +18191 _Primitive-loop-named: # (payload primitive) +18192 0x11/imm32/alloc-id:fake:payload +18193 0x11/imm32/alloc-id:fake +18194 _string-loop/imm32/name +18195 0x11/imm32/alloc-id:fake +18196 Single-lit-var/imm32/inouts +18197 0/imm32/no-outputs +18198 0/imm32/no-outputs +18199 0x11/imm32/alloc-id:fake +18200 _string_e9_jump_label/imm32/subx-name +18201 0/imm32/no-rm32 +18202 0/imm32/no-r32 +18203 0/imm32/no-imm32 +18204 0/imm32/no-imm8 +18205 1/imm32/disp32-is-first-inout +18206 0/imm32/no-output +18207 0/imm32/next +18208 0/imm32/next +18209 +18210 # string literals for Mu instructions +18211 _string-add: # (payload array byte) +18212 0x11/imm32/alloc-id:fake:payload +18213 # "add" +18214 0x3/imm32/size +18215 0x61/a 0x64/d 0x64/d +18216 _string-address: # (payload array byte) +18217 0x11/imm32/alloc-id:fake:payload +18218 # "address" +18219 0x7/imm32/size +18220 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s +18221 _string-add-to: # (payload array byte) +18222 0x11/imm32/alloc-id:fake:payload +18223 # "add-to" +18224 0x6/imm32/size +18225 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +18226 _string-and: # (payload array byte) +18227 0x11/imm32/alloc-id:fake:payload +18228 # "and" +18229 0x3/imm32/size +18230 0x61/a 0x6e/n 0x64/d +18231 _string-and-with: # (payload array byte) +18232 0x11/imm32/alloc-id:fake:payload +18233 # "and-with" +18234 0x8/imm32/size +18235 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18236 _string-break: # (payload array byte) +18237 0x11/imm32/alloc-id:fake:payload +18238 # "break" +18239 0x5/imm32/size +18240 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k +18241 _string-break-if-<: # (payload array byte) +18242 0x11/imm32/alloc-id:fake:payload +18243 # "break-if-<" +18244 0xa/imm32/size +18245 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +18246 _string-break-if-<=: # (payload array byte) +18247 0x11/imm32/alloc-id:fake:payload +18248 # "break-if-<=" +18249 0xb/imm32/size +18250 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +18251 _string-break-if-=: # (payload array byte) +18252 0x11/imm32/alloc-id:fake:payload +18253 # "break-if-=" +18254 0xa/imm32/size +18255 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +18256 _string-break-if->: # (payload array byte) +18257 0x11/imm32/alloc-id:fake:payload +18258 # "break-if->" +18259 0xa/imm32/size +18260 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +18261 _string-break-if->=: # (payload array byte) +18262 0x11/imm32/alloc-id:fake:payload +18263 # "break-if->=" +18264 0xb/imm32/size +18265 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +18266 _string-break-if-!=: # (payload array byte) +18267 0x11/imm32/alloc-id:fake:payload +18268 # "break-if-!=" +18269 0xb/imm32/size +18270 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +18271 _string-break-if-addr<: # (payload array byte) +18272 0x11/imm32/alloc-id:fake:payload +18273 # "break-if-addr<" +18274 0xe/imm32/size +18275 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< +18276 _string-break-if-addr<=: # (payload array byte) +18277 0x11/imm32/alloc-id:fake:payload +18278 # "break-if-addr<=" +18279 0xf/imm32/size +18280 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= +18281 _string-break-if-addr>: # (payload array byte) +18282 0x11/imm32/alloc-id:fake:payload +18283 # "break-if-addr>" +18284 0xe/imm32/size +18285 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> +18286 _string-break-if-addr>=: # (payload array byte) +18287 0x11/imm32/alloc-id:fake:payload +18288 # "break-if-addr>=" +18289 0xf/imm32/size +18290 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= +18291 _string-compare: # (payload array byte) +18292 0x11/imm32/alloc-id:fake:payload +18293 # "compare" +18294 0x7/imm32/size +18295 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e +18296 _string-copy: # (payload array byte) +18297 0x11/imm32/alloc-id:fake:payload +18298 # "copy" +18299 0x4/imm32/size +18300 0x63/c 0x6f/o 0x70/p 0x79/y +18301 _string-copy-to: # (payload array byte) +18302 0x11/imm32/alloc-id:fake:payload +18303 # "copy-to" +18304 0x7/imm32/size +18305 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o +18306 _string-copy-byte: +18307 0x11/imm32/alloc-id:fake:payload +18308 # "copy-byte" +18309 0x9/imm32/size +18310 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e +18311 _string-copy-byte-to: +18312 0x11/imm32/alloc-id:fake:payload +18313 # "copy-byte-to" +18314 0xc/imm32/size +18315 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x74/t 0x6f/o +18316 _string-decrement: # (payload array byte) +18317 0x11/imm32/alloc-id:fake:payload +18318 # "decrement" +18319 0x9/imm32/size +18320 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +18321 _string-increment: # (payload array byte) +18322 0x11/imm32/alloc-id:fake:payload +18323 # "increment" +18324 0x9/imm32/size +18325 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +18326 _string-loop: # (payload array byte) +18327 0x11/imm32/alloc-id:fake:payload +18328 # "loop" +18329 0x4/imm32/size +18330 0x6c/l 0x6f/o 0x6f/o 0x70/p +18331 _string-loop-if-<: # (payload array byte) +18332 0x11/imm32/alloc-id:fake:payload +18333 # "loop-if-<" +18334 0x9/imm32/size +18335 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +18336 _string-loop-if-<=: # (payload array byte) +18337 0x11/imm32/alloc-id:fake:payload +18338 # "loop-if-<=" +18339 0xa/imm32/size +18340 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +18341 _string-loop-if-=: # (payload array byte) +18342 0x11/imm32/alloc-id:fake:payload +18343 # "loop-if-=" +18344 0x9/imm32/size +18345 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +18346 _string-loop-if->: # (payload array byte) +18347 0x11/imm32/alloc-id:fake:payload +18348 # "loop-if->" +18349 0x9/imm32/size +18350 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +18351 _string-loop-if->=: # (payload array byte) +18352 0x11/imm32/alloc-id:fake:payload +18353 # "loop-if->=" +18354 0xa/imm32/size +18355 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +18356 _string-loop-if-!=: # (payload array byte) +18357 0x11/imm32/alloc-id:fake:payload +18358 # "loop-if-!=" +18359 0xa/imm32/size +18360 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +18361 _string-loop-if-addr<: # (payload array byte) +18362 0x11/imm32/alloc-id:fake:payload +18363 # "loop-if-addr<" +18364 0xd/imm32/size +18365 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< +18366 _string-loop-if-addr<=: # (payload array byte) +18367 0x11/imm32/alloc-id:fake:payload +18368 # "loop-if-addr<=" +18369 0xe/imm32/size +18370 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= +18371 _string-loop-if-addr>: # (payload array byte) +18372 0x11/imm32/alloc-id:fake:payload +18373 # "loop-if-addr>" +18374 0xd/imm32/size +18375 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> +18376 _string-loop-if-addr>=: # (payload array byte) +18377 0x11/imm32/alloc-id:fake:payload +18378 # "loop-if-addr>=" +18379 0xe/imm32/size +18380 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= +18381 _string-multiply: # (payload array byte) +18382 0x11/imm32/alloc-id:fake:payload +18383 # "multiply" +18384 0x8/imm32/size +18385 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y +18386 _string-or: # (payload array byte) +18387 0x11/imm32/alloc-id:fake:payload +18388 # "or" +18389 0x2/imm32/size +18390 0x6f/o 0x72/r +18391 _string-or-with: # (payload array byte) +18392 0x11/imm32/alloc-id:fake:payload +18393 # "or-with" +18394 0x7/imm32/size +18395 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18396 _string-subtract: # (payload array byte) +18397 0x11/imm32/alloc-id:fake:payload +18398 # "subtract" +18399 0x8/imm32/size +18400 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +18401 _string-subtract-from: # (payload array byte) +18402 0x11/imm32/alloc-id:fake:payload +18403 # "subtract-from" +18404 0xd/imm32/size +18405 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m +18406 _string-xor: # (payload array byte) +18407 0x11/imm32/alloc-id:fake:payload +18408 # "xor" +18409 0x3/imm32/size +18410 0x78/x 0x6f/o 0x72/r +18411 _string-xor-with: # (payload array byte) +18412 0x11/imm32/alloc-id:fake:payload +18413 # "xor-with" +18414 0x8/imm32/size +18415 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18416 _string-shift-left: # (payload array byte) +18417 0x11/imm32/alloc-id:fake:payload +18418 # "shift-left" +18419 0xa/imm32/size +18420 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x6c/l 0x65/e 0x66/f 0x74/t +18421 _string-shift-right: # (payload array byte) +18422 0x11/imm32/alloc-id:fake:payload +18423 # "shift-right" +18424 0xb/imm32/size +18425 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t +18426 _string-shift-right-signed: # (payload array byte) +18427 0x11/imm32/alloc-id:fake:payload +18428 # "shift-right-signed" +18429 0x12/imm32/size +18430 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n 0x65/e 0x64/d +18431 +18432 # string literals for SubX instructions +18433 _string_01_add_to: # (payload array byte) +18434 0x11/imm32/alloc-id:fake:payload +18435 # "01/add-to" +18436 0x9/imm32/size +18437 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +18438 _string_03_add: # (payload array byte) +18439 0x11/imm32/alloc-id:fake:payload +18440 # "03/add" +18441 0x6/imm32/size +18442 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d +18443 _string_05_add_to_eax: # (payload array byte) +18444 0x11/imm32/alloc-id:fake:payload +18445 # "05/add-to-eax" +18446 0xd/imm32/size +18447 0x30/0 0x35/5 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x +18448 _string_09_or_with: # (payload array byte) +18449 0x11/imm32/alloc-id:fake:payload +18450 # "09/or-with" +18451 0xa/imm32/size +18452 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18453 _string_0b_or: # (payload array byte) +18454 0x11/imm32/alloc-id:fake:payload +18455 # "0b/or" +18456 0x5/imm32/size +18457 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r +18458 _string_0d_or_with_eax: # (payload array byte) +18459 0x11/imm32/alloc-id:fake:payload +18460 # "0d/or-with-eax" +18461 0xe/imm32/size +18462 0x30/0 0x64/d 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x +18463 _string_0f_82_jump_label: # (payload array byte) +18464 0x11/imm32/alloc-id:fake:payload +18465 # "0f 82/jump-if-addr<" +18466 0x13/imm32/size +18467 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< +18468 _string_0f_82_jump_break: # (payload array byte) +18469 0x11/imm32/alloc-id:fake:payload +18470 # "0f 82/jump-if-addr< break/disp32" +18471 0x20/imm32/size +18472 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18473 _string_0f_82_jump_loop: # (payload array byte) +18474 0x11/imm32/alloc-id:fake:payload +18475 # "0f 82/jump-if-addr< loop/disp32" +18476 0x1f/imm32/size +18477 0x30/0 0x66/f 0x20/space 0x38/8 0x32/2 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18478 _string_0f_83_jump_label: # (payload array byte) +18479 0x11/imm32/alloc-id:fake:payload +18480 # "0f 83/jump-if-addr>=" +18481 0x14/imm32/size +18482 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= +18483 _string_0f_83_jump_break: # (payload array byte) +18484 0x11/imm32/alloc-id:fake:payload +18485 # "0f 83/jump-if-addr>= break/disp32" +18486 0x21/imm32/size +18487 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18488 _string_0f_83_jump_loop: # (payload array byte) +18489 0x11/imm32/alloc-id:fake:payload +18490 # "0f 83/jump-if-addr>= loop/disp32" +18491 0x20/imm32/size +18492 0x30/0 0x66/f 0x20/space 0x38/8 0x33/3 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18493 _string_0f_84_jump_label: # (payload array byte) +18494 0x11/imm32/alloc-id:fake:payload +18495 # "0f 84/jump-if-=" +18496 0xf/imm32/size +18497 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +18498 _string_0f_84_jump_break: # (payload array byte) +18499 0x11/imm32/alloc-id:fake:payload +18500 # "0f 84/jump-if-= break/disp32" +18501 0x1c/imm32/size +18502 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18503 _string_0f_84_jump_loop: # (payload array byte) +18504 0x11/imm32/alloc-id:fake:payload +18505 # "0f 84/jump-if-= loop/disp32" +18506 0x1b/imm32/size +18507 0x30/0 0x66/f 0x20/space 0x38/8 0x34/4 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18508 _string_0f_85_jump_label: # (payload array byte) +18509 0x11/imm32/alloc-id:fake:payload +18510 # "0f 85/jump-if-!=" +18511 0x10/imm32/size +18512 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +18513 _string_0f_85_jump_break: # (payload array byte) +18514 0x11/imm32/alloc-id:fake:payload +18515 # "0f 85/jump-if-!= break/disp32" +18516 0x1d/imm32/size +18517 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18518 _string_0f_85_jump_loop: # (payload array byte) +18519 0x11/imm32/alloc-id:fake:payload +18520 # "0f 85/jump-if-!= loop/disp32" +18521 0x1c/imm32/size +18522 0x30/0 0x66/f 0x20/space 0x38/8 0x35/5 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18523 _string_0f_86_jump_label: # (payload array byte) +18524 0x11/imm32/alloc-id:fake:payload +18525 # "0f 86/jump-if-addr<=" +18526 0x14/imm32/size +18527 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= +18528 _string_0f_86_jump_break: # (payload array byte) +18529 0x11/imm32/alloc-id:fake:payload +18530 # "0f 86/jump-if-addr<= break/disp32" +18531 0x21/imm32/size +18532 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18533 _string_0f_86_jump_loop: # (payload array byte) +18534 0x11/imm32/alloc-id:fake:payload +18535 # "0f 86/jump-if-addr<= loop/disp32" +18536 0x20/imm32/size +18537 0x30/0 0x66/f 0x20/space 0x38/8 0x36/6 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18538 _string_0f_87_jump_label: # (payload array byte) +18539 0x11/imm32/alloc-id:fake:payload +18540 # "0f 87/jump-if-addr>" +18541 0x13/imm32/size +18542 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> +18543 _string_0f_87_jump_break: # (payload array byte) +18544 0x11/imm32/alloc-id:fake:payload +18545 # "0f 87/jump-if-addr> break/disp32" +18546 0x20/imm32/size +18547 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18548 _string_0f_87_jump_loop: # (payload array byte) +18549 0x11/imm32/alloc-id:fake:payload +18550 # "0f 87/jump-if-addr> loop/disp32" +18551 0x1f/imm32/size +18552 0x30/0 0x66/f 0x20/space 0x38/8 0x37/7 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18553 _string_0f_8c_jump_label: # (payload array byte) +18554 0x11/imm32/alloc-id:fake:payload +18555 # "0f 8c/jump-if-<" +18556 0xf/imm32/size +18557 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +18558 _string_0f_8c_jump_break: # (payload array byte) +18559 0x11/imm32/alloc-id:fake:payload +18560 # "0f 8c/jump-if-< break/disp32" +18561 0x1c/imm32/size +18562 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18563 _string_0f_8c_jump_loop: # (payload array byte) +18564 0x11/imm32/alloc-id:fake:payload +18565 # "0f 8c/jump-if-< loop/disp32" +18566 0x1b/imm32/size +18567 0x30/0 0x66/f 0x20/space 0x38/8 0x63/c 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18568 _string_0f_8d_jump_label: # (payload array byte) +18569 0x11/imm32/alloc-id:fake:payload +18570 # "0f 8d/jump-if->=" +18571 0x10/imm32/size +18572 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +18573 _string_0f_8d_jump_break: # (payload array byte) +18574 0x11/imm32/alloc-id:fake:payload +18575 # "0f 8d/jump-if->= break/disp32" +18576 0x1d/imm32/size +18577 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18578 _string_0f_8d_jump_loop: # (payload array byte) +18579 0x11/imm32/alloc-id:fake:payload +18580 # "0f 8d/jump-if->= loop/disp32" +18581 0x1c/imm32/size +18582 0x30/0 0x66/f 0x20/space 0x38/8 0x64/d 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18583 _string_0f_8e_jump_label: # (payload array byte) +18584 0x11/imm32/alloc-id:fake:payload +18585 # "0f 8e/jump-if-<=" +18586 0x10/imm32/size +18587 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +18588 _string_0f_8e_jump_break: # (payload array byte) +18589 0x11/imm32/alloc-id:fake:payload +18590 # "0f 8e/jump-if-<= break/disp32" +18591 0x1d/imm32/size +18592 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18593 _string_0f_8e_jump_loop: # (payload array byte) +18594 0x11/imm32/alloc-id:fake:payload +18595 # "0f 8e/jump-if-<= loop/disp32" +18596 0x1c/imm32/size +18597 0x30/0 0x66/f 0x20/space 0x38/8 0x65/e 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18598 _string_0f_8f_jump_label: # (payload array byte) +18599 0x11/imm32/alloc-id:fake:payload +18600 # "0f 8f/jump-if->" +18601 0xf/imm32/size +18602 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +18603 _string_0f_8f_jump_break: # (payload array byte) +18604 0x11/imm32/alloc-id:fake:payload +18605 # "0f 8f/jump-if-> break/disp32" +18606 0x1c/imm32/size +18607 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18608 _string_0f_8f_jump_loop: # (payload array byte) +18609 0x11/imm32/alloc-id:fake:payload +18610 # "0f 8f/jump-if-> loop/disp32" +18611 0x1b/imm32/size +18612 0x30/0 0x66/f 0x20/space 0x38/8 0x66/f 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18613 _string_0f_af_multiply: # (payload array byte) +18614 0x11/imm32/alloc-id:fake:payload +18615 # "0f af/multiply" +18616 0xe/imm32/size +18617 0x30/0 0x66/f 0x20/space 0x61/a 0x66/f 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y +18618 _string_21_and_with: # (payload array byte) +18619 0x11/imm32/alloc-id:fake:payload +18620 # "21/and-with" +18621 0xb/imm32/size +18622 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18623 _string_23_and: # (payload array byte) +18624 0x11/imm32/alloc-id:fake:payload +18625 # "23/and" +18626 0x6/imm32/size +18627 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d +18628 _string_25_and_with_eax: # (payload array byte) +18629 0x11/imm32/alloc-id:fake:payload +18630 # "25/and-with-eax" +18631 0xf/imm32/size +18632 0x32/2 0x35/5 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x +18633 _string_29_subtract_from: # (payload array byte) +18634 0x11/imm32/alloc-id:fake:payload +18635 # "29/subtract-from" +18636 0x10/imm32/size +18637 0x32/2 0x39/9 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m +18638 _string_2b_subtract: # (payload array byte) +18639 0x11/imm32/alloc-id:fake:payload +18640 # "2b/subtract" +18641 0xb/imm32/size +18642 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +18643 _string_2d_subtract_from_eax: # (payload array byte) +18644 0x11/imm32/alloc-id:fake:payload +18645 # "2d/subtract-from-eax" +18646 0x14/imm32/size +18647 0x32/2 0x64/d 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t 0x2d/dash 0x66/f 0x72/r 0x6f/o 0x6d/m 0x2d/dash 0x65/e 0x61/a 0x78/x +18648 _string_31_xor_with: # (payload array byte) +18649 0x11/imm32/alloc-id:fake:payload +18650 # "31/xor-with" +18651 0xb/imm32/size +18652 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18653 _string_33_xor: # (payload array byte) +18654 0x11/imm32/alloc-id:fake:payload +18655 # "33/xor" +18656 0x6/imm32/size +18657 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r +18658 _string_35_xor_with_eax: # (payload array byte) +18659 0x11/imm32/alloc-id:fake:payload +18660 # "35/xor-with-eax" +18661 0xf/imm32/size +18662 0x33/3 0x35/5 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h 0x2d/dash 0x65/e 0x61/a 0x78/x +18663 _string_39_compare->: # (payload array byte) +18664 0x11/imm32/alloc-id:fake:payload +18665 # "39/compare->" +18666 0xc/imm32/size +18667 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> +18668 _string_3b_compare<-: # (payload array byte) +18669 0x11/imm32/alloc-id:fake:payload +18670 # "3b/compare<-" +18671 0xc/imm32/size +18672 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash +18673 _string_3d_compare_eax_with: # (payload array byte) +18674 0x11/imm32/alloc-id:fake:payload +18675 # "3d/compare-eax-with" +18676 0x13/imm32/size +18677 0x33/3 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x65/e 0x61/a 0x78/x 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +18678 _string_40_increment_eax: # (payload array byte) +18679 0x11/imm32/alloc-id:fake:payload +18680 # "40/increment-eax" +18681 0x10/imm32/size +18682 0x34/4 0x30/0 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x +18683 _string_41_increment_ecx: # (payload array byte) +18684 0x11/imm32/alloc-id:fake:payload +18685 # "41/increment-ecx" +18686 0x10/imm32/size +18687 0x34/4 0x31/1 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x +18688 _string_42_increment_edx: # (payload array byte) +18689 0x11/imm32/alloc-id:fake:payload +18690 # "42/increment-edx" +18691 0x10/imm32/size +18692 0x34/4 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x +18693 _string_43_increment_ebx: # (payload array byte) +18694 0x11/imm32/alloc-id:fake:payload +18695 # "43/increment-ebx" +18696 0x10/imm32/size +18697 0x34/4 0x33/3 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x +18698 _string_46_increment_esi: # (payload array byte) +18699 0x11/imm32/alloc-id:fake:payload +18700 # "46/increment-esi" +18701 0x10/imm32/size +18702 0x34/4 0x36/6 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i +18703 _string_47_increment_edi: # (payload array byte) +18704 0x11/imm32/alloc-id:fake:payload +18705 # "47/increment-edi" +18706 0x10/imm32/size +18707 0x34/4 0x37/7 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i +18708 _string_48_decrement_eax: # (payload array byte) +18709 0x11/imm32/alloc-id:fake:payload +18710 # "48/decrement-eax" +18711 0x10/imm32/size +18712 0x34/4 0x38/8 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x61/a 0x78/x +18713 _string_49_decrement_ecx: # (payload array byte) 18714 0x11/imm32/alloc-id:fake:payload -18715 0x11/imm32/alloc-id:fake -18716 Int-var-in-mem/imm32 -18717 0/imm32/next -18718 0/imm32/next -18719 -18720 Int-var-in-mem: # (payload var) -18721 0x11/imm32/alloc-id:fake:payload -18722 0/imm32/name -18723 0/imm32/name -18724 0x11/imm32/alloc-id:fake -18725 Type-int/imm32 -18726 1/imm32/some-block-depth -18727 1/imm32/some-stack-offset -18728 0/imm32/no-register -18729 0/imm32/no-register -18730 -18731 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -18732 Single-byte-var-in-mem: # (payload list var) -18733 0x11/imm32/alloc-id:fake:payload -18734 0x11/imm32/alloc-id:fake -18735 Byte-var-in-mem/imm32 -18736 0/imm32/next -18737 0/imm32/next -18738 -18739 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -18740 Byte-var-in-mem: # (payload var) -18741 0x11/imm32/alloc-id:fake:payload -18742 0/imm32/name -18743 0/imm32/name -18744 0x11/imm32/alloc-id:fake -18745 Type-byte/imm32 -18746 1/imm32/some-block-depth -18747 1/imm32/some-stack-offset -18748 0/imm32/no-register -18749 0/imm32/no-register -18750 -18751 Two-args-int-stack-int-reg: # (payload list var) -18752 0x11/imm32/alloc-id:fake:payload -18753 0x11/imm32/alloc-id:fake -18754 Int-var-in-mem/imm32 -18755 0x11/imm32/alloc-id:fake -18756 Single-int-var-in-some-register/imm32/next -18757 -18758 Two-int-args-in-regs: # (payload list var) +18715 # "49/decrement-ecx" +18716 0x10/imm32/size +18717 0x34/4 0x39/9 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x63/c 0x78/x +18718 _string_4a_decrement_edx: # (payload array byte) +18719 0x11/imm32/alloc-id:fake:payload +18720 # "4a/decrement-edx" +18721 0x10/imm32/size +18722 0x34/4 0x61/a 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x78/x +18723 _string_4b_decrement_ebx: # (payload array byte) +18724 0x11/imm32/alloc-id:fake:payload +18725 # "4b/decrement-ebx" +18726 0x10/imm32/size +18727 0x34/4 0x62/b 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x62/b 0x78/x +18728 _string_4e_decrement_esi: # (payload array byte) +18729 0x11/imm32/alloc-id:fake:payload +18730 # "4e/decrement-esi" +18731 0x10/imm32/size +18732 0x34/4 0x65/e 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x73/s 0x69/i +18733 _string_4f_decrement_edi: # (payload array byte) +18734 0x11/imm32/alloc-id:fake:payload +18735 # "4f/decrement-edi" +18736 0x10/imm32/size +18737 0x34/4 0x66/f 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t 0x2d/dash 0x65/e 0x64/d 0x69/i +18738 _string_81_subop_add: # (payload array byte) +18739 0x11/imm32/alloc-id:fake:payload +18740 # "81 0/subop/add" +18741 0xe/imm32/size +18742 0x38/8 0x31/1 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x64/d 0x64/d +18743 _string_81_subop_or: # (payload array byte) +18744 0x11/imm32/alloc-id:fake:payload +18745 # "81 1/subop/or" +18746 0xd/imm32/size +18747 0x38/8 0x31/1 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6f/o 0x72/r +18748 _string_81_subop_and: # (payload array byte) +18749 0x11/imm32/alloc-id:fake:payload +18750 # "81 4/subop/and" +18751 0xe/imm32/size +18752 0x38/8 0x31/1 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x61/a 0x6e/n 0x64/d +18753 _string_81_subop_subtract: # (payload array byte) +18754 0x11/imm32/alloc-id:fake:payload +18755 # "81 5/subop/subtract" +18756 0x13/imm32/size +18757 0x38/8 0x31/1 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +18758 _string_81_subop_xor: # (payload array byte) 18759 0x11/imm32/alloc-id:fake:payload -18760 0x11/imm32/alloc-id:fake -18761 Int-var-in-some-register/imm32 -18762 0x11/imm32/alloc-id:fake -18763 Single-int-var-in-some-register/imm32/next -18764 -18765 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -18766 Two-args-byte-stack-byte-reg: # (payload list var) -18767 0x11/imm32/alloc-id:fake:payload -18768 0x11/imm32/alloc-id:fake -18769 Byte-var-in-mem/imm32 -18770 0x11/imm32/alloc-id:fake -18771 Single-byte-var-in-some-register/imm32/next -18772 -18773 Two-args-int-reg-int-stack: # (payload list var) +18760 # "81 6/subop/xor" +18761 0xe/imm32/size +18762 0x38/8 0x31/1 0x20/space 0x36/6 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x78/x 0x6f/o 0x72/r +18763 _string_81_subop_compare: # (payload array byte) +18764 0x11/imm32/alloc-id:fake:payload +18765 # "81 7/subop/compare" +18766 0x12/imm32/size +18767 0x38/8 0x31/1 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e +18768 _string_89_<-: # (payload array byte) +18769 0x11/imm32/alloc-id:fake:payload +18770 # "89/<-" +18771 0x5/imm32/size +18772 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash +18773 _string_8b_->: # (payload array byte) 18774 0x11/imm32/alloc-id:fake:payload -18775 0x11/imm32/alloc-id:fake -18776 Int-var-in-some-register/imm32 -18777 0x11/imm32/alloc-id:fake -18778 Single-int-var-in-mem/imm32/next -18779 -18780 Two-args-int-eax-int-literal: # (payload list var) -18781 0x11/imm32/alloc-id:fake:payload -18782 0x11/imm32/alloc-id:fake -18783 Int-var-in-eax/imm32 -18784 0x11/imm32/alloc-id:fake -18785 Single-lit-var/imm32/next -18786 -18787 Int-var-and-literal: # (payload list var) -18788 0x11/imm32/alloc-id:fake:payload -18789 0x11/imm32/alloc-id:fake -18790 Int-var-in-mem/imm32 -18791 0x11/imm32/alloc-id:fake -18792 Single-lit-var/imm32/next -18793 -18794 Int-var-in-register-and-literal: # (payload list var) -18795 0x11/imm32/alloc-id:fake:payload -18796 0x11/imm32/alloc-id:fake -18797 Int-var-in-some-register/imm32 -18798 0x11/imm32/alloc-id:fake -18799 Single-lit-var/imm32/next -18800 -18801 Single-int-var-in-some-register: # (payload list var) -18802 0x11/imm32/alloc-id:fake:payload -18803 0x11/imm32/alloc-id:fake -18804 Int-var-in-some-register/imm32 -18805 0/imm32/next -18806 0/imm32/next -18807 -18808 Single-addr-var-in-some-register: # (payload list var) +18775 # "8b/->" +18776 0x5/imm32/size +18777 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> +18778 _string_8a_copy_byte: +18779 0x11/imm32/alloc-id:fake:payload +18780 # "8a/byte->" +18781 0x9/imm32/size +18782 0x38/8 0x61/a 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x3e/> +18783 _string_88_copy_byte: +18784 0x11/imm32/alloc-id:fake:payload +18785 # "88/byte<-" +18786 0x9/imm32/size +18787 0x38/8 0x38/8 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x3c/< 0x2d/- +18788 _string_8d_copy_address: # (payload array byte) +18789 0x11/imm32/alloc-id:fake:payload +18790 # "8d/copy-address" +18791 0xf/imm32/size +18792 0x38/8 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s +18793 _string_b8_copy_to_eax: # (payload array byte) +18794 0x11/imm32/alloc-id:fake:payload +18795 # "b8/copy-to-eax" +18796 0xe/imm32/size +18797 0x62/b 0x38/8 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x61/a 0x78/x +18798 _string_b9_copy_to_ecx: # (payload array byte) +18799 0x11/imm32/alloc-id:fake:payload +18800 # "b9/copy-to-ecx" +18801 0xe/imm32/size +18802 0x62/b 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x63/c 0x78/x +18803 _string_ba_copy_to_edx: # (payload array byte) +18804 0x11/imm32/alloc-id:fake:payload +18805 # "ba/copy-to-edx" +18806 0xe/imm32/size +18807 0x62/b 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x78/x +18808 _string_bb_copy_to_ebx: # (payload array byte) 18809 0x11/imm32/alloc-id:fake:payload -18810 0x11/imm32/alloc-id:fake -18811 Addr-var-in-some-register/imm32 -18812 0/imm32/next -18813 0/imm32/next -18814 -18815 Single-byte-var-in-some-register: # (payload list var) -18816 0x11/imm32/alloc-id:fake:payload -18817 0x11/imm32/alloc-id:fake -18818 Byte-var-in-some-register/imm32 -18819 0/imm32/next -18820 0/imm32/next -18821 -18822 Int-var-in-some-register: # (payload var) -18823 0x11/imm32/alloc-id:fake:payload -18824 0/imm32/name -18825 0/imm32/name -18826 0x11/imm32/alloc-id:fake -18827 Type-int/imm32 -18828 1/imm32/some-block-depth -18829 0/imm32/no-stack-offset -18830 0x11/imm32/alloc-id:fake -18831 Any-register/imm32 -18832 -18833 Any-register: # (payload array byte) +18810 # "bb/copy-to-ebx" +18811 0xe/imm32/size +18812 0x62/b 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x62/b 0x78/x +18813 _string_be_copy_to_esi: # (payload array byte) +18814 0x11/imm32/alloc-id:fake:payload +18815 # "be/copy-to-esi" +18816 0xe/imm32/size +18817 0x62/b 0x65/e 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x73/s 0x69/i +18818 _string_bf_copy_to_edi: # (payload array byte) +18819 0x11/imm32/alloc-id:fake:payload +18820 # "bf/copy-to-edi" +18821 0xe/imm32/size +18822 0x62/b 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x65/e 0x64/d 0x69/i +18823 _string_c7_subop_copy: # (payload array byte) +18824 0x11/imm32/alloc-id:fake:payload +18825 # "c7 0/subop/copy" +18826 0xf/imm32/size +18827 0x63/c 0x37/7 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y +18828 _string_e9_jump_label: # (payload array byte) +18829 0x11/imm32/alloc-id:fake:payload +18830 # "e9/jump" +18831 0x7/imm32/size +18832 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p +18833 _string_e9_jump_break: # (payload array byte) 18834 0x11/imm32/alloc-id:fake:payload -18835 1/imm32/size -18836 # data -18837 2a/asterisk -18838 -18839 Addr-var-in-some-register: # (payload var) -18840 0x11/imm32/alloc-id:fake:payload -18841 0/imm32/name -18842 0/imm32/name -18843 0x11/imm32/alloc-id:fake -18844 Type-addr/imm32 -18845 1/imm32/some-block-depth -18846 0/imm32/no-stack-offset -18847 0x11/imm32/alloc-id:fake -18848 Any-register/imm32 -18849 -18850 Byte-var-in-some-register: # (payload var) -18851 0x11/imm32/alloc-id:fake:payload -18852 0/imm32/name -18853 0/imm32/name -18854 0x11/imm32/alloc-id:fake -18855 Type-byte/imm32 -18856 1/imm32/some-block-depth -18857 0/imm32/no-stack-offset -18858 0x11/imm32/alloc-id:fake -18859 Any-register/imm32 -18860 -18861 Single-int-var-in-eax: # (payload list var) -18862 0x11/imm32/alloc-id:fake:payload -18863 0x11/imm32/alloc-id:fake -18864 Int-var-in-eax/imm32 -18865 0/imm32/next -18866 0/imm32/next -18867 -18868 Int-var-in-eax: -18869 0x11/imm32/alloc-id:fake:payload -18870 0/imm32/name -18871 0/imm32/name -18872 0x11/imm32/alloc-id:fake -18873 Type-int/imm32 -18874 1/imm32/some-block-depth -18875 0/imm32/no-stack-offset -18876 0x11/imm32/alloc-id:fake -18877 $Register-eax/imm32 -18878 -18879 Single-int-var-in-ecx: # (payload list var) -18880 0x11/imm32/alloc-id:fake:payload -18881 0x11/imm32/alloc-id:fake -18882 Int-var-in-ecx/imm32 -18883 0/imm32/next -18884 0/imm32/next -18885 -18886 Int-var-in-ecx: -18887 0x11/imm32/alloc-id:fake:payload -18888 0/imm32/name -18889 0/imm32/name +18835 # "e9/jump break/disp32" +18836 0x14/imm32/size +18837 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18838 _string_e9_jump_loop: # (payload array byte) +18839 0x11/imm32/alloc-id:fake:payload +18840 # "e9/jump loop/disp32" +18841 0x13/imm32/size +18842 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p 0x20/space 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x69/i 0x73/s 0x70/p 0x33/3 0x32/2 +18843 _string_ff_subop_increment: # (payload array byte) +18844 0x11/imm32/alloc-id:fake:payload +18845 # "ff 0/subop/increment" +18846 0x14/imm32/size +18847 0x66/f 0x66/f 0x20/space 0x30/0 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +18848 _string_ff_subop_decrement: # (payload array byte) +18849 0x11/imm32/alloc-id:fake:payload +18850 # "ff 1/subop/decrement" +18851 0x14/imm32/size +18852 0x66/f 0x66/f 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +18853 _string_c1_subop_shift_left: # (payload array byte) +18854 0x11/imm32/alloc-id:fake:payload +18855 # "c1/shift 4/subop/left" +18856 0x15/imm32/size +18857 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6c/l 0x65/e 0x66/f 0x74/t +18858 _string_c1_subop_shift_right_padding_zeroes: # (payload array byte) +18859 0x11/imm32/alloc-id:fake:payload +18860 # "c1/shift 5/subop/right-padding-zeroes" +18861 0x25/imm32/size +18862 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x61/a 0x64/d 0x64/d 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x7a/z 0x65/e 0x72/r 0x6f/o 0x65/e 0x73/s +18863 _string_c1_subop_shift_right_preserving_sign: # (payload array byte) +18864 0x11/imm32/alloc-id:fake:payload +18865 # "c1/shift 7/subop/right-preserving-sign" +18866 0x26/imm32/size +18867 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x72/r 0x65/e 0x73/s 0x65/e 0x72/r 0x76/v 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n +18868 +18869 Single-int-var-in-mem: # (payload list var) +18870 0x11/imm32/alloc-id:fake:payload +18871 0x11/imm32/alloc-id:fake +18872 Int-var-in-mem/imm32 +18873 0/imm32/next +18874 0/imm32/next +18875 +18876 Int-var-in-mem: # (payload var) +18877 0x11/imm32/alloc-id:fake:payload +18878 0/imm32/name +18879 0/imm32/name +18880 0x11/imm32/alloc-id:fake +18881 Type-int/imm32 +18882 1/imm32/some-block-depth +18883 1/imm32/some-stack-offset +18884 0/imm32/no-register +18885 0/imm32/no-register +18886 +18887 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +18888 Single-byte-var-in-mem: # (payload list var) +18889 0x11/imm32/alloc-id:fake:payload 18890 0x11/imm32/alloc-id:fake -18891 Type-int/imm32 -18892 1/imm32/some-block-depth -18893 0/imm32/no-stack-offset -18894 0x11/imm32/alloc-id:fake -18895 $Register-ecx/imm32/register -18896 -18897 Single-int-var-in-edx: # (payload list var) -18898 0x11/imm32/alloc-id:fake:payload -18899 0x11/imm32/alloc-id:fake -18900 Int-var-in-edx/imm32 -18901 0/imm32/next -18902 0/imm32/next -18903 -18904 Int-var-in-edx: # (payload list var) -18905 0x11/imm32/alloc-id:fake:payload -18906 0/imm32/name -18907 0/imm32/name -18908 0x11/imm32/alloc-id:fake -18909 Type-int/imm32 -18910 1/imm32/some-block-depth -18911 0/imm32/no-stack-offset -18912 0x11/imm32/alloc-id:fake -18913 $Register-edx/imm32/register -18914 -18915 Single-int-var-in-ebx: # (payload list var) -18916 0x11/imm32/alloc-id:fake:payload -18917 0x11/imm32/alloc-id:fake -18918 Int-var-in-ebx/imm32 -18919 0/imm32/next -18920 0/imm32/next -18921 -18922 Int-var-in-ebx: # (payload list var) +18891 Byte-var-in-mem/imm32 +18892 0/imm32/next +18893 0/imm32/next +18894 +18895 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +18896 Byte-var-in-mem: # (payload var) +18897 0x11/imm32/alloc-id:fake:payload +18898 0/imm32/name +18899 0/imm32/name +18900 0x11/imm32/alloc-id:fake +18901 Type-byte/imm32 +18902 1/imm32/some-block-depth +18903 1/imm32/some-stack-offset +18904 0/imm32/no-register +18905 0/imm32/no-register +18906 +18907 Two-args-int-stack-int-reg: # (payload list var) +18908 0x11/imm32/alloc-id:fake:payload +18909 0x11/imm32/alloc-id:fake +18910 Int-var-in-mem/imm32 +18911 0x11/imm32/alloc-id:fake +18912 Single-int-var-in-some-register/imm32/next +18913 +18914 Two-int-args-in-regs: # (payload list var) +18915 0x11/imm32/alloc-id:fake:payload +18916 0x11/imm32/alloc-id:fake +18917 Int-var-in-some-register/imm32 +18918 0x11/imm32/alloc-id:fake +18919 Single-int-var-in-some-register/imm32/next +18920 +18921 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +18922 Two-args-byte-stack-byte-reg: # (payload list var) 18923 0x11/imm32/alloc-id:fake:payload -18924 0/imm32/name -18925 0/imm32/name +18924 0x11/imm32/alloc-id:fake +18925 Byte-var-in-mem/imm32 18926 0x11/imm32/alloc-id:fake -18927 Type-int/imm32 -18928 1/imm32/some-block-depth -18929 0/imm32/no-stack-offset -18930 0x11/imm32/alloc-id:fake -18931 $Register-ebx/imm32/register -18932 -18933 Single-int-var-in-esi: # (payload list var) -18934 0x11/imm32/alloc-id:fake:payload -18935 0x11/imm32/alloc-id:fake -18936 Int-var-in-esi/imm32 -18937 0/imm32/next -18938 0/imm32/next -18939 -18940 Int-var-in-esi: # (payload list var) -18941 0x11/imm32/alloc-id:fake:payload -18942 0/imm32/name -18943 0/imm32/name -18944 0x11/imm32/alloc-id:fake -18945 Type-int/imm32 -18946 1/imm32/some-block-depth -18947 0/imm32/no-stack-offset -18948 0x11/imm32/alloc-id:fake -18949 $Register-esi/imm32/register -18950 -18951 Single-int-var-in-edi: # (payload list var) -18952 0x11/imm32/alloc-id:fake:payload -18953 0x11/imm32/alloc-id:fake -18954 Int-var-in-edi/imm32 -18955 0/imm32/next -18956 0/imm32/next -18957 -18958 Int-var-in-edi: # (payload list var) -18959 0x11/imm32/alloc-id:fake:payload -18960 0/imm32/name -18961 0/imm32/name -18962 0x11/imm32/alloc-id:fake -18963 Type-int/imm32 -18964 1/imm32/some-block-depth -18965 0/imm32/no-stack-offset +18927 Single-byte-var-in-some-register/imm32/next +18928 +18929 Two-args-int-reg-int-stack: # (payload list var) +18930 0x11/imm32/alloc-id:fake:payload +18931 0x11/imm32/alloc-id:fake +18932 Int-var-in-some-register/imm32 +18933 0x11/imm32/alloc-id:fake +18934 Single-int-var-in-mem/imm32/next +18935 +18936 Two-args-int-eax-int-literal: # (payload list var) +18937 0x11/imm32/alloc-id:fake:payload +18938 0x11/imm32/alloc-id:fake +18939 Int-var-in-eax/imm32 +18940 0x11/imm32/alloc-id:fake +18941 Single-lit-var/imm32/next +18942 +18943 Int-var-and-literal: # (payload list var) +18944 0x11/imm32/alloc-id:fake:payload +18945 0x11/imm32/alloc-id:fake +18946 Int-var-in-mem/imm32 +18947 0x11/imm32/alloc-id:fake +18948 Single-lit-var/imm32/next +18949 +18950 Int-var-in-register-and-literal: # (payload list var) +18951 0x11/imm32/alloc-id:fake:payload +18952 0x11/imm32/alloc-id:fake +18953 Int-var-in-some-register/imm32 +18954 0x11/imm32/alloc-id:fake +18955 Single-lit-var/imm32/next +18956 +18957 Single-int-var-in-some-register: # (payload list var) +18958 0x11/imm32/alloc-id:fake:payload +18959 0x11/imm32/alloc-id:fake +18960 Int-var-in-some-register/imm32 +18961 0/imm32/next +18962 0/imm32/next +18963 +18964 Single-addr-var-in-some-register: # (payload list var) +18965 0x11/imm32/alloc-id:fake:payload 18966 0x11/imm32/alloc-id:fake -18967 $Register-edi/imm32/register -18968 -18969 Single-lit-var: # (payload list var) -18970 0x11/imm32/alloc-id:fake:payload -18971 0x11/imm32/alloc-id:fake -18972 Lit-var/imm32 -18973 0/imm32/next -18974 0/imm32/next -18975 -18976 Lit-var: # (payload var) -18977 0x11/imm32/alloc-id:fake:payload -18978 0/imm32/name -18979 0/imm32/name -18980 0x11/imm32/alloc-id:fake -18981 Type-literal/imm32 -18982 1/imm32/some-block-depth -18983 0/imm32/no-stack-offset -18984 0/imm32/no-register -18985 0/imm32/no-register -18986 -18987 Type-int: # (payload type-tree) -18988 0x11/imm32/alloc-id:fake:payload -18989 1/imm32/is-atom -18990 1/imm32/value:int -18991 0/imm32/left:unused -18992 0/imm32/right:null -18993 0/imm32/right:null +18967 Addr-var-in-some-register/imm32 +18968 0/imm32/next +18969 0/imm32/next +18970 +18971 Single-byte-var-in-some-register: # (payload list var) +18972 0x11/imm32/alloc-id:fake:payload +18973 0x11/imm32/alloc-id:fake +18974 Byte-var-in-some-register/imm32 +18975 0/imm32/next +18976 0/imm32/next +18977 +18978 Int-var-in-some-register: # (payload var) +18979 0x11/imm32/alloc-id:fake:payload +18980 0/imm32/name +18981 0/imm32/name +18982 0x11/imm32/alloc-id:fake +18983 Type-int/imm32 +18984 1/imm32/some-block-depth +18985 0/imm32/no-stack-offset +18986 0x11/imm32/alloc-id:fake +18987 Any-register/imm32 +18988 +18989 Any-register: # (payload array byte) +18990 0x11/imm32/alloc-id:fake:payload +18991 1/imm32/size +18992 # data +18993 2a/asterisk 18994 -18995 Type-literal: # (payload type-tree) +18995 Addr-var-in-some-register: # (payload var) 18996 0x11/imm32/alloc-id:fake:payload -18997 1/imm32/is-atom -18998 0/imm32/value:literal -18999 0/imm32/left:unused -19000 0/imm32/right:null -19001 0/imm32/right:null -19002 -19003 Type-addr: # (payload type-tree) -19004 0x11/imm32/alloc-id:fake:payload -19005 1/imm32/is-atom -19006 2/imm32/value:addr -19007 0/imm32/left:unused -19008 0/imm32/right:null -19009 0/imm32/right:null -19010 -19011 Type-byte: # (payload type-tree) -19012 0x11/imm32/alloc-id:fake:payload -19013 1/imm32/is-atom -19014 8/imm32/value:byte -19015 0/imm32/left:unused -19016 0/imm32/right:null -19017 0/imm32/right:null -19018 -19019 == code -19020 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) -19021 # . prologue -19022 55/push-ebp -19023 89/<- %ebp 4/r32/esp -19024 # . save registers -19025 50/push-eax -19026 51/push-ecx -19027 # ecx = primitive -19028 8b/-> *(ebp+0x10) 1/r32/ecx -19029 # emit primitive name -19030 (emit-indent *(ebp+8) *Curr-block-depth) -19031 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax -19032 (write-buffered *(ebp+8) %eax) -19033 # emit rm32 if necessary -19034 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-rm32 -19035 # emit r32 if necessary -19036 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # Primitive-subx-r32 -19037 # emit imm32 if necessary -19038 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # Primitive-subx-imm32 -19039 # emit imm8 if necessary -19040 (emit-subx-imm8 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # Primitive-subx-imm8 -19041 # emit disp32 if necessary -19042 (emit-subx-disp32 *(ebp+8) *(ecx+0x30) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-disp32 -19043 (write-buffered *(ebp+8) Newline) -19044 $emit-subx-primitive:end: -19045 # . restore registers -19046 59/pop-to-ecx -19047 58/pop-to-eax -19048 # . epilogue -19049 89/<- %esp 5/r32/ebp -19050 5d/pop-to-ebp -19051 c3/return +18997 0/imm32/name +18998 0/imm32/name +18999 0x11/imm32/alloc-id:fake +19000 Type-addr/imm32 +19001 1/imm32/some-block-depth +19002 0/imm32/no-stack-offset +19003 0x11/imm32/alloc-id:fake +19004 Any-register/imm32 +19005 +19006 Byte-var-in-some-register: # (payload var) +19007 0x11/imm32/alloc-id:fake:payload +19008 0/imm32/name +19009 0/imm32/name +19010 0x11/imm32/alloc-id:fake +19011 Type-byte/imm32 +19012 1/imm32/some-block-depth +19013 0/imm32/no-stack-offset +19014 0x11/imm32/alloc-id:fake +19015 Any-register/imm32 +19016 +19017 Single-int-var-in-eax: # (payload list var) +19018 0x11/imm32/alloc-id:fake:payload +19019 0x11/imm32/alloc-id:fake +19020 Int-var-in-eax/imm32 +19021 0/imm32/next +19022 0/imm32/next +19023 +19024 Int-var-in-eax: +19025 0x11/imm32/alloc-id:fake:payload +19026 0/imm32/name +19027 0/imm32/name +19028 0x11/imm32/alloc-id:fake +19029 Type-int/imm32 +19030 1/imm32/some-block-depth +19031 0/imm32/no-stack-offset +19032 0x11/imm32/alloc-id:fake +19033 $Register-eax/imm32 +19034 +19035 Single-int-var-in-ecx: # (payload list var) +19036 0x11/imm32/alloc-id:fake:payload +19037 0x11/imm32/alloc-id:fake +19038 Int-var-in-ecx/imm32 +19039 0/imm32/next +19040 0/imm32/next +19041 +19042 Int-var-in-ecx: +19043 0x11/imm32/alloc-id:fake:payload +19044 0/imm32/name +19045 0/imm32/name +19046 0x11/imm32/alloc-id:fake +19047 Type-int/imm32 +19048 1/imm32/some-block-depth +19049 0/imm32/no-stack-offset +19050 0x11/imm32/alloc-id:fake +19051 $Register-ecx/imm32/register 19052 -19053 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -19054 # . prologue -19055 55/push-ebp -19056 89/<- %ebp 4/r32/esp -19057 # . save registers -19058 50/push-eax -19059 # if (l == 0) return -19060 81 7/subop/compare *(ebp+0xc) 0/imm32 -19061 74/jump-if-= $emit-subx-rm32:end/disp8 -19062 # var v/eax: (addr stmt-var) -19063 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax -19064 (emit-subx-var-as-rm32 *(ebp+8) %eax) -19065 $emit-subx-rm32:end: -19066 # . restore registers -19067 58/pop-to-eax -19068 # . epilogue -19069 89/<- %esp 5/r32/ebp -19070 5d/pop-to-ebp -19071 c3/return -19072 -19073 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location, err: (addr buffered-file), ed: (addr exit-descriptor) -> var/eax: (addr stmt-var) -19074 # . prologue -19075 55/push-ebp -19076 89/<- %ebp 4/r32/esp -19077 # . save registers -19078 51/push-ecx -19079 # eax = l -19080 8b/-> *(ebp+0xc) 0/r32/eax -19081 # ecx = stmt -19082 8b/-> *(ebp+8) 1/r32/ecx -19083 # if (l == 1) return stmt->inouts -19084 { -19085 3d/compare-eax-and 1/imm32 -19086 75/jump-if-!= break/disp8 -19087 $get-stmt-operand-from-arg-location:1: -19088 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19089 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -19090 } -19091 # if (l == 2) return stmt->inouts->next -19092 { -19093 3d/compare-eax-and 2/imm32 -19094 75/jump-if-!= break/disp8 -19095 $get-stmt-operand-from-arg-location:2: -19096 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19097 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -19098 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -19099 } -19100 # if (l == 3) return stmt->outputs -19101 { -19102 3d/compare-eax-and 3/imm32 -19103 75/jump-if-!= break/disp8 -19104 $get-stmt-operand-from-arg-location:3: -19105 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -19106 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -19107 } -19108 # abort -19109 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 -19110 $get-stmt-operand-from-arg-location:end: -19111 # . restore registers -19112 59/pop-to-ecx -19113 # . epilogue -19114 89/<- %esp 5/r32/ebp -19115 5d/pop-to-ebp -19116 c3/return -19117 -19118 $get-stmt-operand-from-arg-location:abort: -19119 # error("invalid arg-location " eax) -19120 (write-buffered *(ebp+0x10) "invalid arg-location ") -19121 (write-int32-hex-buffered *(ebp+0x10) %eax) -19122 (write-buffered *(ebp+0x10) Newline) -19123 (flush *(ebp+0x10)) -19124 (stop *(ebp+0x14) 1) -19125 # never gets here -19126 -19127 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -19128 # . prologue -19129 55/push-ebp -19130 89/<- %ebp 4/r32/esp -19131 # . save registers -19132 50/push-eax -19133 51/push-ecx -19134 # if (l == 0) return -19135 81 7/subop/compare *(ebp+0xc) 0/imm32 -19136 0f 84/jump-if-= $emit-subx-r32:end/disp32 -19137 # var v/eax: (addr stmt-var) -19138 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -19139 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19140 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -19141 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) -19142 (write-buffered *(ebp+8) Space) -19143 (write-int32-hex-buffered *(ebp+8) *eax) -19144 (write-buffered *(ebp+8) "/r32") -19145 $emit-subx-r32:end: -19146 # . restore registers -19147 59/pop-to-ecx -19148 58/pop-to-eax -19149 # . epilogue -19150 89/<- %esp 5/r32/ebp -19151 5d/pop-to-ebp -19152 c3/return -19153 -19154 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -19155 # . prologue -19156 55/push-ebp -19157 89/<- %ebp 4/r32/esp -19158 # . save registers -19159 50/push-eax -19160 51/push-ecx -19161 # if (l == 0) return -19162 81 7/subop/compare *(ebp+0xc) 0/imm32 -19163 0f 84/jump-if-= $emit-subx-imm32:end/disp32 -19164 # var v/eax: (handle var) -19165 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -19166 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19167 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19168 (write-buffered *(ebp+8) Space) -19169 (write-buffered *(ebp+8) %eax) -19170 (write-buffered *(ebp+8) "/imm32") -19171 $emit-subx-imm32:end: -19172 # . restore registers -19173 59/pop-to-ecx -19174 58/pop-to-eax -19175 # . epilogue -19176 89/<- %esp 5/r32/ebp -19177 5d/pop-to-ebp -19178 c3/return -19179 -19180 emit-subx-imm8: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -19181 # . prologue -19182 55/push-ebp -19183 89/<- %ebp 4/r32/esp -19184 # . save registers -19185 50/push-eax -19186 51/push-ecx -19187 # if (l == 0) return -19188 81 7/subop/compare *(ebp+0xc) 0/imm32 -19189 0f 84/jump-if-= $emit-subx-imm32:end/disp32 -19190 # var v/eax: (handle var) -19191 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -19192 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19193 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19194 (write-buffered *(ebp+8) Space) -19195 (write-buffered *(ebp+8) %eax) -19196 (write-buffered *(ebp+8) "/imm8") -19197 $emit-subx-imm8:end: -19198 # . restore registers -19199 59/pop-to-ecx -19200 58/pop-to-eax -19201 # . epilogue -19202 89/<- %esp 5/r32/ebp -19203 5d/pop-to-ebp -19204 c3/return -19205 -19206 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -19207 # . prologue -19208 55/push-ebp -19209 89/<- %ebp 4/r32/esp -19210 # . save registers -19211 50/push-eax -19212 51/push-ecx -19213 # if (location == 0) return -19214 81 7/subop/compare *(ebp+0xc) 0/imm32 -19215 0f 84/jump-if-= $emit-subx-disp32:end/disp32 -19216 # var v/eax: (addr stmt-var) -19217 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax -19218 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19219 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19220 (write-buffered *(ebp+8) Space) -19221 (write-buffered *(ebp+8) %eax) -19222 # hack: if instruction operation starts with "break", emit ":break" -19223 # var name/ecx: (addr array byte) = lookup(stmt->operation) -19224 8b/-> *(ebp+0x10) 0/r32/eax -19225 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -19226 89/<- %ecx 0/r32/eax -19227 { -19228 (string-starts-with? %ecx "break") # => eax -19229 3d/compare-eax-and 0/imm32/false -19230 74/jump-if-= break/disp8 -19231 (write-buffered *(ebp+8) ":break") -19232 } -19233 # hack: if instruction operation starts with "loop", emit ":loop" -19234 { -19235 (string-starts-with? %ecx "loop") # => eax -19236 3d/compare-eax-and 0/imm32/false -19237 74/jump-if-= break/disp8 -19238 (write-buffered *(ebp+8) ":loop") -19239 } -19240 (write-buffered *(ebp+8) "/disp32") -19241 $emit-subx-disp32:end: -19242 # . restore registers -19243 59/pop-to-ecx -19244 58/pop-to-eax -19245 # . epilogue -19246 89/<- %esp 5/r32/ebp -19247 5d/pop-to-ebp -19248 c3/return -19249 -19250 emit-call: # out: (addr buffered-file), stmt: (addr stmt) -19251 # . prologue -19252 55/push-ebp -19253 89/<- %ebp 4/r32/esp -19254 # . save registers -19255 50/push-eax -19256 51/push-ecx -19257 # -19258 (emit-indent *(ebp+8) *Curr-block-depth) -19259 (write-buffered *(ebp+8) "(") -19260 # ecx = stmt -19261 8b/-> *(ebp+0xc) 1/r32/ecx -19262 # - emit function name -19263 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -19264 (write-buffered *(ebp+8) %eax) -19265 # - emit arguments -19266 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) -19267 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19268 { -19269 # if (curr == null) break -19270 3d/compare-eax-and 0/imm32 -19271 74/jump-if-= break/disp8 -19272 # -19273 (emit-subx-call-operand *(ebp+8) %eax) -19274 # curr = lookup(curr->next) -19275 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -19276 eb/jump loop/disp8 -19277 } -19278 # -19279 (write-buffered *(ebp+8) ")\n") -19280 $emit-call:end: -19281 # . restore registers -19282 59/pop-to-ecx -19283 58/pop-to-eax -19284 # . epilogue -19285 89/<- %esp 5/r32/ebp -19286 5d/pop-to-ebp -19287 c3/return -19288 -19289 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) -19290 # shares code with emit-subx-var-as-rm32 -19291 # . prologue -19292 55/push-ebp -19293 89/<- %ebp 4/r32/esp -19294 # . save registers -19295 50/push-eax -19296 51/push-ecx -19297 56/push-esi -19298 # ecx = s -19299 8b/-> *(ebp+0xc) 1/r32/ecx -19300 # var operand/esi: (addr var) = lookup(s->value) -19301 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -19302 89/<- %esi 0/r32/eax -19303 # if (operand->register && !s->is-deref?) emit "%__" -19304 { -19305 $emit-subx-call-operand:check-for-register-direct: -19306 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19307 74/jump-if-= break/disp8 -19308 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19309 75/jump-if-!= break/disp8 -19310 $emit-subx-call-operand:register-direct: -19311 (write-buffered *(ebp+8) " %") -19312 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -19313 (write-buffered *(ebp+8) %eax) -19314 e9/jump $emit-subx-call-operand:end/disp32 -19315 } -19316 # else if (operand->register && s->is-deref?) emit "*__" -19317 { -19318 $emit-subx-call-operand:check-for-register-indirect: -19319 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19320 74/jump-if-= break/disp8 -19321 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19322 74/jump-if-= break/disp8 -19323 $emit-subx-call-operand:register-indirect: -19324 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) -19325 e9/jump $emit-subx-call-operand:end/disp32 -19326 } -19327 # else if (operand->stack-offset) emit "*(ebp+__)" -19328 { -19329 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -19330 74/jump-if-= break/disp8 -19331 $emit-subx-call-operand:stack: -19332 (emit-subx-call-operand-stack *(ebp+8) %esi) -19333 e9/jump $emit-subx-call-operand:end/disp32 -19334 } -19335 # else if (operand->type == literal) emit "__" -19336 { -19337 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -19338 81 7/subop/compare *(eax+4) 0/imm32 # Type-tree-left -19339 75/jump-if-!= break/disp8 -19340 $emit-subx-call-operand:literal: -19341 (write-buffered *(ebp+8) Space) -19342 (lookup *esi *(esi+4)) # Var-name Var-name => eax -19343 (write-buffered *(ebp+8) %eax) -19344 } -19345 $emit-subx-call-operand:end: -19346 # . restore registers -19347 5e/pop-to-esi -19348 59/pop-to-ecx -19349 58/pop-to-eax -19350 # . epilogue -19351 89/<- %esp 5/r32/ebp -19352 5d/pop-to-ebp -19353 c3/return -19354 -19355 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) -19356 # . prologue -19357 55/push-ebp -19358 89/<- %ebp 4/r32/esp -19359 # . save registers -19360 50/push-eax -19361 51/push-ecx -19362 56/push-esi -19363 # esi = v -19364 8b/-> *(ebp+0xc) 6/r32/esi -19365 # var size/ecx: int = size-of-deref(v) -19366 (size-of-deref %esi) # => eax -19367 89/<- %ecx 0/r32/eax -19368 # var reg-name/esi: (addr array byte) = lookup(v->register) -19369 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -19370 89/<- %esi 0/r32/eax -19371 # TODO: assert size is a multiple of 4 -19372 # var i/eax: int = 0 -19373 b8/copy-to-eax 0/imm32 -19374 { -19375 $emit-subx-call-operand-register-indirect:loop: -19376 # if (i >= size) break -19377 39/compare %eax 1/r32/ecx -19378 7d/jump-if->= break/disp8 -19379 # emit " *(" v->register "+" i ")" -19380 (write-buffered *(ebp+8) " *(") -19381 (write-buffered *(ebp+8) %esi) -19382 (write-buffered *(ebp+8) "+") -19383 (write-int32-hex-buffered *(ebp+8) %eax) -19384 (write-buffered *(ebp+8) ")") -19385 # i += 4 -19386 05/add-to-eax 4/imm32 -19387 # -19388 eb/jump loop/disp8 -19389 } -19390 $emit-subx-call-operand-register-indirect:end: -19391 # . restore registers -19392 5e/pop-to-esi -19393 59/pop-to-ecx -19394 58/pop-to-eax -19395 # . epilogue -19396 89/<- %esp 5/r32/ebp -19397 5d/pop-to-ebp -19398 c3/return -19399 -19400 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) -19401 # . prologue -19402 55/push-ebp -19403 89/<- %ebp 4/r32/esp -19404 # . save registers -19405 50/push-eax -19406 51/push-ecx -19407 56/push-esi -19408 # esi = v -19409 8b/-> *(ebp+0xc) 6/r32/esi -19410 # var curr/ecx: int = v->offset -19411 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset -19412 # var max/eax: int = v->offset + size-of(v) -19413 (size-of %esi) # => eax -19414 # TODO: assert size is a multiple of 4 -19415 01/add-to %eax 1/r32/ecx -19416 { -19417 $emit-subx-call-operand-stack:loop: -19418 # if (curr >= max) break -19419 39/compare %ecx 0/r32/eax -19420 7d/jump-if->= break/disp8 -19421 # emit " *(ebp+" curr ")" -19422 (write-buffered *(ebp+8) " *(ebp+") -19423 (write-int32-hex-buffered *(ebp+8) %ecx) -19424 (write-buffered *(ebp+8) ")") -19425 # i += 4 -19426 81 0/subop/add %ecx 4/imm32 -19427 # -19428 eb/jump loop/disp8 -19429 } -19430 $emit-subx-call-operand-stack:end: -19431 # . restore registers -19432 5e/pop-to-esi -19433 59/pop-to-ecx -19434 58/pop-to-eax -19435 # . epilogue -19436 89/<- %esp 5/r32/ebp -19437 5d/pop-to-ebp -19438 c3/return -19439 -19440 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) -19441 # . prologue -19442 55/push-ebp -19443 89/<- %ebp 4/r32/esp -19444 # . save registers -19445 50/push-eax -19446 51/push-ecx -19447 56/push-esi -19448 # ecx = s -19449 8b/-> *(ebp+0xc) 1/r32/ecx -19450 # var operand/esi: (addr var) = lookup(s->value) -19451 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -19452 89/<- %esi 0/r32/eax -19453 # if (operand->register && s->is-deref?) emit "*__" -19454 { -19455 $emit-subx-var-as-rm32:check-for-register-indirect: -19456 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19457 74/jump-if-= break/disp8 -19458 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19459 74/jump-if-= break/disp8 -19460 $emit-subx-var-as-rm32:register-indirect: -19461 (write-buffered *(ebp+8) " *") -19462 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -19463 (write-buffered *(ebp+8) %eax) -19464 e9/jump $emit-subx-var-as-rm32:end/disp32 -19465 } -19466 # if (operand->register && !s->is-deref?) emit "%__" -19467 { -19468 $emit-subx-var-as-rm32:check-for-register-direct: -19469 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19470 74/jump-if-= break/disp8 -19471 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19472 75/jump-if-!= break/disp8 -19473 $emit-subx-var-as-rm32:register-direct: -19474 (write-buffered *(ebp+8) " %") -19475 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -19476 (write-buffered *(ebp+8) %eax) -19477 e9/jump $emit-subx-var-as-rm32:end/disp32 -19478 } -19479 # else if (operand->stack-offset) emit "*(ebp+__)" -19480 { -19481 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -19482 74/jump-if-= break/disp8 -19483 $emit-subx-var-as-rm32:stack: -19484 (write-buffered *(ebp+8) Space) -19485 (write-buffered *(ebp+8) "*(ebp+") -19486 (write-int32-hex-buffered *(ebp+8) *(esi+0x14)) # Var-offset -19487 (write-buffered *(ebp+8) ")") -19488 } -19489 $emit-subx-var-as-rm32:end: -19490 # . restore registers -19491 5e/pop-to-esi -19492 59/pop-to-ecx -19493 58/pop-to-eax -19494 # . epilogue -19495 89/<- %esp 5/r32/ebp -19496 5d/pop-to-ebp -19497 c3/return -19498 -19499 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) -19500 # . prologue -19501 55/push-ebp -19502 89/<- %ebp 4/r32/esp -19503 # . save registers -19504 51/push-ecx -19505 # var curr/ecx: (addr primitive) = primitives -19506 8b/-> *(ebp+8) 1/r32/ecx -19507 { -19508 $find-matching-primitive:loop: -19509 # if (curr == null) break -19510 81 7/subop/compare %ecx 0/imm32 -19511 74/jump-if-= break/disp8 -19512 # if match(curr, stmt) return curr -19513 { -19514 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax -19515 3d/compare-eax-and 0/imm32/false -19516 74/jump-if-= break/disp8 -19517 89/<- %eax 1/r32/ecx -19518 eb/jump $find-matching-primitive:end/disp8 -19519 } -19520 $find-matching-primitive:next-primitive: -19521 # curr = curr->next -19522 (lookup *(ecx+0x38) *(ecx+0x3c)) # Primitive-next Primitive-next => eax -19523 89/<- %ecx 0/r32/eax -19524 # -19525 e9/jump loop/disp32 -19526 } -19527 # return null -19528 b8/copy-to-eax 0/imm32 -19529 $find-matching-primitive:end: -19530 # . restore registers -19531 59/pop-to-ecx -19532 # . epilogue -19533 89/<- %esp 5/r32/ebp -19534 5d/pop-to-ebp -19535 c3/return -19536 -19537 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean -19538 # A mu stmt matches a primitive if the name matches, all the inout vars -19539 # match, and all the output vars match. -19540 # Vars match if types match and registers match. -19541 # In addition, a stmt output matches a primitive's output if types match -19542 # and the primitive has a wildcard register. -19543 # . prologue -19544 55/push-ebp -19545 89/<- %ebp 4/r32/esp -19546 # . save registers -19547 51/push-ecx -19548 52/push-edx -19549 53/push-ebx -19550 56/push-esi -19551 57/push-edi -19552 # ecx = stmt -19553 8b/-> *(ebp+8) 1/r32/ecx -19554 # edx = primitive -19555 8b/-> *(ebp+0xc) 2/r32/edx -19556 { -19557 $mu-stmt-matches-primitive?:check-name: -19558 # if (primitive->name != stmt->operation) return false -19559 # . var esi: (addr array byte) = lookup(stmt->operation) -19560 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -19561 89/<- %esi 0/r32/eax -19562 # . var edi: (addr array byte) = lookup(primitive->name) -19563 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax -19564 89/<- %edi 0/r32/eax -19565 (string-equal? %esi %edi) # => eax -19566 3d/compare-eax-and 0/imm32/false -19567 75/jump-if-!= break/disp8 -19568 b8/copy-to-eax 0/imm32 -19569 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19570 } -19571 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) -19572 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19573 89/<- %esi 0/r32/eax -19574 # var curr2/edi: (addr list var) = lookup(primitive->inouts) -19575 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax -19576 89/<- %edi 0/r32/eax -19577 { -19578 $mu-stmt-matches-primitive?:inouts-loop: -19579 # if (curr == 0 && curr2 == 0) move on to check outputs -19580 { -19581 $mu-stmt-matches-primitive?:check-both-inouts-null: -19582 81 7/subop/compare %esi 0/imm32 -19583 75/jump-if-!= break/disp8 -19584 $mu-stmt-matches-primitive?:stmt-inout-null: -19585 81 7/subop/compare %edi 0/imm32 -19586 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 -19587 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: -19588 # return false -19589 b8/copy-to-eax 0/imm32/false -19590 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19591 } -19592 # if (curr2 == 0) return false -19593 { -19594 $mu-stmt-matches-primitive?:check-prim-inout-null: -19595 81 7/subop/compare %edi 0/imm32 -19596 75/jump-if-!= break/disp8 -19597 $mu-stmt-matches-primitive?:prim-inout-null: -19598 b8/copy-to-eax 0/imm32/false -19599 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19600 } -19601 # if (curr != curr2) return false -19602 { -19603 $mu-stmt-matches-primitive?:check-inouts-match: -19604 (lookup *edi *(edi+4)) # List-value List-value => eax -19605 (operand-matches-primitive? %esi %eax) # => eax -19606 3d/compare-eax-and 0/imm32/false -19607 75/jump-if-!= break/disp8 -19608 $mu-stmt-matches-primitive?:inouts-match: -19609 b8/copy-to-eax 0/imm32/false -19610 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19611 } -19612 $mu-stmt-matches-primitive?:next-inout: -19613 # curr = lookup(curr->next) -19614 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -19615 89/<- %esi 0/r32/eax -19616 # curr2 = lookup(curr2->next) -19617 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -19618 89/<- %edi 0/r32/eax -19619 # -19620 e9/jump loop/disp32 +19053 Single-int-var-in-edx: # (payload list var) +19054 0x11/imm32/alloc-id:fake:payload +19055 0x11/imm32/alloc-id:fake +19056 Int-var-in-edx/imm32 +19057 0/imm32/next +19058 0/imm32/next +19059 +19060 Int-var-in-edx: # (payload list var) +19061 0x11/imm32/alloc-id:fake:payload +19062 0/imm32/name +19063 0/imm32/name +19064 0x11/imm32/alloc-id:fake +19065 Type-int/imm32 +19066 1/imm32/some-block-depth +19067 0/imm32/no-stack-offset +19068 0x11/imm32/alloc-id:fake +19069 $Register-edx/imm32/register +19070 +19071 Single-int-var-in-ebx: # (payload list var) +19072 0x11/imm32/alloc-id:fake:payload +19073 0x11/imm32/alloc-id:fake +19074 Int-var-in-ebx/imm32 +19075 0/imm32/next +19076 0/imm32/next +19077 +19078 Int-var-in-ebx: # (payload list var) +19079 0x11/imm32/alloc-id:fake:payload +19080 0/imm32/name +19081 0/imm32/name +19082 0x11/imm32/alloc-id:fake +19083 Type-int/imm32 +19084 1/imm32/some-block-depth +19085 0/imm32/no-stack-offset +19086 0x11/imm32/alloc-id:fake +19087 $Register-ebx/imm32/register +19088 +19089 Single-int-var-in-esi: # (payload list var) +19090 0x11/imm32/alloc-id:fake:payload +19091 0x11/imm32/alloc-id:fake +19092 Int-var-in-esi/imm32 +19093 0/imm32/next +19094 0/imm32/next +19095 +19096 Int-var-in-esi: # (payload list var) +19097 0x11/imm32/alloc-id:fake:payload +19098 0/imm32/name +19099 0/imm32/name +19100 0x11/imm32/alloc-id:fake +19101 Type-int/imm32 +19102 1/imm32/some-block-depth +19103 0/imm32/no-stack-offset +19104 0x11/imm32/alloc-id:fake +19105 $Register-esi/imm32/register +19106 +19107 Single-int-var-in-edi: # (payload list var) +19108 0x11/imm32/alloc-id:fake:payload +19109 0x11/imm32/alloc-id:fake +19110 Int-var-in-edi/imm32 +19111 0/imm32/next +19112 0/imm32/next +19113 +19114 Int-var-in-edi: # (payload list var) +19115 0x11/imm32/alloc-id:fake:payload +19116 0/imm32/name +19117 0/imm32/name +19118 0x11/imm32/alloc-id:fake +19119 Type-int/imm32 +19120 1/imm32/some-block-depth +19121 0/imm32/no-stack-offset +19122 0x11/imm32/alloc-id:fake +19123 $Register-edi/imm32/register +19124 +19125 Single-lit-var: # (payload list var) +19126 0x11/imm32/alloc-id:fake:payload +19127 0x11/imm32/alloc-id:fake +19128 Lit-var/imm32 +19129 0/imm32/next +19130 0/imm32/next +19131 +19132 Lit-var: # (payload var) +19133 0x11/imm32/alloc-id:fake:payload +19134 0/imm32/name +19135 0/imm32/name +19136 0x11/imm32/alloc-id:fake +19137 Type-literal/imm32 +19138 1/imm32/some-block-depth +19139 0/imm32/no-stack-offset +19140 0/imm32/no-register +19141 0/imm32/no-register +19142 +19143 Type-int: # (payload type-tree) +19144 0x11/imm32/alloc-id:fake:payload +19145 1/imm32/is-atom +19146 1/imm32/value:int +19147 0/imm32/left:unused +19148 0/imm32/right:null +19149 0/imm32/right:null +19150 +19151 Type-literal: # (payload type-tree) +19152 0x11/imm32/alloc-id:fake:payload +19153 1/imm32/is-atom +19154 0/imm32/value:literal +19155 0/imm32/left:unused +19156 0/imm32/right:null +19157 0/imm32/right:null +19158 +19159 Type-addr: # (payload type-tree) +19160 0x11/imm32/alloc-id:fake:payload +19161 1/imm32/is-atom +19162 2/imm32/value:addr +19163 0/imm32/left:unused +19164 0/imm32/right:null +19165 0/imm32/right:null +19166 +19167 Type-byte: # (payload type-tree) +19168 0x11/imm32/alloc-id:fake:payload +19169 1/imm32/is-atom +19170 8/imm32/value:byte +19171 0/imm32/left:unused +19172 0/imm32/right:null +19173 0/imm32/right:null +19174 +19175 == code +19176 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) +19177 # . prologue +19178 55/push-ebp +19179 89/<- %ebp 4/r32/esp +19180 # . save registers +19181 50/push-eax +19182 51/push-ecx +19183 # ecx = primitive +19184 8b/-> *(ebp+0x10) 1/r32/ecx +19185 # emit primitive name +19186 (emit-indent *(ebp+8) *Curr-block-depth) +19187 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax +19188 (write-buffered *(ebp+8) %eax) +19189 # emit rm32 if necessary +19190 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-rm32 +19191 # emit r32 if necessary +19192 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # Primitive-subx-r32 +19193 # emit imm32 if necessary +19194 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # Primitive-subx-imm32 +19195 # emit imm8 if necessary +19196 (emit-subx-imm8 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # Primitive-subx-imm8 +19197 # emit disp32 if necessary +19198 (emit-subx-disp32 *(ebp+8) *(ecx+0x30) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-disp32 +19199 (write-buffered *(ebp+8) Newline) +19200 $emit-subx-primitive:end: +19201 # . restore registers +19202 59/pop-to-ecx +19203 58/pop-to-eax +19204 # . epilogue +19205 89/<- %esp 5/r32/ebp +19206 5d/pop-to-ebp +19207 c3/return +19208 +19209 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +19210 # . prologue +19211 55/push-ebp +19212 89/<- %ebp 4/r32/esp +19213 # . save registers +19214 50/push-eax +19215 # if (l == 0) return +19216 81 7/subop/compare *(ebp+0xc) 0/imm32 +19217 74/jump-if-= $emit-subx-rm32:end/disp8 +19218 # var v/eax: (addr stmt-var) +19219 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax +19220 (emit-subx-var-as-rm32 *(ebp+8) %eax) +19221 $emit-subx-rm32:end: +19222 # . restore registers +19223 58/pop-to-eax +19224 # . epilogue +19225 89/<- %esp 5/r32/ebp +19226 5d/pop-to-ebp +19227 c3/return +19228 +19229 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location, err: (addr buffered-file), ed: (addr exit-descriptor) -> var/eax: (addr stmt-var) +19230 # . prologue +19231 55/push-ebp +19232 89/<- %ebp 4/r32/esp +19233 # . save registers +19234 51/push-ecx +19235 # eax = l +19236 8b/-> *(ebp+0xc) 0/r32/eax +19237 # ecx = stmt +19238 8b/-> *(ebp+8) 1/r32/ecx +19239 # if (l == 1) return stmt->inouts +19240 { +19241 3d/compare-eax-and 1/imm32 +19242 75/jump-if-!= break/disp8 +19243 $get-stmt-operand-from-arg-location:1: +19244 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +19245 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +19246 } +19247 # if (l == 2) return stmt->inouts->next +19248 { +19249 3d/compare-eax-and 2/imm32 +19250 75/jump-if-!= break/disp8 +19251 $get-stmt-operand-from-arg-location:2: +19252 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +19253 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +19254 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +19255 } +19256 # if (l == 3) return stmt->outputs +19257 { +19258 3d/compare-eax-and 3/imm32 +19259 75/jump-if-!= break/disp8 +19260 $get-stmt-operand-from-arg-location:3: +19261 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +19262 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +19263 } +19264 # abort +19265 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 +19266 $get-stmt-operand-from-arg-location:end: +19267 # . restore registers +19268 59/pop-to-ecx +19269 # . epilogue +19270 89/<- %esp 5/r32/ebp +19271 5d/pop-to-ebp +19272 c3/return +19273 +19274 $get-stmt-operand-from-arg-location:abort: +19275 # error("invalid arg-location " eax) +19276 (write-buffered *(ebp+0x10) "invalid arg-location ") +19277 (write-int32-hex-buffered *(ebp+0x10) %eax) +19278 (write-buffered *(ebp+0x10) Newline) +19279 (flush *(ebp+0x10)) +19280 (stop *(ebp+0x14) 1) +19281 # never gets here +19282 +19283 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +19284 # . prologue +19285 55/push-ebp +19286 89/<- %ebp 4/r32/esp +19287 # . save registers +19288 50/push-eax +19289 51/push-ecx +19290 # if (l == 0) return +19291 81 7/subop/compare *(ebp+0xc) 0/imm32 +19292 0f 84/jump-if-= $emit-subx-r32:end/disp32 +19293 # var v/eax: (addr stmt-var) +19294 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +19295 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +19296 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +19297 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) +19298 (write-buffered *(ebp+8) Space) +19299 (write-int32-hex-buffered *(ebp+8) *eax) +19300 (write-buffered *(ebp+8) "/r32") +19301 $emit-subx-r32:end: +19302 # . restore registers +19303 59/pop-to-ecx +19304 58/pop-to-eax +19305 # . epilogue +19306 89/<- %esp 5/r32/ebp +19307 5d/pop-to-ebp +19308 c3/return +19309 +19310 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +19311 # . prologue +19312 55/push-ebp +19313 89/<- %ebp 4/r32/esp +19314 # . save registers +19315 50/push-eax +19316 51/push-ecx +19317 # if (l == 0) return +19318 81 7/subop/compare *(ebp+0xc) 0/imm32 +19319 0f 84/jump-if-= $emit-subx-imm32:end/disp32 +19320 # var v/eax: (handle var) +19321 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +19322 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +19323 (lookup *eax *(eax+4)) # Var-name Var-name => eax +19324 (write-buffered *(ebp+8) Space) +19325 (write-buffered *(ebp+8) %eax) +19326 (write-buffered *(ebp+8) "/imm32") +19327 $emit-subx-imm32:end: +19328 # . restore registers +19329 59/pop-to-ecx +19330 58/pop-to-eax +19331 # . epilogue +19332 89/<- %esp 5/r32/ebp +19333 5d/pop-to-ebp +19334 c3/return +19335 +19336 emit-subx-imm8: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +19337 # . prologue +19338 55/push-ebp +19339 89/<- %ebp 4/r32/esp +19340 # . save registers +19341 50/push-eax +19342 51/push-ecx +19343 # if (l == 0) return +19344 81 7/subop/compare *(ebp+0xc) 0/imm32 +19345 0f 84/jump-if-= $emit-subx-imm32:end/disp32 +19346 # var v/eax: (handle var) +19347 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +19348 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +19349 (lookup *eax *(eax+4)) # Var-name Var-name => eax +19350 (write-buffered *(ebp+8) Space) +19351 (write-buffered *(ebp+8) %eax) +19352 (write-buffered *(ebp+8) "/imm8") +19353 $emit-subx-imm8:end: +19354 # . restore registers +19355 59/pop-to-ecx +19356 58/pop-to-eax +19357 # . epilogue +19358 89/<- %esp 5/r32/ebp +19359 5d/pop-to-ebp +19360 c3/return +19361 +19362 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +19363 # . prologue +19364 55/push-ebp +19365 89/<- %ebp 4/r32/esp +19366 # . save registers +19367 50/push-eax +19368 51/push-ecx +19369 # if (location == 0) return +19370 81 7/subop/compare *(ebp+0xc) 0/imm32 +19371 0f 84/jump-if-= $emit-subx-disp32:end/disp32 +19372 # var v/eax: (addr stmt-var) +19373 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax +19374 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +19375 (lookup *eax *(eax+4)) # Var-name Var-name => eax +19376 (write-buffered *(ebp+8) Space) +19377 (write-buffered *(ebp+8) %eax) +19378 # hack: if instruction operation starts with "break", emit ":break" +19379 # var name/ecx: (addr array byte) = lookup(stmt->operation) +19380 8b/-> *(ebp+0x10) 0/r32/eax +19381 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +19382 89/<- %ecx 0/r32/eax +19383 { +19384 (string-starts-with? %ecx "break") # => eax +19385 3d/compare-eax-and 0/imm32/false +19386 74/jump-if-= break/disp8 +19387 (write-buffered *(ebp+8) ":break") +19388 } +19389 # hack: if instruction operation starts with "loop", emit ":loop" +19390 { +19391 (string-starts-with? %ecx "loop") # => eax +19392 3d/compare-eax-and 0/imm32/false +19393 74/jump-if-= break/disp8 +19394 (write-buffered *(ebp+8) ":loop") +19395 } +19396 (write-buffered *(ebp+8) "/disp32") +19397 $emit-subx-disp32:end: +19398 # . restore registers +19399 59/pop-to-ecx +19400 58/pop-to-eax +19401 # . epilogue +19402 89/<- %esp 5/r32/ebp +19403 5d/pop-to-ebp +19404 c3/return +19405 +19406 emit-call: # out: (addr buffered-file), stmt: (addr stmt) +19407 # . prologue +19408 55/push-ebp +19409 89/<- %ebp 4/r32/esp +19410 # . save registers +19411 50/push-eax +19412 51/push-ecx +19413 # +19414 (emit-indent *(ebp+8) *Curr-block-depth) +19415 (write-buffered *(ebp+8) "(") +19416 # ecx = stmt +19417 8b/-> *(ebp+0xc) 1/r32/ecx +19418 # - emit function name +19419 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +19420 (write-buffered *(ebp+8) %eax) +19421 # - emit arguments +19422 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) +19423 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +19424 { +19425 # if (curr == null) break +19426 3d/compare-eax-and 0/imm32 +19427 74/jump-if-= break/disp8 +19428 # +19429 (emit-subx-call-operand *(ebp+8) %eax) +19430 # curr = lookup(curr->next) +19431 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +19432 eb/jump loop/disp8 +19433 } +19434 # +19435 (write-buffered *(ebp+8) ")\n") +19436 $emit-call:end: +19437 # . restore registers +19438 59/pop-to-ecx +19439 58/pop-to-eax +19440 # . epilogue +19441 89/<- %esp 5/r32/ebp +19442 5d/pop-to-ebp +19443 c3/return +19444 +19445 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) +19446 # shares code with emit-subx-var-as-rm32 +19447 # . prologue +19448 55/push-ebp +19449 89/<- %ebp 4/r32/esp +19450 # . save registers +19451 50/push-eax +19452 51/push-ecx +19453 56/push-esi +19454 # ecx = s +19455 8b/-> *(ebp+0xc) 1/r32/ecx +19456 # var operand/esi: (addr var) = lookup(s->value) +19457 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +19458 89/<- %esi 0/r32/eax +19459 # if (operand->register && !s->is-deref?) emit "%__" +19460 { +19461 $emit-subx-call-operand:check-for-register-direct: +19462 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19463 74/jump-if-= break/disp8 +19464 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19465 75/jump-if-!= break/disp8 +19466 $emit-subx-call-operand:register-direct: +19467 (write-buffered *(ebp+8) " %") +19468 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +19469 (write-buffered *(ebp+8) %eax) +19470 e9/jump $emit-subx-call-operand:end/disp32 +19471 } +19472 # else if (operand->register && s->is-deref?) emit "*__" +19473 { +19474 $emit-subx-call-operand:check-for-register-indirect: +19475 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19476 74/jump-if-= break/disp8 +19477 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19478 74/jump-if-= break/disp8 +19479 $emit-subx-call-operand:register-indirect: +19480 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) +19481 e9/jump $emit-subx-call-operand:end/disp32 +19482 } +19483 # else if (operand->stack-offset) emit "*(ebp+__)" +19484 { +19485 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +19486 74/jump-if-= break/disp8 +19487 $emit-subx-call-operand:stack: +19488 (emit-subx-call-operand-stack *(ebp+8) %esi) +19489 e9/jump $emit-subx-call-operand:end/disp32 +19490 } +19491 # else if (operand->type == literal) emit "__" +19492 { +19493 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +19494 81 7/subop/compare *(eax+4) 0/imm32 # Type-tree-left +19495 75/jump-if-!= break/disp8 +19496 $emit-subx-call-operand:literal: +19497 (write-buffered *(ebp+8) Space) +19498 (lookup *esi *(esi+4)) # Var-name Var-name => eax +19499 (write-buffered *(ebp+8) %eax) +19500 } +19501 $emit-subx-call-operand:end: +19502 # . restore registers +19503 5e/pop-to-esi +19504 59/pop-to-ecx +19505 58/pop-to-eax +19506 # . epilogue +19507 89/<- %esp 5/r32/ebp +19508 5d/pop-to-ebp +19509 c3/return +19510 +19511 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) +19512 # . prologue +19513 55/push-ebp +19514 89/<- %ebp 4/r32/esp +19515 # . save registers +19516 50/push-eax +19517 51/push-ecx +19518 56/push-esi +19519 # esi = v +19520 8b/-> *(ebp+0xc) 6/r32/esi +19521 # var size/ecx: int = size-of-deref(v) +19522 (size-of-deref %esi) # => eax +19523 89/<- %ecx 0/r32/eax +19524 # var reg-name/esi: (addr array byte) = lookup(v->register) +19525 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +19526 89/<- %esi 0/r32/eax +19527 # TODO: assert size is a multiple of 4 +19528 # var i/eax: int = 0 +19529 b8/copy-to-eax 0/imm32 +19530 { +19531 $emit-subx-call-operand-register-indirect:loop: +19532 # if (i >= size) break +19533 39/compare %eax 1/r32/ecx +19534 7d/jump-if->= break/disp8 +19535 # emit " *(" v->register "+" i ")" +19536 (write-buffered *(ebp+8) " *(") +19537 (write-buffered *(ebp+8) %esi) +19538 (write-buffered *(ebp+8) "+") +19539 (write-int32-hex-buffered *(ebp+8) %eax) +19540 (write-buffered *(ebp+8) ")") +19541 # i += 4 +19542 05/add-to-eax 4/imm32 +19543 # +19544 eb/jump loop/disp8 +19545 } +19546 $emit-subx-call-operand-register-indirect:end: +19547 # . restore registers +19548 5e/pop-to-esi +19549 59/pop-to-ecx +19550 58/pop-to-eax +19551 # . epilogue +19552 89/<- %esp 5/r32/ebp +19553 5d/pop-to-ebp +19554 c3/return +19555 +19556 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) +19557 # . prologue +19558 55/push-ebp +19559 89/<- %ebp 4/r32/esp +19560 # . save registers +19561 50/push-eax +19562 51/push-ecx +19563 56/push-esi +19564 # esi = v +19565 8b/-> *(ebp+0xc) 6/r32/esi +19566 # var curr/ecx: int = v->offset +19567 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset +19568 # var max/eax: int = v->offset + size-of(v) +19569 (size-of %esi) # => eax +19570 # TODO: assert size is a multiple of 4 +19571 01/add-to %eax 1/r32/ecx +19572 { +19573 $emit-subx-call-operand-stack:loop: +19574 # if (curr >= max) break +19575 39/compare %ecx 0/r32/eax +19576 7d/jump-if->= break/disp8 +19577 # emit " *(ebp+" curr ")" +19578 (write-buffered *(ebp+8) " *(ebp+") +19579 (write-int32-hex-buffered *(ebp+8) %ecx) +19580 (write-buffered *(ebp+8) ")") +19581 # i += 4 +19582 81 0/subop/add %ecx 4/imm32 +19583 # +19584 eb/jump loop/disp8 +19585 } +19586 $emit-subx-call-operand-stack:end: +19587 # . restore registers +19588 5e/pop-to-esi +19589 59/pop-to-ecx +19590 58/pop-to-eax +19591 # . epilogue +19592 89/<- %esp 5/r32/ebp +19593 5d/pop-to-ebp +19594 c3/return +19595 +19596 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) +19597 # . prologue +19598 55/push-ebp +19599 89/<- %ebp 4/r32/esp +19600 # . save registers +19601 50/push-eax +19602 51/push-ecx +19603 56/push-esi +19604 # ecx = s +19605 8b/-> *(ebp+0xc) 1/r32/ecx +19606 # var operand/esi: (addr var) = lookup(s->value) +19607 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +19608 89/<- %esi 0/r32/eax +19609 # if (operand->register && s->is-deref?) emit "*__" +19610 { +19611 $emit-subx-var-as-rm32:check-for-register-indirect: +19612 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19613 74/jump-if-= break/disp8 +19614 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19615 74/jump-if-= break/disp8 +19616 $emit-subx-var-as-rm32:register-indirect: +19617 (write-buffered *(ebp+8) " *") +19618 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +19619 (write-buffered *(ebp+8) %eax) +19620 e9/jump $emit-subx-var-as-rm32:end/disp32 19621 } -19622 $mu-stmt-matches-primitive?:check-outputs: -19623 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) -19624 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -19625 89/<- %esi 0/r32/eax -19626 # var curr2/edi: (addr list var) = lookup(primitive->outputs) -19627 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax -19628 89/<- %edi 0/r32/eax -19629 { -19630 $mu-stmt-matches-primitive?:outputs-loop: -19631 # if (curr == 0) return (curr2 == 0) -19632 { -19633 $mu-stmt-matches-primitive?:check-both-outputs-null: -19634 81 7/subop/compare %esi 0/imm32 -19635 75/jump-if-!= break/disp8 -19636 { -19637 $mu-stmt-matches-primitive?:stmt-output-null: -19638 81 7/subop/compare %edi 0/imm32 -19639 75/jump-if-!= break/disp8 -19640 $mu-stmt-matches-primitive?:both-outputs-null: -19641 # return true -19642 b8/copy-to-eax 1/imm32 -19643 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19644 } -19645 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: -19646 # return false -19647 b8/copy-to-eax 0/imm32 -19648 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19649 } -19650 # if (curr2 == 0) return false -19651 { -19652 $mu-stmt-matches-primitive?:check-prim-output-null: -19653 81 7/subop/compare %edi 0/imm32 -19654 75/jump-if-!= break/disp8 -19655 $mu-stmt-matches-primitive?:prim-output-is-null: -19656 b8/copy-to-eax 0/imm32 -19657 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19658 } -19659 # if (curr != curr2) return false -19660 { -19661 $mu-stmt-matches-primitive?:check-outputs-match: -19662 (lookup *edi *(edi+4)) # List-value List-value => eax -19663 (operand-matches-primitive? %esi %eax) # => eax -19664 3d/compare-eax-and 0/imm32/false -19665 75/jump-if-!= break/disp8 -19666 $mu-stmt-matches-primitive?:outputs-match: -19667 b8/copy-to-eax 0/imm32 -19668 e9/jump $mu-stmt-matches-primitive?:end/disp32 -19669 } -19670 $mu-stmt-matches-primitive?:next-output: -19671 # curr = lookup(curr->next) -19672 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -19673 89/<- %esi 0/r32/eax -19674 # curr2 = lookup(curr2->next) -19675 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -19676 89/<- %edi 0/r32/eax -19677 # -19678 e9/jump loop/disp32 -19679 } -19680 $mu-stmt-matches-primitive?:return-true: -19681 b8/copy-to-eax 1/imm32 -19682 $mu-stmt-matches-primitive?:end: -19683 # . restore registers -19684 5f/pop-to-edi -19685 5e/pop-to-esi -19686 5b/pop-to-ebx -19687 5a/pop-to-edx -19688 59/pop-to-ecx -19689 # . epilogue -19690 89/<- %esp 5/r32/ebp -19691 5d/pop-to-ebp -19692 c3/return -19693 -19694 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean -19695 # . prologue -19696 55/push-ebp -19697 89/<- %ebp 4/r32/esp -19698 # . save registers -19699 51/push-ecx -19700 52/push-edx -19701 53/push-ebx -19702 56/push-esi -19703 57/push-edi -19704 # ecx = s -19705 8b/-> *(ebp+8) 1/r32/ecx -19706 # var var/esi: (addr var) = lookup(s->value) -19707 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -19708 89/<- %esi 0/r32/eax -19709 # edi = prim-var -19710 8b/-> *(ebp+0xc) 7/r32/edi -19711 $operand-matches-primitive?:check-type: -19712 # if !category-match?(var->type, prim-var->type) return false -19713 # . var vtype/ebx: (addr type-tree) = lookup(var->type) -19714 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -19715 89/<- %ebx 0/r32/eax -19716 # . var ptype/eax: (addr type-tree) = lookup(prim-var->type) -19717 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -19718 (subx-type-category-match? %ebx %eax) # => eax -19719 3d/compare-eax-and 0/imm32/false -19720 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 -19721 { -19722 $operand-matches-primitive?:check-register: -19723 # if prim-var is in memory and var is in register but dereference, match -19724 { -19725 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -19726 0f 85/jump-if-!= break/disp32 -19727 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19728 74/jump-if-= break/disp8 -19729 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19730 74/jump-if-= break/disp8 -19731 $operand-matches-primitive?:var-deref-match: -19732 e9/jump $operand-matches-primitive?:return-true/disp32 -19733 } -19734 # if prim-var is in register and var is in register but dereference, no match -19735 { -19736 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -19737 0f 84/jump-if-= break/disp32 -19738 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -19739 0f 84/jump-if-= break/disp32 -19740 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -19741 74/jump-if-= break/disp8 -19742 $operand-matches-primitive?:var-deref-no-match: -19743 e9/jump $operand-matches-primitive?:return-false/disp32 -19744 } -19745 # return false if var->register doesn't match prim-var->register -19746 { -19747 # if register addresses are equal, it's a match -19748 # var vreg/ebx: (addr array byte) = lookup(var->register) -19749 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -19750 89/<- %ebx 0/r32/eax -19751 # var preg/ecx: (addr array byte) = lookup(prim-var->register) -19752 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -19753 89/<- %ecx 0/r32/eax -19754 # if (vreg == preg) break -19755 39/compare %ecx 3/r32/ebx -19756 74/jump-if-= break/disp8 -19757 $operand-matches-primitive?:var-register-no-match: -19758 # if either address is 0, return false -19759 81 7/subop/compare %ebx 0/imm32 -19760 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -19761 81 7/subop/compare %ecx 0/imm32 -19762 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -19763 # if prim-var->register is wildcard, it's a match -19764 (string-equal? %ecx "*") # Any-register => eax -19765 3d/compare-eax-and 0/imm32/false -19766 75/jump-if-!= break/disp8 -19767 $operand-matches-primitive?:wildcard-no-match: -19768 # if string contents aren't equal, return false -19769 (string-equal? %ecx %ebx) # => eax -19770 3d/compare-eax-and 0/imm32/false -19771 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -19772 } -19773 } -19774 $operand-matches-primitive?:return-true: -19775 b8/copy-to-eax 1/imm32/true -19776 eb/jump $operand-matches-primitive?:end/disp8 -19777 $operand-matches-primitive?:return-false: -19778 b8/copy-to-eax 0/imm32/false -19779 $operand-matches-primitive?:end: -19780 # . restore registers -19781 5f/pop-to-edi -19782 5e/pop-to-esi -19783 5b/pop-to-ebx -19784 5a/pop-to-edx -19785 59/pop-to-ecx -19786 # . epilogue -19787 89/<- %esp 5/r32/ebp -19788 5d/pop-to-ebp -19789 c3/return -19790 -19791 find-matching-function: # functions: (addr function), stmt: (addr stmt) -> result/eax: (addr function) -19792 # . prologue -19793 55/push-ebp -19794 89/<- %ebp 4/r32/esp -19795 # . save registers -19796 51/push-ecx -19797 # var curr/ecx: (handle function) = functions -19798 8b/-> *(ebp+8) 1/r32/ecx -19799 { -19800 # if (curr == null) break -19801 81 7/subop/compare %ecx 0/imm32 -19802 74/jump-if-= break/disp8 -19803 #? (write-buffered Stderr "iter\n") -19804 #? (flush Stderr) -19805 # if match(stmt, curr) return curr -19806 { -19807 (mu-stmt-matches-function? *(ebp+0xc) %ecx) # => eax -19808 3d/compare-eax-and 0/imm32/false -19809 74/jump-if-= break/disp8 -19810 89/<- %eax 1/r32/ecx -19811 eb/jump $find-matching-function:end/disp8 -19812 } -19813 # curr = curr->next -19814 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax -19815 89/<- %ecx 0/r32/eax -19816 # -19817 eb/jump loop/disp8 -19818 } -19819 # return null -19820 b8/copy-to-eax 0/imm32 -19821 $find-matching-function:end: -19822 # . restore registers -19823 59/pop-to-ecx -19824 # . epilogue -19825 89/<- %esp 5/r32/ebp -19826 5d/pop-to-ebp -19827 c3/return -19828 -19829 # Just compare names; user-defined functions don't support overloading yet. -19830 mu-stmt-matches-function?: # stmt: (addr stmt1), function: (addr function) -> result/eax: boolean -19831 # . prologue -19832 55/push-ebp -19833 89/<- %ebp 4/r32/esp -19834 # . save registers -19835 51/push-ecx -19836 # return function->name == stmt->operation -19837 # ecx = lookup(stmt->operation) -19838 8b/-> *(ebp+8) 0/r32/eax -19839 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -19840 89/<- %ecx 0/r32/eax -19841 # eax = lookup(function->name) -19842 8b/-> *(ebp+0xc) 0/r32/eax -19843 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19844 (string-equal? %eax %ecx) # => eax -19845 $mu-stmt-matches-function?:end: -19846 # . restore registers -19847 59/pop-to-ecx -19848 # . epilogue -19849 89/<- %esp 5/r32/ebp -19850 5d/pop-to-ebp -19851 c3/return -19852 -19853 # Type-checking happens elsewhere. This method is for selecting between -19854 # primitives. -19855 subx-type-category-match?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean -19856 # . prologue -19857 55/push-ebp -19858 89/<- %ebp 4/r32/esp -19859 # . save registers -19860 51/push-ecx -19861 # var alit/ecx: boolean = is-literal-type?(a) -19862 (is-simple-mu-type? *(ebp+8) 0) # => eax -19863 89/<- %ecx 0/r32/eax -19864 # var blit/eax: boolean = is-literal-type?(b) -19865 (is-simple-mu-type? *(ebp+0xc) 0) # => eax -19866 # return alit == blit -19867 39/compare %eax 1/r32/ecx -19868 0f 94/set-byte-if-= %al -19869 81 4/subop/and %eax 0xff/imm32 -19870 $subx-type-category-match?:end: -19871 # . restore registers -19872 59/pop-to-ecx -19873 # . epilogue -19874 89/<- %esp 5/r32/ebp -19875 5d/pop-to-ebp -19876 c3/return -19877 -19878 is-simple-mu-type?: # a: (addr type-tree), n: type-id -> result/eax: boolean -19879 # . prologue -19880 55/push-ebp -19881 89/<- %ebp 4/r32/esp -19882 # . save registers -19883 51/push-ecx -19884 # ecx = n -19885 8b/-> *(ebp+0xc) 1/r32/ecx -19886 # return (a->value == n) -19887 8b/-> *(ebp+8) 0/r32/eax -19888 39/compare *(eax+4) 1/r32/ecx # Type-tree-value -19889 0f 94/set-byte-if-= %al -19890 81 4/subop/and %eax 0xff/imm32 -19891 $is-simple-mu-type?:end: -19892 # . restore registers -19893 59/pop-to-ecx -19894 # . epilogue -19895 89/<- %esp 5/r32/ebp -19896 5d/pop-to-ebp -19897 c3/return -19898 -19899 is-mu-addr-type?: # a: (addr type-tree) -> result/eax: boolean -19900 # . prologue -19901 55/push-ebp -19902 89/<- %ebp 4/r32/esp -19903 # eax = a -19904 8b/-> *(ebp+8) 0/r32/eax -19905 # if (!a->is-atom?) a = a->left -19906 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -19907 { -19908 75/jump-if-!= break/disp8 -19909 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19910 } -19911 # return (a->value == addr) -19912 81 7/subop/compare *(eax+4) 2/imm32/addr # Type-tree-value -19913 0f 94/set-byte-if-= %al -19914 81 4/subop/and %eax 0xff/imm32 -19915 $is-mu-addr-type?:end: -19916 # . epilogue -19917 89/<- %esp 5/r32/ebp -19918 5d/pop-to-ebp -19919 c3/return -19920 -19921 is-mu-array-type?: # a: (addr type-tree) -> result/eax: boolean -19922 # . prologue -19923 55/push-ebp -19924 89/<- %ebp 4/r32/esp -19925 # eax = a -19926 8b/-> *(ebp+8) 0/r32/eax -19927 # if (!a->is-atom?) a = a->left -19928 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -19929 { -19930 75/jump-if-!= break/disp8 -19931 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19932 } -19933 # return (a->value == array) -19934 81 7/subop/compare *(eax+4) 3/imm32/array # Type-tree-value -19935 0f 94/set-byte-if-= %al -19936 81 4/subop/and %eax 0xff/imm32 -19937 $is-mu-array-type?:end: -19938 # . epilogue -19939 89/<- %esp 5/r32/ebp -19940 5d/pop-to-ebp -19941 c3/return -19942 -19943 is-mu-stream-type?: # a: (addr type-tree) -> result/eax: boolean -19944 # . prologue -19945 55/push-ebp -19946 89/<- %ebp 4/r32/esp -19947 # eax = a -19948 8b/-> *(ebp+8) 0/r32/eax -19949 # if (!a->is-atom?) a = a->left -19950 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -19951 { -19952 75/jump-if-!= break/disp8 -19953 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19954 } -19955 # return (a->value == stream) -19956 81 7/subop/compare *(eax+4) 0xb/imm32/stream # Type-tree-value -19957 0f 94/set-byte-if-= %al -19958 81 4/subop/and %eax 0xff/imm32 -19959 $is-mu-stream-type?:end: -19960 # . epilogue -19961 89/<- %esp 5/r32/ebp -19962 5d/pop-to-ebp -19963 c3/return -19964 -19965 test-emit-subx-stmt-primitive: -19966 # Primitive operation on a variable on the stack. -19967 # increment foo -19968 # => -19969 # ff 0/subop/increment *(ebp-8) -19970 # -19971 # There's a variable on the var stack as follows: -19972 # name: 'foo' -19973 # type: int -19974 # stack-offset: -8 -19975 # -19976 # There's a primitive with this info: -19977 # name: 'increment' -19978 # inouts: int/mem -19979 # value: 'ff 0/subop/increment' -19980 # -19981 # . prologue -19982 55/push-ebp -19983 89/<- %ebp 4/r32/esp -19984 # setup -19985 (clear-stream _test-output-stream) -19986 (clear-stream $_test-output-buffered-file->buffer) -19987 # simulate allocated payloads starting with an initial fake alloc-id (0x11) -19988 $test-emit-subx-stmt-primitive:initialize-type: -19989 # var type/ecx: (payload type-tree) = int -19990 68/push 0/imm32/right:null -19991 68/push 0/imm32/right:null -19992 68/push 0/imm32/left:unused -19993 68/push 1/imm32/value:int -19994 68/push 1/imm32/is-atom?:true -19995 68/push 0x11/imm32/alloc-id:fake:payload -19996 89/<- %ecx 4/r32/esp -19997 $test-emit-subx-stmt-primitive:initialize-var: -19998 # var var-foo/ecx: (payload var) = var(type) -19999 68/push 0/imm32/no-register -20000 68/push 0/imm32/no-register -20001 68/push -8/imm32/stack-offset -20002 68/push 1/imm32/block-depth -20003 51/push-ecx/type -20004 68/push 0x11/imm32/alloc-id:fake -20005 68/push 0/imm32/name -20006 68/push 0/imm32/name -20007 68/push 0x11/imm32/alloc-id:fake:payload -20008 89/<- %ecx 4/r32/esp -20009 $test-emit-subx-stmt-primitive:initialize-var-name: -20010 # var-foo->name = "foo" -20011 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20012 (copy-array Heap "foo" %eax) -20013 $test-emit-subx-stmt-primitive:initialize-stmt-var: -20014 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -20015 68/push 0/imm32/is-deref:false -20016 68/push 0/imm32/next -20017 68/push 0/imm32/next -20018 51/push-ecx/var-foo -20019 68/push 0x11/imm32/alloc-id:fake -20020 68/push 0x11/imm32/alloc-id:fake:payload -20021 89/<- %ebx 4/r32/esp -20022 $test-emit-subx-stmt-primitive:initialize-stmt: -20023 # var stmt/esi: (addr statement) -20024 68/push 0/imm32/no-outputs -20025 68/push 0/imm32/no-outputs -20026 53/push-ebx/inouts -20027 68/push 0x11/imm32/alloc-id:fake -20028 68/push 0/imm32/operation -20029 68/push 0/imm32/operation -20030 68/push 1/imm32/tag -20031 89/<- %esi 4/r32/esp -20032 $test-emit-subx-stmt-primitive:initialize-stmt-operation: -20033 # stmt->operation = "increment" -20034 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20035 (copy-array Heap "increment" %eax) -20036 $test-emit-subx-stmt-primitive:initialize-primitive: -20037 # var primitives/ebx: (addr primitive) -20038 68/push 0/imm32/next -20039 68/push 0/imm32/next -20040 68/push 0/imm32/output-is-write-only -20041 68/push 0/imm32/no-disp32 -20042 68/push 0/imm32/no-imm8 -20043 68/push 0/imm32/no-imm32 -20044 68/push 0/imm32/no-r32 -20045 68/push 1/imm32/rm32-is-first-inout -20046 68/push 0/imm32/subx-name -20047 68/push 0/imm32/subx-name -20048 68/push 0/imm32/no-outputs -20049 68/push 0/imm32/no-outputs -20050 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -20051 68/push 0x11/imm32/alloc-id:fake -20052 68/push 0/imm32/name -20053 68/push 0/imm32/name -20054 89/<- %ebx 4/r32/esp -20055 $test-emit-subx-stmt-primitive:initialize-primitive-name: -20056 # primitives->name = "increment" -20057 (copy-array Heap "increment" %ebx) # Primitive-name -20058 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: -20059 # primitives->subx-name = "ff 0/subop/increment" -20060 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -20061 (copy-array Heap "ff 0/subop/increment" %eax) -20062 # convert -20063 c7 0/subop/copy *Curr-block-depth 0/imm32 -20064 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -20065 (flush _test-output-buffered-file) -20066 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20072 # check output -20073 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") -20074 # . epilogue -20075 89/<- %esp 5/r32/ebp -20076 5d/pop-to-ebp -20077 c3/return -20078 -20079 test-emit-subx-stmt-primitive-register: -20080 # Primitive operation on a variable in a register. -20081 # foo <- increment -20082 # => -20083 # ff 0/subop/increment %eax # sub-optimal, but should suffice -20084 # -20085 # There's a variable on the var stack as follows: -20086 # name: 'foo' -20087 # type: int -20088 # register: 'eax' -20089 # -20090 # There's a primitive with this info: -20091 # name: 'increment' -20092 # out: int/reg -20093 # value: 'ff 0/subop/increment' -20094 # -20095 # . prologue -20096 55/push-ebp -20097 89/<- %ebp 4/r32/esp -20098 # setup -20099 (clear-stream _test-output-stream) -20100 (clear-stream $_test-output-buffered-file->buffer) -20101 $test-emit-subx-stmt-primitive-register:initialize-type: -20102 # var type/ecx: (payload type-tree) = int -20103 68/push 0/imm32/right:null -20104 68/push 0/imm32/right:null -20105 68/push 0/imm32/left:unused -20106 68/push 1/imm32/value:int -20107 68/push 1/imm32/is-atom?:true -20108 68/push 0x11/imm32/alloc-id:fake:payload -20109 89/<- %ecx 4/r32/esp -20110 $test-emit-subx-stmt-primitive-register:initialize-var: -20111 # var var-foo/ecx: (payload var) -20112 68/push 0/imm32/register -20113 68/push 0/imm32/register -20114 68/push 0/imm32/no-stack-offset -20115 68/push 1/imm32/block-depth -20116 51/push-ecx -20117 68/push 0x11/imm32/alloc-id:fake -20118 68/push 0/imm32/name -20119 68/push 0/imm32/name -20120 68/push 0x11/imm32/alloc-id:fake:payload -20121 89/<- %ecx 4/r32/esp -20122 $test-emit-subx-stmt-primitive-register:initialize-var-name: -20123 # var-foo->name = "foo" -20124 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20125 (copy-array Heap "foo" %eax) -20126 $test-emit-subx-stmt-primitive-register:initialize-var-register: -20127 # var-foo->register = "eax" -20128 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20129 (copy-array Heap "eax" %eax) -20130 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: -20131 # var operand/ebx: (payload stmt-var) -20132 68/push 0/imm32/is-deref:false -20133 68/push 0/imm32/next -20134 68/push 0/imm32/next -20135 51/push-ecx/var-foo -20136 68/push 0x11/imm32/alloc-id:fake -20137 68/push 0x11/imm32/alloc-id:fake:payload -20138 89/<- %ebx 4/r32/esp -20139 $test-emit-subx-stmt-primitive-register:initialize-stmt: -20140 # var stmt/esi: (addr statement) -20141 53/push-ebx/outputs -20142 68/push 0x11/imm32/alloc-id:fake -20143 68/push 0/imm32/no-inouts -20144 68/push 0/imm32/no-inouts -20145 68/push 0/imm32/operation -20146 68/push 0/imm32/operation -20147 68/push 1/imm32 -20148 89/<- %esi 4/r32/esp -20149 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: -20150 # stmt->operation = "increment" -20151 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20152 (copy-array Heap "increment" %eax) -20153 $test-emit-subx-stmt-primitive-register:initialize-formal-var: -20154 # var formal-var/ebx: (payload var) -20155 68/push 0/imm32/register -20156 68/push 0/imm32/register -20157 68/push 0/imm32/no-stack-offset +19622 # if (operand->register && !s->is-deref?) emit "%__" +19623 { +19624 $emit-subx-var-as-rm32:check-for-register-direct: +19625 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19626 74/jump-if-= break/disp8 +19627 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19628 75/jump-if-!= break/disp8 +19629 $emit-subx-var-as-rm32:register-direct: +19630 (write-buffered *(ebp+8) " %") +19631 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +19632 (write-buffered *(ebp+8) %eax) +19633 e9/jump $emit-subx-var-as-rm32:end/disp32 +19634 } +19635 # else if (operand->stack-offset) emit "*(ebp+__)" +19636 { +19637 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +19638 74/jump-if-= break/disp8 +19639 $emit-subx-var-as-rm32:stack: +19640 (write-buffered *(ebp+8) Space) +19641 (write-buffered *(ebp+8) "*(ebp+") +19642 (write-int32-hex-buffered *(ebp+8) *(esi+0x14)) # Var-offset +19643 (write-buffered *(ebp+8) ")") +19644 } +19645 $emit-subx-var-as-rm32:end: +19646 # . restore registers +19647 5e/pop-to-esi +19648 59/pop-to-ecx +19649 58/pop-to-eax +19650 # . epilogue +19651 89/<- %esp 5/r32/ebp +19652 5d/pop-to-ebp +19653 c3/return +19654 +19655 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) +19656 # . prologue +19657 55/push-ebp +19658 89/<- %ebp 4/r32/esp +19659 # . save registers +19660 51/push-ecx +19661 # var curr/ecx: (addr primitive) = primitives +19662 8b/-> *(ebp+8) 1/r32/ecx +19663 { +19664 $find-matching-primitive:loop: +19665 # if (curr == null) break +19666 81 7/subop/compare %ecx 0/imm32 +19667 74/jump-if-= break/disp8 +19668 # if match(curr, stmt) return curr +19669 { +19670 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax +19671 3d/compare-eax-and 0/imm32/false +19672 74/jump-if-= break/disp8 +19673 89/<- %eax 1/r32/ecx +19674 eb/jump $find-matching-primitive:end/disp8 +19675 } +19676 $find-matching-primitive:next-primitive: +19677 # curr = curr->next +19678 (lookup *(ecx+0x38) *(ecx+0x3c)) # Primitive-next Primitive-next => eax +19679 89/<- %ecx 0/r32/eax +19680 # +19681 e9/jump loop/disp32 +19682 } +19683 # return null +19684 b8/copy-to-eax 0/imm32 +19685 $find-matching-primitive:end: +19686 # . restore registers +19687 59/pop-to-ecx +19688 # . epilogue +19689 89/<- %esp 5/r32/ebp +19690 5d/pop-to-ebp +19691 c3/return +19692 +19693 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean +19694 # A mu stmt matches a primitive if the name matches, all the inout vars +19695 # match, and all the output vars match. +19696 # Vars match if types match and registers match. +19697 # In addition, a stmt output matches a primitive's output if types match +19698 # and the primitive has a wildcard register. +19699 # . prologue +19700 55/push-ebp +19701 89/<- %ebp 4/r32/esp +19702 # . save registers +19703 51/push-ecx +19704 52/push-edx +19705 53/push-ebx +19706 56/push-esi +19707 57/push-edi +19708 # ecx = stmt +19709 8b/-> *(ebp+8) 1/r32/ecx +19710 # edx = primitive +19711 8b/-> *(ebp+0xc) 2/r32/edx +19712 { +19713 $mu-stmt-matches-primitive?:check-name: +19714 # if (primitive->name != stmt->operation) return false +19715 # . var esi: (addr array byte) = lookup(stmt->operation) +19716 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +19717 89/<- %esi 0/r32/eax +19718 # . var edi: (addr array byte) = lookup(primitive->name) +19719 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax +19720 89/<- %edi 0/r32/eax +19721 (string-equal? %esi %edi) # => eax +19722 3d/compare-eax-and 0/imm32/false +19723 75/jump-if-!= break/disp8 +19724 b8/copy-to-eax 0/imm32 +19725 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19726 } +19727 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) +19728 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +19729 89/<- %esi 0/r32/eax +19730 # var curr2/edi: (addr list var) = lookup(primitive->inouts) +19731 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax +19732 89/<- %edi 0/r32/eax +19733 { +19734 $mu-stmt-matches-primitive?:inouts-loop: +19735 # if (curr == 0 && curr2 == 0) move on to check outputs +19736 { +19737 $mu-stmt-matches-primitive?:check-both-inouts-null: +19738 81 7/subop/compare %esi 0/imm32 +19739 75/jump-if-!= break/disp8 +19740 $mu-stmt-matches-primitive?:stmt-inout-null: +19741 81 7/subop/compare %edi 0/imm32 +19742 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 +19743 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: +19744 # return false +19745 b8/copy-to-eax 0/imm32/false +19746 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19747 } +19748 # if (curr2 == 0) return false +19749 { +19750 $mu-stmt-matches-primitive?:check-prim-inout-null: +19751 81 7/subop/compare %edi 0/imm32 +19752 75/jump-if-!= break/disp8 +19753 $mu-stmt-matches-primitive?:prim-inout-null: +19754 b8/copy-to-eax 0/imm32/false +19755 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19756 } +19757 # if (curr != curr2) return false +19758 { +19759 $mu-stmt-matches-primitive?:check-inouts-match: +19760 (lookup *edi *(edi+4)) # List-value List-value => eax +19761 (operand-matches-primitive? %esi %eax) # => eax +19762 3d/compare-eax-and 0/imm32/false +19763 75/jump-if-!= break/disp8 +19764 $mu-stmt-matches-primitive?:inouts-match: +19765 b8/copy-to-eax 0/imm32/false +19766 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19767 } +19768 $mu-stmt-matches-primitive?:next-inout: +19769 # curr = lookup(curr->next) +19770 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +19771 89/<- %esi 0/r32/eax +19772 # curr2 = lookup(curr2->next) +19773 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +19774 89/<- %edi 0/r32/eax +19775 # +19776 e9/jump loop/disp32 +19777 } +19778 $mu-stmt-matches-primitive?:check-outputs: +19779 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) +19780 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +19781 89/<- %esi 0/r32/eax +19782 # var curr2/edi: (addr list var) = lookup(primitive->outputs) +19783 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax +19784 89/<- %edi 0/r32/eax +19785 { +19786 $mu-stmt-matches-primitive?:outputs-loop: +19787 # if (curr == 0) return (curr2 == 0) +19788 { +19789 $mu-stmt-matches-primitive?:check-both-outputs-null: +19790 81 7/subop/compare %esi 0/imm32 +19791 75/jump-if-!= break/disp8 +19792 { +19793 $mu-stmt-matches-primitive?:stmt-output-null: +19794 81 7/subop/compare %edi 0/imm32 +19795 75/jump-if-!= break/disp8 +19796 $mu-stmt-matches-primitive?:both-outputs-null: +19797 # return true +19798 b8/copy-to-eax 1/imm32 +19799 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19800 } +19801 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: +19802 # return false +19803 b8/copy-to-eax 0/imm32 +19804 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19805 } +19806 # if (curr2 == 0) return false +19807 { +19808 $mu-stmt-matches-primitive?:check-prim-output-null: +19809 81 7/subop/compare %edi 0/imm32 +19810 75/jump-if-!= break/disp8 +19811 $mu-stmt-matches-primitive?:prim-output-is-null: +19812 b8/copy-to-eax 0/imm32 +19813 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19814 } +19815 # if (curr != curr2) return false +19816 { +19817 $mu-stmt-matches-primitive?:check-outputs-match: +19818 (lookup *edi *(edi+4)) # List-value List-value => eax +19819 (operand-matches-primitive? %esi %eax) # => eax +19820 3d/compare-eax-and 0/imm32/false +19821 75/jump-if-!= break/disp8 +19822 $mu-stmt-matches-primitive?:outputs-match: +19823 b8/copy-to-eax 0/imm32 +19824 e9/jump $mu-stmt-matches-primitive?:end/disp32 +19825 } +19826 $mu-stmt-matches-primitive?:next-output: +19827 # curr = lookup(curr->next) +19828 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +19829 89/<- %esi 0/r32/eax +19830 # curr2 = lookup(curr2->next) +19831 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +19832 89/<- %edi 0/r32/eax +19833 # +19834 e9/jump loop/disp32 +19835 } +19836 $mu-stmt-matches-primitive?:return-true: +19837 b8/copy-to-eax 1/imm32 +19838 $mu-stmt-matches-primitive?:end: +19839 # . restore registers +19840 5f/pop-to-edi +19841 5e/pop-to-esi +19842 5b/pop-to-ebx +19843 5a/pop-to-edx +19844 59/pop-to-ecx +19845 # . epilogue +19846 89/<- %esp 5/r32/ebp +19847 5d/pop-to-ebp +19848 c3/return +19849 +19850 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean +19851 # . prologue +19852 55/push-ebp +19853 89/<- %ebp 4/r32/esp +19854 # . save registers +19855 51/push-ecx +19856 52/push-edx +19857 53/push-ebx +19858 56/push-esi +19859 57/push-edi +19860 # ecx = s +19861 8b/-> *(ebp+8) 1/r32/ecx +19862 # var var/esi: (addr var) = lookup(s->value) +19863 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +19864 89/<- %esi 0/r32/eax +19865 # edi = prim-var +19866 8b/-> *(ebp+0xc) 7/r32/edi +19867 $operand-matches-primitive?:check-type: +19868 # if !category-match?(var->type, prim-var->type) return false +19869 # . var vtype/ebx: (addr type-tree) = lookup(var->type) +19870 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +19871 89/<- %ebx 0/r32/eax +19872 # . var ptype/eax: (addr type-tree) = lookup(prim-var->type) +19873 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +19874 (subx-type-category-match? %ebx %eax) # => eax +19875 3d/compare-eax-and 0/imm32/false +19876 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 +19877 { +19878 $operand-matches-primitive?:check-register: +19879 # if prim-var is in memory and var is in register but dereference, match +19880 { +19881 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +19882 0f 85/jump-if-!= break/disp32 +19883 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19884 74/jump-if-= break/disp8 +19885 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19886 74/jump-if-= break/disp8 +19887 $operand-matches-primitive?:var-deref-match: +19888 e9/jump $operand-matches-primitive?:return-true/disp32 +19889 } +19890 # if prim-var is in register and var is in register but dereference, no match +19891 { +19892 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +19893 0f 84/jump-if-= break/disp32 +19894 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +19895 0f 84/jump-if-= break/disp32 +19896 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +19897 74/jump-if-= break/disp8 +19898 $operand-matches-primitive?:var-deref-no-match: +19899 e9/jump $operand-matches-primitive?:return-false/disp32 +19900 } +19901 # return false if var->register doesn't match prim-var->register +19902 { +19903 # if register addresses are equal, it's a match +19904 # var vreg/ebx: (addr array byte) = lookup(var->register) +19905 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +19906 89/<- %ebx 0/r32/eax +19907 # var preg/ecx: (addr array byte) = lookup(prim-var->register) +19908 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +19909 89/<- %ecx 0/r32/eax +19910 # if (vreg == preg) break +19911 39/compare %ecx 3/r32/ebx +19912 74/jump-if-= break/disp8 +19913 $operand-matches-primitive?:var-register-no-match: +19914 # if either address is 0, return false +19915 81 7/subop/compare %ebx 0/imm32 +19916 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +19917 81 7/subop/compare %ecx 0/imm32 +19918 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +19919 # if prim-var->register is wildcard, it's a match +19920 (string-equal? %ecx "*") # Any-register => eax +19921 3d/compare-eax-and 0/imm32/false +19922 75/jump-if-!= break/disp8 +19923 $operand-matches-primitive?:wildcard-no-match: +19924 # if string contents aren't equal, return false +19925 (string-equal? %ecx %ebx) # => eax +19926 3d/compare-eax-and 0/imm32/false +19927 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +19928 } +19929 } +19930 $operand-matches-primitive?:return-true: +19931 b8/copy-to-eax 1/imm32/true +19932 eb/jump $operand-matches-primitive?:end/disp8 +19933 $operand-matches-primitive?:return-false: +19934 b8/copy-to-eax 0/imm32/false +19935 $operand-matches-primitive?:end: +19936 # . restore registers +19937 5f/pop-to-edi +19938 5e/pop-to-esi +19939 5b/pop-to-ebx +19940 5a/pop-to-edx +19941 59/pop-to-ecx +19942 # . epilogue +19943 89/<- %esp 5/r32/ebp +19944 5d/pop-to-ebp +19945 c3/return +19946 +19947 find-matching-function: # functions: (addr function), stmt: (addr stmt) -> result/eax: (addr function) +19948 # . prologue +19949 55/push-ebp +19950 89/<- %ebp 4/r32/esp +19951 # . save registers +19952 51/push-ecx +19953 # var curr/ecx: (handle function) = functions +19954 8b/-> *(ebp+8) 1/r32/ecx +19955 { +19956 # if (curr == null) break +19957 81 7/subop/compare %ecx 0/imm32 +19958 74/jump-if-= break/disp8 +19959 #? (write-buffered Stderr "iter\n") +19960 #? (flush Stderr) +19961 # if match(stmt, curr) return curr +19962 { +19963 (mu-stmt-matches-function? *(ebp+0xc) %ecx) # => eax +19964 3d/compare-eax-and 0/imm32/false +19965 74/jump-if-= break/disp8 +19966 89/<- %eax 1/r32/ecx +19967 eb/jump $find-matching-function:end/disp8 +19968 } +19969 # curr = curr->next +19970 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax +19971 89/<- %ecx 0/r32/eax +19972 # +19973 eb/jump loop/disp8 +19974 } +19975 # return null +19976 b8/copy-to-eax 0/imm32 +19977 $find-matching-function:end: +19978 # . restore registers +19979 59/pop-to-ecx +19980 # . epilogue +19981 89/<- %esp 5/r32/ebp +19982 5d/pop-to-ebp +19983 c3/return +19984 +19985 # Just compare names; user-defined functions don't support overloading yet. +19986 mu-stmt-matches-function?: # stmt: (addr stmt1), function: (addr function) -> result/eax: boolean +19987 # . prologue +19988 55/push-ebp +19989 89/<- %ebp 4/r32/esp +19990 # . save registers +19991 51/push-ecx +19992 # return function->name == stmt->operation +19993 # ecx = lookup(stmt->operation) +19994 8b/-> *(ebp+8) 0/r32/eax +19995 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +19996 89/<- %ecx 0/r32/eax +19997 # eax = lookup(function->name) +19998 8b/-> *(ebp+0xc) 0/r32/eax +19999 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20000 (string-equal? %eax %ecx) # => eax +20001 $mu-stmt-matches-function?:end: +20002 # . restore registers +20003 59/pop-to-ecx +20004 # . epilogue +20005 89/<- %esp 5/r32/ebp +20006 5d/pop-to-ebp +20007 c3/return +20008 +20009 # Type-checking happens elsewhere. This method is for selecting between +20010 # primitives. +20011 subx-type-category-match?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean +20012 # . prologue +20013 55/push-ebp +20014 89/<- %ebp 4/r32/esp +20015 # . save registers +20016 51/push-ecx +20017 # var alit/ecx: boolean = is-literal-type?(a) +20018 (is-simple-mu-type? *(ebp+8) 0) # => eax +20019 89/<- %ecx 0/r32/eax +20020 # var blit/eax: boolean = is-literal-type?(b) +20021 (is-simple-mu-type? *(ebp+0xc) 0) # => eax +20022 # return alit == blit +20023 39/compare %eax 1/r32/ecx +20024 0f 94/set-byte-if-= %al +20025 81 4/subop/and %eax 0xff/imm32 +20026 $subx-type-category-match?:end: +20027 # . restore registers +20028 59/pop-to-ecx +20029 # . epilogue +20030 89/<- %esp 5/r32/ebp +20031 5d/pop-to-ebp +20032 c3/return +20033 +20034 is-simple-mu-type?: # a: (addr type-tree), n: type-id -> result/eax: boolean +20035 # . prologue +20036 55/push-ebp +20037 89/<- %ebp 4/r32/esp +20038 # . save registers +20039 51/push-ecx +20040 # ecx = n +20041 8b/-> *(ebp+0xc) 1/r32/ecx +20042 # return (a->value == n) +20043 8b/-> *(ebp+8) 0/r32/eax +20044 39/compare *(eax+4) 1/r32/ecx # Type-tree-value +20045 0f 94/set-byte-if-= %al +20046 81 4/subop/and %eax 0xff/imm32 +20047 $is-simple-mu-type?:end: +20048 # . restore registers +20049 59/pop-to-ecx +20050 # . epilogue +20051 89/<- %esp 5/r32/ebp +20052 5d/pop-to-ebp +20053 c3/return +20054 +20055 is-mu-addr-type?: # a: (addr type-tree) -> result/eax: boolean +20056 # . prologue +20057 55/push-ebp +20058 89/<- %ebp 4/r32/esp +20059 # eax = a +20060 8b/-> *(ebp+8) 0/r32/eax +20061 # if (!a->is-atom?) a = a->left +20062 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +20063 { +20064 75/jump-if-!= break/disp8 +20065 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20066 } +20067 # return (a->value == addr) +20068 81 7/subop/compare *(eax+4) 2/imm32/addr # Type-tree-value +20069 0f 94/set-byte-if-= %al +20070 81 4/subop/and %eax 0xff/imm32 +20071 $is-mu-addr-type?:end: +20072 # . epilogue +20073 89/<- %esp 5/r32/ebp +20074 5d/pop-to-ebp +20075 c3/return +20076 +20077 is-mu-array-type?: # a: (addr type-tree) -> result/eax: boolean +20078 # . prologue +20079 55/push-ebp +20080 89/<- %ebp 4/r32/esp +20081 # eax = a +20082 8b/-> *(ebp+8) 0/r32/eax +20083 # if (!a->is-atom?) a = a->left +20084 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +20085 { +20086 75/jump-if-!= break/disp8 +20087 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20088 } +20089 # return (a->value == array) +20090 81 7/subop/compare *(eax+4) 3/imm32/array # Type-tree-value +20091 0f 94/set-byte-if-= %al +20092 81 4/subop/and %eax 0xff/imm32 +20093 $is-mu-array-type?:end: +20094 # . epilogue +20095 89/<- %esp 5/r32/ebp +20096 5d/pop-to-ebp +20097 c3/return +20098 +20099 is-mu-stream-type?: # a: (addr type-tree) -> result/eax: boolean +20100 # . prologue +20101 55/push-ebp +20102 89/<- %ebp 4/r32/esp +20103 # eax = a +20104 8b/-> *(ebp+8) 0/r32/eax +20105 # if (!a->is-atom?) a = a->left +20106 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +20107 { +20108 75/jump-if-!= break/disp8 +20109 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20110 } +20111 # return (a->value == stream) +20112 81 7/subop/compare *(eax+4) 0xb/imm32/stream # Type-tree-value +20113 0f 94/set-byte-if-= %al +20114 81 4/subop/and %eax 0xff/imm32 +20115 $is-mu-stream-type?:end: +20116 # . epilogue +20117 89/<- %esp 5/r32/ebp +20118 5d/pop-to-ebp +20119 c3/return +20120 +20121 test-emit-subx-stmt-primitive: +20122 # Primitive operation on a variable on the stack. +20123 # increment foo +20124 # => +20125 # ff 0/subop/increment *(ebp-8) +20126 # +20127 # There's a variable on the var stack as follows: +20128 # name: 'foo' +20129 # type: int +20130 # stack-offset: -8 +20131 # +20132 # There's a primitive with this info: +20133 # name: 'increment' +20134 # inouts: int/mem +20135 # value: 'ff 0/subop/increment' +20136 # +20137 # . prologue +20138 55/push-ebp +20139 89/<- %ebp 4/r32/esp +20140 # setup +20141 (clear-stream _test-output-stream) +20142 (clear-stream $_test-output-buffered-file->buffer) +20143 # simulate allocated payloads starting with an initial fake alloc-id (0x11) +20144 $test-emit-subx-stmt-primitive:initialize-type: +20145 # var type/ecx: (payload type-tree) = int +20146 68/push 0/imm32/right:null +20147 68/push 0/imm32/right:null +20148 68/push 0/imm32/left:unused +20149 68/push 1/imm32/value:int +20150 68/push 1/imm32/is-atom?:true +20151 68/push 0x11/imm32/alloc-id:fake:payload +20152 89/<- %ecx 4/r32/esp +20153 $test-emit-subx-stmt-primitive:initialize-var: +20154 # var var-foo/ecx: (payload var) = var(type) +20155 68/push 0/imm32/no-register +20156 68/push 0/imm32/no-register +20157 68/push -8/imm32/stack-offset 20158 68/push 1/imm32/block-depth -20159 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +20159 51/push-ecx/type 20160 68/push 0x11/imm32/alloc-id:fake 20161 68/push 0/imm32/name 20162 68/push 0/imm32/name 20163 68/push 0x11/imm32/alloc-id:fake:payload -20164 89/<- %ebx 4/r32/esp -20165 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: -20166 # formal-var->name = "dummy" -20167 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -20168 (copy-array Heap "dummy" %eax) -20169 $test-emit-subx-stmt-primitive-register:initialize-formal-register: -20170 # formal-var->register = "*" -20171 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -20172 (copy-array Heap "*" %eax) # Any-register -20173 $test-emit-subx-stmt-primitive-register:initialize-var-list: -20174 # var formal-outputs/ebx: (payload list var) -20175 68/push 0/imm32/next -20176 68/push 0/imm32/next -20177 53/push-ebx/formal-var -20178 68/push 0x11/imm32/alloc-id:fake -20179 68/push 0x11/imm32/alloc-id:fake:payload -20180 89/<- %ebx 4/r32/esp -20181 $test-emit-subx-stmt-primitive-register:initialize-primitive: -20182 # var primitives/ebx: (addr primitive) -20183 68/push 0/imm32/next -20184 68/push 0/imm32/next -20185 68/push 0/imm32/output-is-write-only -20186 68/push 0/imm32/no-disp32 -20187 68/push 0/imm32/no-imm8 -20188 68/push 0/imm32/no-imm32 -20189 68/push 0/imm32/no-r32 -20190 68/push 3/imm32/rm32-is-first-output -20191 68/push 0/imm32/subx-name -20192 68/push 0/imm32/subx-name -20193 53/push-ebx/outputs -20194 68/push 0x11/imm32/alloc-id:fake -20195 68/push 0/imm32/no-inouts -20196 68/push 0/imm32/no-inouts -20197 68/push 0/imm32/name -20198 68/push 0/imm32/name -20199 89/<- %ebx 4/r32/esp -20200 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: -20201 # primitives->name = "increment" -20202 (copy-array Heap "increment" %ebx) # Primitive-name -20203 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: -20204 # primitives->subx-name = "ff 0/subop/increment" -20205 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -20206 (copy-array Heap "ff 0/subop/increment" %eax) -20207 # convert -20208 c7 0/subop/copy *Curr-block-depth 0/imm32 -20209 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -20210 (flush _test-output-buffered-file) -20211 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20217 # check output -20218 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") -20219 # . epilogue -20220 89/<- %esp 5/r32/ebp -20221 5d/pop-to-ebp -20222 c3/return -20223 -20224 test-emit-subx-stmt-select-primitive: -20225 # Select the right primitive between overloads. -20226 # foo <- increment -20227 # => -20228 # ff 0/subop/increment %eax # sub-optimal, but should suffice -20229 # -20230 # There's a variable on the var stack as follows: -20231 # name: 'foo' -20232 # type: int -20233 # register: 'eax' -20234 # -20235 # There's two primitives, as follows: -20236 # - name: 'increment' -20237 # out: int/reg -20238 # value: 'ff 0/subop/increment' -20239 # - name: 'increment' -20240 # inout: int/mem -20241 # value: 'ff 0/subop/increment' -20242 # -20243 # . prologue -20244 55/push-ebp -20245 89/<- %ebp 4/r32/esp -20246 # setup -20247 (clear-stream _test-output-stream) -20248 (clear-stream $_test-output-buffered-file->buffer) -20249 $test-emit-subx-stmt-select-primitive:initialize-type: -20250 # var type/ecx: (payload type-tree) = int -20251 68/push 0/imm32/right:null -20252 68/push 0/imm32/right:null -20253 68/push 0/imm32/left:unused -20254 68/push 1/imm32/value:int -20255 68/push 1/imm32/is-atom?:true -20256 68/push 0x11/imm32/alloc-id:fake:payload -20257 89/<- %ecx 4/r32/esp -20258 $test-emit-subx-stmt-select-primitive:initialize-var: -20259 # var var-foo/ecx: (payload var) -20260 68/push 0/imm32/register -20261 68/push 0/imm32/register -20262 68/push 0/imm32/no-stack-offset -20263 68/push 1/imm32/block-depth -20264 51/push-ecx -20265 68/push 0x11/imm32/alloc-id:fake -20266 68/push 0/imm32/name -20267 68/push 0/imm32/name -20268 68/push 0x11/imm32/alloc-id:fake:payload -20269 89/<- %ecx 4/r32/esp -20270 $test-emit-subx-stmt-select-primitive:initialize-var-name: -20271 # var-foo->name = "foo" -20272 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20273 (copy-array Heap "foo" %eax) -20274 $test-emit-subx-stmt-select-primitive:initialize-var-register: -20275 # var-foo->register = "eax" -20276 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20277 (copy-array Heap "eax" %eax) -20278 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: -20279 # var operand/ebx: (payload stmt-var) -20280 68/push 0/imm32/is-deref:false -20281 68/push 0/imm32/next -20282 68/push 0/imm32/next -20283 51/push-ecx/var-foo -20284 68/push 0x11/imm32/alloc-id:fake -20285 68/push 0x11/imm32/alloc-id:fake:payload -20286 89/<- %ebx 4/r32/esp -20287 $test-emit-subx-stmt-select-primitive:initialize-stmt: -20288 # var stmt/esi: (addr statement) -20289 53/push-ebx/outputs -20290 68/push 0x11/imm32/alloc-id:fake -20291 68/push 0/imm32/no-inouts -20292 68/push 0/imm32/no-inouts -20293 68/push 0/imm32/operation -20294 68/push 0/imm32/operation -20295 68/push 1/imm32 -20296 89/<- %esi 4/r32/esp -20297 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: -20298 # stmt->operation = "increment" -20299 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20300 (copy-array Heap "increment" %eax) -20301 $test-emit-subx-stmt-select-primitive:initialize-formal-var: -20302 # var formal-var/ebx: (payload var) -20303 68/push 0/imm32/register -20304 68/push 0/imm32/register -20305 68/push 0/imm32/no-stack-offset -20306 68/push 1/imm32/block-depth -20307 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -20308 68/push 0x11/imm32/alloc-id:fake -20309 68/push 0/imm32/name -20310 68/push 0/imm32/name -20311 68/push 0x11/imm32/alloc-id:fake:payload -20312 89/<- %ebx 4/r32/esp -20313 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: -20314 # formal-var->name = "dummy" -20315 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -20316 (copy-array Heap "dummy" %eax) -20317 $test-emit-subx-stmt-select-primitive:initialize-formal-register: -20318 # formal-var->register = "*" -20319 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -20320 (copy-array Heap "*" %eax) # Any-register -20321 $test-emit-subx-stmt-select-primitive:initialize-var-list: -20322 # var formal-outputs/ebx: (payload list var) -20323 68/push 0/imm32/next -20324 68/push 0/imm32/next -20325 53/push-ebx/formal-var -20326 68/push 0x11/imm32/alloc-id:fake -20327 68/push 0x11/imm32/alloc-id:fake:payload -20328 89/<- %ebx 4/r32/esp -20329 $test-emit-subx-stmt-select-primitive:initialize-primitive2: -20330 # var primitive2/edi: (payload primitive) +20164 89/<- %ecx 4/r32/esp +20165 $test-emit-subx-stmt-primitive:initialize-var-name: +20166 # var-foo->name = "foo" +20167 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20168 (copy-array Heap "foo" %eax) +20169 $test-emit-subx-stmt-primitive:initialize-stmt-var: +20170 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +20171 68/push 0/imm32/is-deref:false +20172 68/push 0/imm32/next +20173 68/push 0/imm32/next +20174 51/push-ecx/var-foo +20175 68/push 0x11/imm32/alloc-id:fake +20176 68/push 0x11/imm32/alloc-id:fake:payload +20177 89/<- %ebx 4/r32/esp +20178 $test-emit-subx-stmt-primitive:initialize-stmt: +20179 # var stmt/esi: (addr statement) +20180 68/push 0/imm32/no-outputs +20181 68/push 0/imm32/no-outputs +20182 53/push-ebx/inouts +20183 68/push 0x11/imm32/alloc-id:fake +20184 68/push 0/imm32/operation +20185 68/push 0/imm32/operation +20186 68/push 1/imm32/tag +20187 89/<- %esi 4/r32/esp +20188 $test-emit-subx-stmt-primitive:initialize-stmt-operation: +20189 # stmt->operation = "increment" +20190 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20191 (copy-array Heap "increment" %eax) +20192 $test-emit-subx-stmt-primitive:initialize-primitive: +20193 # var primitives/ebx: (addr primitive) +20194 68/push 0/imm32/next +20195 68/push 0/imm32/next +20196 68/push 0/imm32/output-is-write-only +20197 68/push 0/imm32/no-disp32 +20198 68/push 0/imm32/no-imm8 +20199 68/push 0/imm32/no-imm32 +20200 68/push 0/imm32/no-r32 +20201 68/push 1/imm32/rm32-is-first-inout +20202 68/push 0/imm32/subx-name +20203 68/push 0/imm32/subx-name +20204 68/push 0/imm32/no-outputs +20205 68/push 0/imm32/no-outputs +20206 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +20207 68/push 0x11/imm32/alloc-id:fake +20208 68/push 0/imm32/name +20209 68/push 0/imm32/name +20210 89/<- %ebx 4/r32/esp +20211 $test-emit-subx-stmt-primitive:initialize-primitive-name: +20212 # primitives->name = "increment" +20213 (copy-array Heap "increment" %ebx) # Primitive-name +20214 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: +20215 # primitives->subx-name = "ff 0/subop/increment" +20216 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +20217 (copy-array Heap "ff 0/subop/increment" %eax) +20218 # convert +20219 c7 0/subop/copy *Curr-block-depth 0/imm32 +20220 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +20221 (flush _test-output-buffered-file) +20222 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20228 # check output +20229 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") +20230 # . epilogue +20231 89/<- %esp 5/r32/ebp +20232 5d/pop-to-ebp +20233 c3/return +20234 +20235 test-emit-subx-stmt-primitive-register: +20236 # Primitive operation on a variable in a register. +20237 # foo <- increment +20238 # => +20239 # ff 0/subop/increment %eax # sub-optimal, but should suffice +20240 # +20241 # There's a variable on the var stack as follows: +20242 # name: 'foo' +20243 # type: int +20244 # register: 'eax' +20245 # +20246 # There's a primitive with this info: +20247 # name: 'increment' +20248 # out: int/reg +20249 # value: 'ff 0/subop/increment' +20250 # +20251 # . prologue +20252 55/push-ebp +20253 89/<- %ebp 4/r32/esp +20254 # setup +20255 (clear-stream _test-output-stream) +20256 (clear-stream $_test-output-buffered-file->buffer) +20257 $test-emit-subx-stmt-primitive-register:initialize-type: +20258 # var type/ecx: (payload type-tree) = int +20259 68/push 0/imm32/right:null +20260 68/push 0/imm32/right:null +20261 68/push 0/imm32/left:unused +20262 68/push 1/imm32/value:int +20263 68/push 1/imm32/is-atom?:true +20264 68/push 0x11/imm32/alloc-id:fake:payload +20265 89/<- %ecx 4/r32/esp +20266 $test-emit-subx-stmt-primitive-register:initialize-var: +20267 # var var-foo/ecx: (payload var) +20268 68/push 0/imm32/register +20269 68/push 0/imm32/register +20270 68/push 0/imm32/no-stack-offset +20271 68/push 1/imm32/block-depth +20272 51/push-ecx +20273 68/push 0x11/imm32/alloc-id:fake +20274 68/push 0/imm32/name +20275 68/push 0/imm32/name +20276 68/push 0x11/imm32/alloc-id:fake:payload +20277 89/<- %ecx 4/r32/esp +20278 $test-emit-subx-stmt-primitive-register:initialize-var-name: +20279 # var-foo->name = "foo" +20280 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20281 (copy-array Heap "foo" %eax) +20282 $test-emit-subx-stmt-primitive-register:initialize-var-register: +20283 # var-foo->register = "eax" +20284 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +20285 (copy-array Heap "eax" %eax) +20286 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: +20287 # var operand/ebx: (payload stmt-var) +20288 68/push 0/imm32/is-deref:false +20289 68/push 0/imm32/next +20290 68/push 0/imm32/next +20291 51/push-ecx/var-foo +20292 68/push 0x11/imm32/alloc-id:fake +20293 68/push 0x11/imm32/alloc-id:fake:payload +20294 89/<- %ebx 4/r32/esp +20295 $test-emit-subx-stmt-primitive-register:initialize-stmt: +20296 # var stmt/esi: (addr statement) +20297 53/push-ebx/outputs +20298 68/push 0x11/imm32/alloc-id:fake +20299 68/push 0/imm32/no-inouts +20300 68/push 0/imm32/no-inouts +20301 68/push 0/imm32/operation +20302 68/push 0/imm32/operation +20303 68/push 1/imm32 +20304 89/<- %esi 4/r32/esp +20305 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: +20306 # stmt->operation = "increment" +20307 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20308 (copy-array Heap "increment" %eax) +20309 $test-emit-subx-stmt-primitive-register:initialize-formal-var: +20310 # var formal-var/ebx: (payload var) +20311 68/push 0/imm32/register +20312 68/push 0/imm32/register +20313 68/push 0/imm32/no-stack-offset +20314 68/push 1/imm32/block-depth +20315 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +20316 68/push 0x11/imm32/alloc-id:fake +20317 68/push 0/imm32/name +20318 68/push 0/imm32/name +20319 68/push 0x11/imm32/alloc-id:fake:payload +20320 89/<- %ebx 4/r32/esp +20321 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: +20322 # formal-var->name = "dummy" +20323 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +20324 (copy-array Heap "dummy" %eax) +20325 $test-emit-subx-stmt-primitive-register:initialize-formal-register: +20326 # formal-var->register = "*" +20327 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +20328 (copy-array Heap "*" %eax) # Any-register +20329 $test-emit-subx-stmt-primitive-register:initialize-var-list: +20330 # var formal-outputs/ebx: (payload list var) 20331 68/push 0/imm32/next 20332 68/push 0/imm32/next -20333 68/push 0/imm32/output-is-write-only -20334 68/push 0/imm32/no-disp32 -20335 68/push 0/imm32/no-imm8 -20336 68/push 0/imm32/no-imm32 -20337 68/push 0/imm32/no-r32 -20338 68/push 3/imm32/rm32-is-first-output -20339 68/push 0/imm32/subx-name -20340 68/push 0/imm32/subx-name -20341 53/push-ebx/outputs -20342 68/push 0x11/imm32/alloc-id:fake -20343 68/push 0/imm32/no-inouts -20344 68/push 0/imm32/no-inouts -20345 68/push 0/imm32/name -20346 68/push 0/imm32/name -20347 68/push 0x11/imm32/alloc-id:fake:payload -20348 89/<- %edi 4/r32/esp -20349 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: -20350 # primitives->name = "increment" -20351 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -20352 (copy-array Heap "increment" %eax) -20353 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: -20354 # primitives->subx-name = "ff 0/subop/increment" -20355 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -20356 (copy-array Heap "ff 0/subop/increment" %eax) -20357 $test-emit-subx-stmt-select-primitive:initialize-primitive: -20358 # var primitives/ebx: (addr primitive) -20359 57/push-edi -20360 68/push 0x11/imm32/alloc-id:fake -20361 68/push 0/imm32/output-is-write-only -20362 68/push 0/imm32/no-disp32 -20363 68/push 0/imm32/no-imm8 -20364 68/push 0/imm32/no-imm32 -20365 68/push 0/imm32/no-r32 -20366 68/push 1/imm32/rm32-is-first-inout -20367 68/push 0/imm32/subx-name -20368 68/push 0/imm32/subx-name -20369 68/push 0/imm32/no-outputs -20370 68/push 0/imm32/no-outputs -20371 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -20372 68/push 0x11/imm32/alloc-id:fake -20373 68/push 0/imm32/name -20374 68/push 0/imm32/name -20375 89/<- %ebx 4/r32/esp -20376 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: -20377 # primitives->name = "increment" -20378 (copy-array Heap "increment" %ebx) # Primitive-name -20379 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: -20380 # primitives->subx-name = "ff 0/subop/increment" -20381 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -20382 (copy-array Heap "ff 0/subop/increment" %eax) -20383 # convert -20384 c7 0/subop/copy *Curr-block-depth 0/imm32 -20385 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -20386 (flush _test-output-buffered-file) -20387 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20393 # check output -20394 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") -20395 # . epilogue -20396 89/<- %esp 5/r32/ebp -20397 5d/pop-to-ebp -20398 c3/return -20399 -20400 test-emit-subx-stmt-select-primitive-2: -20401 # Select the right primitive between overloads. -20402 # increment foo -20403 # => -20404 # ff 0/subop/increment %eax # sub-optimal, but should suffice -20405 # -20406 # There's a variable on the var stack as follows: -20407 # name: 'foo' -20408 # type: int -20409 # register: 'eax' -20410 # -20411 # There's two primitives, as follows: -20412 # - name: 'increment' -20413 # out: int/reg -20414 # value: 'ff 0/subop/increment' -20415 # - name: 'increment' -20416 # inout: int/mem -20417 # value: 'ff 0/subop/increment' -20418 # -20419 # . prologue -20420 55/push-ebp -20421 89/<- %ebp 4/r32/esp -20422 # setup -20423 (clear-stream _test-output-stream) -20424 (clear-stream $_test-output-buffered-file->buffer) -20425 $test-emit-subx-stmt-select-primitive-2:initialize-type: -20426 # var type/ecx: (payload type-tree) = int -20427 68/push 0/imm32/right:null -20428 68/push 0/imm32/right:null -20429 68/push 0/imm32/left:unused -20430 68/push 1/imm32/value:int -20431 68/push 1/imm32/is-atom?:true -20432 68/push 0x11/imm32/alloc-id:fake:payload -20433 89/<- %ecx 4/r32/esp -20434 $test-emit-subx-stmt-select-primitive-2:initialize-var: -20435 # var var-foo/ecx: (payload var) -20436 68/push 0/imm32/register -20437 68/push 0/imm32/register -20438 68/push 0/imm32/no-stack-offset -20439 68/push 1/imm32/block-depth -20440 51/push-ecx -20441 68/push 0x11/imm32/alloc-id:fake -20442 68/push 0/imm32/name -20443 68/push 0/imm32/name -20444 68/push 0x11/imm32/alloc-id:fake:payload -20445 89/<- %ecx 4/r32/esp -20446 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: -20447 # var-foo->name = "foo" -20448 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20449 (copy-array Heap "foo" %eax) -20450 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: -20451 # var-foo->register = "eax" -20452 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20453 (copy-array Heap "eax" %eax) -20454 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: -20455 # var operand/ebx: (payload stmt-var) -20456 68/push 0/imm32/is-deref:false -20457 68/push 0/imm32/next -20458 68/push 0/imm32/next -20459 51/push-ecx/var-foo -20460 68/push 0x11/imm32/alloc-id:fake -20461 68/push 0x11/imm32/alloc-id:fake:payload -20462 89/<- %ebx 4/r32/esp -20463 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: -20464 # var stmt/esi: (addr statement) -20465 68/push 0/imm32/no-outputs -20466 68/push 0/imm32/no-outputs -20467 53/push-ebx/inouts -20468 68/push 0x11/imm32/alloc-id:fake -20469 68/push 0/imm32/operation -20470 68/push 0/imm32/operation -20471 68/push 1/imm32 -20472 89/<- %esi 4/r32/esp -20473 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: -20474 # stmt->operation = "increment" -20475 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20476 (copy-array Heap "increment" %eax) -20477 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: -20478 # var formal-var/ebx: (payload var) -20479 68/push 0/imm32/register -20480 68/push 0/imm32/register -20481 68/push 0/imm32/no-stack-offset -20482 68/push 1/imm32/block-depth -20483 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -20484 68/push 0x11/imm32/alloc-id:fake -20485 68/push 0/imm32/name -20486 68/push 0/imm32/name -20487 68/push 0x11/imm32/alloc-id:fake:payload -20488 89/<- %ebx 4/r32/esp -20489 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: -20490 # formal-var->name = "dummy" -20491 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -20492 (copy-array Heap "dummy" %eax) -20493 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: -20494 # formal-var->register = "*" -20495 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -20496 (copy-array Heap "*" %eax) # Any-register -20497 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: -20498 # var formal-outputs/ebx: (payload list stmt-var) -20499 68/push 0/imm32/next -20500 68/push 0/imm32/next -20501 53/push-ebx/formal-var -20502 68/push 0x11/imm32/alloc-id:fake +20333 53/push-ebx/formal-var +20334 68/push 0x11/imm32/alloc-id:fake +20335 68/push 0x11/imm32/alloc-id:fake:payload +20336 89/<- %ebx 4/r32/esp +20337 $test-emit-subx-stmt-primitive-register:initialize-primitive: +20338 # var primitives/ebx: (addr primitive) +20339 68/push 0/imm32/next +20340 68/push 0/imm32/next +20341 68/push 0/imm32/output-is-write-only +20342 68/push 0/imm32/no-disp32 +20343 68/push 0/imm32/no-imm8 +20344 68/push 0/imm32/no-imm32 +20345 68/push 0/imm32/no-r32 +20346 68/push 3/imm32/rm32-is-first-output +20347 68/push 0/imm32/subx-name +20348 68/push 0/imm32/subx-name +20349 53/push-ebx/outputs +20350 68/push 0x11/imm32/alloc-id:fake +20351 68/push 0/imm32/no-inouts +20352 68/push 0/imm32/no-inouts +20353 68/push 0/imm32/name +20354 68/push 0/imm32/name +20355 89/<- %ebx 4/r32/esp +20356 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: +20357 # primitives->name = "increment" +20358 (copy-array Heap "increment" %ebx) # Primitive-name +20359 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: +20360 # primitives->subx-name = "ff 0/subop/increment" +20361 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +20362 (copy-array Heap "ff 0/subop/increment" %eax) +20363 # convert +20364 c7 0/subop/copy *Curr-block-depth 0/imm32 +20365 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +20366 (flush _test-output-buffered-file) +20367 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20373 # check output +20374 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") +20375 # . epilogue +20376 89/<- %esp 5/r32/ebp +20377 5d/pop-to-ebp +20378 c3/return +20379 +20380 test-emit-subx-stmt-select-primitive: +20381 # Select the right primitive between overloads. +20382 # foo <- increment +20383 # => +20384 # ff 0/subop/increment %eax # sub-optimal, but should suffice +20385 # +20386 # There's a variable on the var stack as follows: +20387 # name: 'foo' +20388 # type: int +20389 # register: 'eax' +20390 # +20391 # There's two primitives, as follows: +20392 # - name: 'increment' +20393 # out: int/reg +20394 # value: 'ff 0/subop/increment' +20395 # - name: 'increment' +20396 # inout: int/mem +20397 # value: 'ff 0/subop/increment' +20398 # +20399 # . prologue +20400 55/push-ebp +20401 89/<- %ebp 4/r32/esp +20402 # setup +20403 (clear-stream _test-output-stream) +20404 (clear-stream $_test-output-buffered-file->buffer) +20405 $test-emit-subx-stmt-select-primitive:initialize-type: +20406 # var type/ecx: (payload type-tree) = int +20407 68/push 0/imm32/right:null +20408 68/push 0/imm32/right:null +20409 68/push 0/imm32/left:unused +20410 68/push 1/imm32/value:int +20411 68/push 1/imm32/is-atom?:true +20412 68/push 0x11/imm32/alloc-id:fake:payload +20413 89/<- %ecx 4/r32/esp +20414 $test-emit-subx-stmt-select-primitive:initialize-var: +20415 # var var-foo/ecx: (payload var) +20416 68/push 0/imm32/register +20417 68/push 0/imm32/register +20418 68/push 0/imm32/no-stack-offset +20419 68/push 1/imm32/block-depth +20420 51/push-ecx +20421 68/push 0x11/imm32/alloc-id:fake +20422 68/push 0/imm32/name +20423 68/push 0/imm32/name +20424 68/push 0x11/imm32/alloc-id:fake:payload +20425 89/<- %ecx 4/r32/esp +20426 $test-emit-subx-stmt-select-primitive:initialize-var-name: +20427 # var-foo->name = "foo" +20428 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20429 (copy-array Heap "foo" %eax) +20430 $test-emit-subx-stmt-select-primitive:initialize-var-register: +20431 # var-foo->register = "eax" +20432 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +20433 (copy-array Heap "eax" %eax) +20434 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: +20435 # var operand/ebx: (payload stmt-var) +20436 68/push 0/imm32/is-deref:false +20437 68/push 0/imm32/next +20438 68/push 0/imm32/next +20439 51/push-ecx/var-foo +20440 68/push 0x11/imm32/alloc-id:fake +20441 68/push 0x11/imm32/alloc-id:fake:payload +20442 89/<- %ebx 4/r32/esp +20443 $test-emit-subx-stmt-select-primitive:initialize-stmt: +20444 # var stmt/esi: (addr statement) +20445 53/push-ebx/outputs +20446 68/push 0x11/imm32/alloc-id:fake +20447 68/push 0/imm32/no-inouts +20448 68/push 0/imm32/no-inouts +20449 68/push 0/imm32/operation +20450 68/push 0/imm32/operation +20451 68/push 1/imm32 +20452 89/<- %esi 4/r32/esp +20453 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: +20454 # stmt->operation = "increment" +20455 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20456 (copy-array Heap "increment" %eax) +20457 $test-emit-subx-stmt-select-primitive:initialize-formal-var: +20458 # var formal-var/ebx: (payload var) +20459 68/push 0/imm32/register +20460 68/push 0/imm32/register +20461 68/push 0/imm32/no-stack-offset +20462 68/push 1/imm32/block-depth +20463 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +20464 68/push 0x11/imm32/alloc-id:fake +20465 68/push 0/imm32/name +20466 68/push 0/imm32/name +20467 68/push 0x11/imm32/alloc-id:fake:payload +20468 89/<- %ebx 4/r32/esp +20469 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: +20470 # formal-var->name = "dummy" +20471 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +20472 (copy-array Heap "dummy" %eax) +20473 $test-emit-subx-stmt-select-primitive:initialize-formal-register: +20474 # formal-var->register = "*" +20475 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +20476 (copy-array Heap "*" %eax) # Any-register +20477 $test-emit-subx-stmt-select-primitive:initialize-var-list: +20478 # var formal-outputs/ebx: (payload list var) +20479 68/push 0/imm32/next +20480 68/push 0/imm32/next +20481 53/push-ebx/formal-var +20482 68/push 0x11/imm32/alloc-id:fake +20483 68/push 0x11/imm32/alloc-id:fake:payload +20484 89/<- %ebx 4/r32/esp +20485 $test-emit-subx-stmt-select-primitive:initialize-primitive2: +20486 # var primitive2/edi: (payload primitive) +20487 68/push 0/imm32/next +20488 68/push 0/imm32/next +20489 68/push 0/imm32/output-is-write-only +20490 68/push 0/imm32/no-disp32 +20491 68/push 0/imm32/no-imm8 +20492 68/push 0/imm32/no-imm32 +20493 68/push 0/imm32/no-r32 +20494 68/push 3/imm32/rm32-is-first-output +20495 68/push 0/imm32/subx-name +20496 68/push 0/imm32/subx-name +20497 53/push-ebx/outputs +20498 68/push 0x11/imm32/alloc-id:fake +20499 68/push 0/imm32/no-inouts +20500 68/push 0/imm32/no-inouts +20501 68/push 0/imm32/name +20502 68/push 0/imm32/name 20503 68/push 0x11/imm32/alloc-id:fake:payload -20504 89/<- %ebx 4/r32/esp -20505 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: -20506 # var primitive2/edi: (payload primitive) -20507 68/push 0/imm32/next -20508 68/push 0/imm32/next -20509 68/push 0/imm32/output-is-write-only -20510 68/push 0/imm32/no-disp32 -20511 68/push 0/imm32/no-imm8 -20512 68/push 0/imm32/no-imm32 -20513 68/push 0/imm32/no-r32 -20514 68/push 3/imm32/rm32-is-first-output -20515 68/push 0/imm32/subx-name -20516 68/push 0/imm32/subx-name -20517 53/push-ebx/outputs -20518 68/push 0x11/imm32/alloc-id:fake -20519 68/push 0/imm32/no-inouts -20520 68/push 0/imm32/no-inouts -20521 68/push 0/imm32/name -20522 68/push 0/imm32/name -20523 68/push 0x11/imm32/alloc-id:fake:payload -20524 89/<- %edi 4/r32/esp -20525 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: -20526 # primitives->name = "increment" -20527 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -20528 (copy-array Heap "increment" %eax) -20529 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: -20530 # primitives->subx-name = "ff 0/subop/increment" -20531 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -20532 (copy-array Heap "ff 0/subop/increment" %eax) -20533 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: -20534 # var primitives/ebx: (addr primitive) -20535 57/push-edi -20536 68/push 0x11/imm32/alloc-id:fake -20537 68/push 0/imm32/output-is-write-only -20538 68/push 0/imm32/no-disp32 -20539 68/push 0/imm32/no-imm8 -20540 68/push 0/imm32/no-imm32 -20541 68/push 0/imm32/no-r32 -20542 68/push 1/imm32/rm32-is-first-inout -20543 68/push 0/imm32/subx-name -20544 68/push 0/imm32/subx-name -20545 68/push 0/imm32/no-outputs -20546 68/push 0/imm32/no-outputs -20547 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -20548 68/push 0x11/imm32/alloc-id:fake -20549 68/push 0/imm32/name -20550 68/push 0/imm32/name -20551 89/<- %ebx 4/r32/esp -20552 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: -20553 # primitives->name = "increment" -20554 (copy-array Heap "increment" %ebx) # Primitive-name -20555 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: -20556 # primitives->subx-name = "ff 0/subop/increment" -20557 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -20558 (copy-array Heap "ff 0/subop/increment" %eax) -20559 # convert -20560 c7 0/subop/copy *Curr-block-depth 0/imm32 -20561 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -20562 (flush _test-output-buffered-file) -20563 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20569 # check output -20570 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") -20571 # . epilogue -20572 89/<- %esp 5/r32/ebp -20573 5d/pop-to-ebp -20574 c3/return -20575 -20576 test-increment-register: -20577 # Select the right register between overloads. -20578 # foo <- increment -20579 # => -20580 # 50/increment-eax -20581 # -20582 # There's a variable on the var stack as follows: -20583 # name: 'foo' -20584 # type: int -20585 # register: 'eax' -20586 # -20587 # Primitives are the global definitions. -20588 # -20589 # . prologue -20590 55/push-ebp -20591 89/<- %ebp 4/r32/esp -20592 # setup -20593 (clear-stream _test-output-stream) -20594 (clear-stream $_test-output-buffered-file->buffer) -20595 $test-increment-register:initialize-type: -20596 # var type/ecx: (payload type-tree) = int -20597 68/push 0/imm32/right:null -20598 68/push 0/imm32/right:null -20599 68/push 0/imm32/left:unused -20600 68/push 1/imm32/value:int -20601 68/push 1/imm32/is-atom?:true -20602 68/push 0x11/imm32/alloc-id:fake:payload -20603 89/<- %ecx 4/r32/esp -20604 $test-increment-register:initialize-var: -20605 # var var-foo/ecx: (payload var) -20606 68/push 0/imm32/register -20607 68/push 0/imm32/register -20608 68/push 0/imm32/no-stack-offset -20609 68/push 1/imm32/block-depth -20610 51/push-ecx -20611 68/push 0x11/imm32/alloc-id:fake -20612 68/push 0/imm32/name -20613 68/push 0/imm32/name -20614 68/push 0x11/imm32/alloc-id:fake:payload -20615 89/<- %ecx 4/r32/esp -20616 $test-increment-register:initialize-var-name: -20617 # var-foo->name = "foo" -20618 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20619 (copy-array Heap "foo" %eax) -20620 $test-increment-register:initialize-var-register: -20621 # var-foo->register = "eax" -20622 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20623 (copy-array Heap "eax" %eax) -20624 $test-increment-register:initialize-stmt-var: -20625 # var operand/ebx: (payload stmt-var) -20626 68/push 0/imm32/is-deref:false -20627 68/push 0/imm32/next -20628 68/push 0/imm32/next -20629 51/push-ecx/var-foo -20630 68/push 0x11/imm32/alloc-id:fake -20631 68/push 0x11/imm32/alloc-id:fake:payload -20632 89/<- %ebx 4/r32/esp -20633 $test-increment-register:initialize-stmt: -20634 # var stmt/esi: (addr statement) -20635 53/push-ebx/outputs -20636 68/push 0x11/imm32/alloc-id:fake -20637 68/push 0/imm32/no-inouts -20638 68/push 0/imm32/no-inouts -20639 68/push 0/imm32/operation -20640 68/push 0/imm32/operation -20641 68/push 1/imm32 -20642 89/<- %esi 4/r32/esp -20643 $test-increment-register:initialize-stmt-operation: -20644 # stmt->operation = "increment" -20645 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20646 (copy-array Heap "increment" %eax) -20647 # convert -20648 c7 0/subop/copy *Curr-block-depth 0/imm32 -20649 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -20650 (flush _test-output-buffered-file) -20651 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20657 # check output -20658 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") -20659 # . epilogue -20660 89/<- %esp 5/r32/ebp -20661 5d/pop-to-ebp -20662 c3/return -20663 -20664 test-add-reg-to-reg: -20665 # var1/reg <- add var2/reg -20666 # => -20667 # 01/add-to %var1 var2 -20668 # -20669 # . prologue -20670 55/push-ebp -20671 89/<- %ebp 4/r32/esp -20672 # setup -20673 (clear-stream _test-output-stream) -20674 (clear-stream $_test-output-buffered-file->buffer) -20675 $test-add-reg-to-reg:initialize-type: -20676 # var type/ecx: (payload type-tree) = int -20677 68/push 0/imm32/right:null -20678 68/push 0/imm32/right:null -20679 68/push 0/imm32/left:unused -20680 68/push 1/imm32/value:int -20681 68/push 1/imm32/is-atom?:true -20682 68/push 0x11/imm32/alloc-id:fake:payload -20683 89/<- %ecx 4/r32/esp -20684 $test-add-reg-to-reg:initialize-var1: -20685 # var var1/ecx: (payload var) -20686 68/push 0/imm32/register -20687 68/push 0/imm32/register -20688 68/push 0/imm32/no-stack-offset -20689 68/push 1/imm32/block-depth -20690 51/push-ecx -20691 68/push 0x11/imm32/alloc-id:fake -20692 68/push 0/imm32/name -20693 68/push 0/imm32/name -20694 68/push 0x11/imm32/alloc-id:fake:payload -20695 89/<- %ecx 4/r32/esp -20696 $test-add-reg-to-reg:initialize-var1-name: -20697 # var1->name = "var1" -20698 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20699 (copy-array Heap "var1" %eax) -20700 $test-add-reg-to-reg:initialize-var1-register: -20701 # var1->register = "eax" -20702 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20703 (copy-array Heap "eax" %eax) -20704 $test-add-reg-to-reg:initialize-var2: -20705 # var var2/edx: (payload var) -20706 68/push 0/imm32/register -20707 68/push 0/imm32/register -20708 68/push 0/imm32/no-stack-offset -20709 68/push 1/imm32/block-depth -20710 ff 6/subop/push *(ecx+0x10) -20711 68/push 0x11/imm32/alloc-id:fake -20712 68/push 0/imm32/name -20713 68/push 0/imm32/name -20714 68/push 0x11/imm32/alloc-id:fake:payload -20715 89/<- %edx 4/r32/esp -20716 $test-add-reg-to-reg:initialize-var2-name: -20717 # var2->name = "var2" -20718 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -20719 (copy-array Heap "var2" %eax) -20720 $test-add-reg-to-reg:initialize-var2-register: -20721 # var2->register = "ecx" -20722 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -20723 (copy-array Heap "ecx" %eax) -20724 $test-add-reg-to-reg:initialize-inouts: -20725 # var inouts/esi: (payload stmt-var) = [var2] -20726 68/push 0/imm32/is-deref:false -20727 68/push 0/imm32/next -20728 68/push 0/imm32/next -20729 52/push-edx/var2 -20730 68/push 0x11/imm32/alloc-id:fake -20731 68/push 0x11/imm32/alloc-id:fake:payload -20732 89/<- %esi 4/r32/esp -20733 $test-add-reg-to-reg:initialize-outputs: -20734 # var outputs/edi: (payload stmt-var) = [var1] -20735 68/push 0/imm32/is-deref:false -20736 68/push 0/imm32/next -20737 68/push 0/imm32/next -20738 51/push-ecx/var1 -20739 68/push 0x11/imm32/alloc-id:fake -20740 68/push 0x11/imm32/alloc-id:fake:payload -20741 89/<- %edi 4/r32/esp -20742 $test-add-reg-to-reg:initialize-stmt: -20743 # var stmt/esi: (addr statement) -20744 68/push 0/imm32/next -20745 68/push 0/imm32/next -20746 57/push-edi/outputs -20747 68/push 0x11/imm32/alloc-id:fake -20748 56/push-esi/inouts -20749 68/push 0x11/imm32/alloc-id:fake -20750 68/push 0/imm32/operation -20751 68/push 0/imm32/operation -20752 68/push 1/imm32/tag:stmt1 -20753 89/<- %esi 4/r32/esp -20754 $test-add-reg-to-reg:initialize-stmt-operation: -20755 # stmt->operation = "add" -20756 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20757 (copy-array Heap "add" %eax) -20758 # convert -20759 c7 0/subop/copy *Curr-block-depth 0/imm32 -20760 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -20761 (flush _test-output-buffered-file) -20762 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20768 # check output -20769 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") -20770 # . epilogue -20771 89/<- %esp 5/r32/ebp -20772 5d/pop-to-ebp -20773 c3/return -20774 -20775 test-add-reg-to-mem: -20776 # add-to var1 var2/reg -20777 # => -20778 # 01/add-to *(ebp+__) var2 -20779 # -20780 # . prologue -20781 55/push-ebp -20782 89/<- %ebp 4/r32/esp -20783 # setup -20784 (clear-stream _test-output-stream) -20785 (clear-stream $_test-output-buffered-file->buffer) -20786 $test-add-reg-to-mem:initialize-type: -20787 # var type/ecx: (payload type-tree) = int -20788 68/push 0/imm32/right:null -20789 68/push 0/imm32/right:null -20790 68/push 0/imm32/left:unused -20791 68/push 1/imm32/value:int -20792 68/push 1/imm32/is-atom?:true -20793 68/push 0x11/imm32/alloc-id:fake:payload -20794 89/<- %ecx 4/r32/esp -20795 $test-add-reg-to-mem:initialize-var1: -20796 # var var1/ecx: (payload var) -20797 68/push 0/imm32/register -20798 68/push 0/imm32/register -20799 68/push 8/imm32/stack-offset -20800 68/push 1/imm32/block-depth -20801 51/push-ecx -20802 68/push 0x11/imm32/alloc-id:fake -20803 68/push 0/imm32/name -20804 68/push 0/imm32/name -20805 68/push 0x11/imm32/alloc-id:fake:payload -20806 89/<- %ecx 4/r32/esp -20807 $test-add-reg-to-mem:initialize-var1-name: -20808 # var1->name = "var1" -20809 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20810 (copy-array Heap "var1" %eax) -20811 $test-add-reg-to-mem:initialize-var2: -20812 # var var2/edx: (payload var) -20813 68/push 0/imm32/register -20814 68/push 0/imm32/register -20815 68/push 0/imm32/no-stack-offset -20816 68/push 1/imm32/block-depth -20817 ff 6/subop/push *(ecx+0x10) -20818 68/push 0x11/imm32/alloc-id:fake -20819 68/push 0/imm32/name -20820 68/push 0/imm32/name -20821 68/push 0x11/imm32/alloc-id:fake:payload -20822 89/<- %edx 4/r32/esp -20823 $test-add-reg-to-mem:initialize-var2-name: -20824 # var2->name = "var2" -20825 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -20826 (copy-array Heap "var2" %eax) -20827 $test-add-reg-to-mem:initialize-var2-register: -20828 # var2->register = "ecx" -20829 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -20830 (copy-array Heap "ecx" %eax) -20831 $test-add-reg-to-mem:initialize-inouts: -20832 # var inouts/esi: (payload stmt-var) = [var2] -20833 68/push 0/imm32/is-deref:false -20834 68/push 0/imm32/next -20835 68/push 0/imm32/next -20836 52/push-edx/var2 -20837 68/push 0x11/imm32/alloc-id:fake +20504 89/<- %edi 4/r32/esp +20505 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: +20506 # primitives->name = "increment" +20507 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +20508 (copy-array Heap "increment" %eax) +20509 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: +20510 # primitives->subx-name = "ff 0/subop/increment" +20511 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +20512 (copy-array Heap "ff 0/subop/increment" %eax) +20513 $test-emit-subx-stmt-select-primitive:initialize-primitive: +20514 # var primitives/ebx: (addr primitive) +20515 57/push-edi +20516 68/push 0x11/imm32/alloc-id:fake +20517 68/push 0/imm32/output-is-write-only +20518 68/push 0/imm32/no-disp32 +20519 68/push 0/imm32/no-imm8 +20520 68/push 0/imm32/no-imm32 +20521 68/push 0/imm32/no-r32 +20522 68/push 1/imm32/rm32-is-first-inout +20523 68/push 0/imm32/subx-name +20524 68/push 0/imm32/subx-name +20525 68/push 0/imm32/no-outputs +20526 68/push 0/imm32/no-outputs +20527 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +20528 68/push 0x11/imm32/alloc-id:fake +20529 68/push 0/imm32/name +20530 68/push 0/imm32/name +20531 89/<- %ebx 4/r32/esp +20532 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: +20533 # primitives->name = "increment" +20534 (copy-array Heap "increment" %ebx) # Primitive-name +20535 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: +20536 # primitives->subx-name = "ff 0/subop/increment" +20537 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +20538 (copy-array Heap "ff 0/subop/increment" %eax) +20539 # convert +20540 c7 0/subop/copy *Curr-block-depth 0/imm32 +20541 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +20542 (flush _test-output-buffered-file) +20543 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20549 # check output +20550 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") +20551 # . epilogue +20552 89/<- %esp 5/r32/ebp +20553 5d/pop-to-ebp +20554 c3/return +20555 +20556 test-emit-subx-stmt-select-primitive-2: +20557 # Select the right primitive between overloads. +20558 # increment foo +20559 # => +20560 # ff 0/subop/increment %eax # sub-optimal, but should suffice +20561 # +20562 # There's a variable on the var stack as follows: +20563 # name: 'foo' +20564 # type: int +20565 # register: 'eax' +20566 # +20567 # There's two primitives, as follows: +20568 # - name: 'increment' +20569 # out: int/reg +20570 # value: 'ff 0/subop/increment' +20571 # - name: 'increment' +20572 # inout: int/mem +20573 # value: 'ff 0/subop/increment' +20574 # +20575 # . prologue +20576 55/push-ebp +20577 89/<- %ebp 4/r32/esp +20578 # setup +20579 (clear-stream _test-output-stream) +20580 (clear-stream $_test-output-buffered-file->buffer) +20581 $test-emit-subx-stmt-select-primitive-2:initialize-type: +20582 # var type/ecx: (payload type-tree) = int +20583 68/push 0/imm32/right:null +20584 68/push 0/imm32/right:null +20585 68/push 0/imm32/left:unused +20586 68/push 1/imm32/value:int +20587 68/push 1/imm32/is-atom?:true +20588 68/push 0x11/imm32/alloc-id:fake:payload +20589 89/<- %ecx 4/r32/esp +20590 $test-emit-subx-stmt-select-primitive-2:initialize-var: +20591 # var var-foo/ecx: (payload var) +20592 68/push 0/imm32/register +20593 68/push 0/imm32/register +20594 68/push 0/imm32/no-stack-offset +20595 68/push 1/imm32/block-depth +20596 51/push-ecx +20597 68/push 0x11/imm32/alloc-id:fake +20598 68/push 0/imm32/name +20599 68/push 0/imm32/name +20600 68/push 0x11/imm32/alloc-id:fake:payload +20601 89/<- %ecx 4/r32/esp +20602 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: +20603 # var-foo->name = "foo" +20604 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20605 (copy-array Heap "foo" %eax) +20606 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: +20607 # var-foo->register = "eax" +20608 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +20609 (copy-array Heap "eax" %eax) +20610 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: +20611 # var operand/ebx: (payload stmt-var) +20612 68/push 0/imm32/is-deref:false +20613 68/push 0/imm32/next +20614 68/push 0/imm32/next +20615 51/push-ecx/var-foo +20616 68/push 0x11/imm32/alloc-id:fake +20617 68/push 0x11/imm32/alloc-id:fake:payload +20618 89/<- %ebx 4/r32/esp +20619 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: +20620 # var stmt/esi: (addr statement) +20621 68/push 0/imm32/no-outputs +20622 68/push 0/imm32/no-outputs +20623 53/push-ebx/inouts +20624 68/push 0x11/imm32/alloc-id:fake +20625 68/push 0/imm32/operation +20626 68/push 0/imm32/operation +20627 68/push 1/imm32 +20628 89/<- %esi 4/r32/esp +20629 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: +20630 # stmt->operation = "increment" +20631 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20632 (copy-array Heap "increment" %eax) +20633 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: +20634 # var formal-var/ebx: (payload var) +20635 68/push 0/imm32/register +20636 68/push 0/imm32/register +20637 68/push 0/imm32/no-stack-offset +20638 68/push 1/imm32/block-depth +20639 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +20640 68/push 0x11/imm32/alloc-id:fake +20641 68/push 0/imm32/name +20642 68/push 0/imm32/name +20643 68/push 0x11/imm32/alloc-id:fake:payload +20644 89/<- %ebx 4/r32/esp +20645 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: +20646 # formal-var->name = "dummy" +20647 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +20648 (copy-array Heap "dummy" %eax) +20649 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: +20650 # formal-var->register = "*" +20651 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +20652 (copy-array Heap "*" %eax) # Any-register +20653 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: +20654 # var formal-outputs/ebx: (payload list stmt-var) +20655 68/push 0/imm32/next +20656 68/push 0/imm32/next +20657 53/push-ebx/formal-var +20658 68/push 0x11/imm32/alloc-id:fake +20659 68/push 0x11/imm32/alloc-id:fake:payload +20660 89/<- %ebx 4/r32/esp +20661 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: +20662 # var primitive2/edi: (payload primitive) +20663 68/push 0/imm32/next +20664 68/push 0/imm32/next +20665 68/push 0/imm32/output-is-write-only +20666 68/push 0/imm32/no-disp32 +20667 68/push 0/imm32/no-imm8 +20668 68/push 0/imm32/no-imm32 +20669 68/push 0/imm32/no-r32 +20670 68/push 3/imm32/rm32-is-first-output +20671 68/push 0/imm32/subx-name +20672 68/push 0/imm32/subx-name +20673 53/push-ebx/outputs +20674 68/push 0x11/imm32/alloc-id:fake +20675 68/push 0/imm32/no-inouts +20676 68/push 0/imm32/no-inouts +20677 68/push 0/imm32/name +20678 68/push 0/imm32/name +20679 68/push 0x11/imm32/alloc-id:fake:payload +20680 89/<- %edi 4/r32/esp +20681 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: +20682 # primitives->name = "increment" +20683 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +20684 (copy-array Heap "increment" %eax) +20685 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: +20686 # primitives->subx-name = "ff 0/subop/increment" +20687 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +20688 (copy-array Heap "ff 0/subop/increment" %eax) +20689 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: +20690 # var primitives/ebx: (addr primitive) +20691 57/push-edi +20692 68/push 0x11/imm32/alloc-id:fake +20693 68/push 0/imm32/output-is-write-only +20694 68/push 0/imm32/no-disp32 +20695 68/push 0/imm32/no-imm8 +20696 68/push 0/imm32/no-imm32 +20697 68/push 0/imm32/no-r32 +20698 68/push 1/imm32/rm32-is-first-inout +20699 68/push 0/imm32/subx-name +20700 68/push 0/imm32/subx-name +20701 68/push 0/imm32/no-outputs +20702 68/push 0/imm32/no-outputs +20703 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +20704 68/push 0x11/imm32/alloc-id:fake +20705 68/push 0/imm32/name +20706 68/push 0/imm32/name +20707 89/<- %ebx 4/r32/esp +20708 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: +20709 # primitives->name = "increment" +20710 (copy-array Heap "increment" %ebx) # Primitive-name +20711 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: +20712 # primitives->subx-name = "ff 0/subop/increment" +20713 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +20714 (copy-array Heap "ff 0/subop/increment" %eax) +20715 # convert +20716 c7 0/subop/copy *Curr-block-depth 0/imm32 +20717 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +20718 (flush _test-output-buffered-file) +20719 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20725 # check output +20726 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") +20727 # . epilogue +20728 89/<- %esp 5/r32/ebp +20729 5d/pop-to-ebp +20730 c3/return +20731 +20732 test-increment-register: +20733 # Select the right register between overloads. +20734 # foo <- increment +20735 # => +20736 # 50/increment-eax +20737 # +20738 # There's a variable on the var stack as follows: +20739 # name: 'foo' +20740 # type: int +20741 # register: 'eax' +20742 # +20743 # Primitives are the global definitions. +20744 # +20745 # . prologue +20746 55/push-ebp +20747 89/<- %ebp 4/r32/esp +20748 # setup +20749 (clear-stream _test-output-stream) +20750 (clear-stream $_test-output-buffered-file->buffer) +20751 $test-increment-register:initialize-type: +20752 # var type/ecx: (payload type-tree) = int +20753 68/push 0/imm32/right:null +20754 68/push 0/imm32/right:null +20755 68/push 0/imm32/left:unused +20756 68/push 1/imm32/value:int +20757 68/push 1/imm32/is-atom?:true +20758 68/push 0x11/imm32/alloc-id:fake:payload +20759 89/<- %ecx 4/r32/esp +20760 $test-increment-register:initialize-var: +20761 # var var-foo/ecx: (payload var) +20762 68/push 0/imm32/register +20763 68/push 0/imm32/register +20764 68/push 0/imm32/no-stack-offset +20765 68/push 1/imm32/block-depth +20766 51/push-ecx +20767 68/push 0x11/imm32/alloc-id:fake +20768 68/push 0/imm32/name +20769 68/push 0/imm32/name +20770 68/push 0x11/imm32/alloc-id:fake:payload +20771 89/<- %ecx 4/r32/esp +20772 $test-increment-register:initialize-var-name: +20773 # var-foo->name = "foo" +20774 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20775 (copy-array Heap "foo" %eax) +20776 $test-increment-register:initialize-var-register: +20777 # var-foo->register = "eax" +20778 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +20779 (copy-array Heap "eax" %eax) +20780 $test-increment-register:initialize-stmt-var: +20781 # var operand/ebx: (payload stmt-var) +20782 68/push 0/imm32/is-deref:false +20783 68/push 0/imm32/next +20784 68/push 0/imm32/next +20785 51/push-ecx/var-foo +20786 68/push 0x11/imm32/alloc-id:fake +20787 68/push 0x11/imm32/alloc-id:fake:payload +20788 89/<- %ebx 4/r32/esp +20789 $test-increment-register:initialize-stmt: +20790 # var stmt/esi: (addr statement) +20791 53/push-ebx/outputs +20792 68/push 0x11/imm32/alloc-id:fake +20793 68/push 0/imm32/no-inouts +20794 68/push 0/imm32/no-inouts +20795 68/push 0/imm32/operation +20796 68/push 0/imm32/operation +20797 68/push 1/imm32 +20798 89/<- %esi 4/r32/esp +20799 $test-increment-register:initialize-stmt-operation: +20800 # stmt->operation = "increment" +20801 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20802 (copy-array Heap "increment" %eax) +20803 # convert +20804 c7 0/subop/copy *Curr-block-depth 0/imm32 +20805 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +20806 (flush _test-output-buffered-file) +20807 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20813 # check output +20814 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") +20815 # . epilogue +20816 89/<- %esp 5/r32/ebp +20817 5d/pop-to-ebp +20818 c3/return +20819 +20820 test-add-reg-to-reg: +20821 # var1/reg <- add var2/reg +20822 # => +20823 # 01/add-to %var1 var2 +20824 # +20825 # . prologue +20826 55/push-ebp +20827 89/<- %ebp 4/r32/esp +20828 # setup +20829 (clear-stream _test-output-stream) +20830 (clear-stream $_test-output-buffered-file->buffer) +20831 $test-add-reg-to-reg:initialize-type: +20832 # var type/ecx: (payload type-tree) = int +20833 68/push 0/imm32/right:null +20834 68/push 0/imm32/right:null +20835 68/push 0/imm32/left:unused +20836 68/push 1/imm32/value:int +20837 68/push 1/imm32/is-atom?:true 20838 68/push 0x11/imm32/alloc-id:fake:payload -20839 89/<- %esi 4/r32/esp -20840 # inouts = [var1, var2] -20841 68/push 0/imm32/is-deref:false -20842 56/push-esi/next -20843 68/push 0x11/imm32/alloc-id:fake -20844 51/push-ecx/var1 -20845 68/push 0x11/imm32/alloc-id:fake -20846 68/push 0x11/imm32/alloc-id:fake:payload -20847 89/<- %esi 4/r32/esp -20848 $test-add-reg-to-mem:initialize-stmt: -20849 # var stmt/esi: (addr statement) -20850 68/push 0/imm32/next -20851 68/push 0/imm32/next -20852 68/push 0/imm32/outputs -20853 68/push 0/imm32/outputs -20854 56/push-esi/inouts -20855 68/push 0x11/imm32/alloc-id:fake -20856 68/push 0/imm32/operation -20857 68/push 0/imm32/operation -20858 68/push 1/imm32/tag:stmt1 -20859 89/<- %esi 4/r32/esp -20860 $test-add-reg-to-mem:initialize-stmt-operation: -20861 # stmt->operation = "add-to" -20862 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20863 (copy-array Heap "add-to" %eax) -20864 # convert -20865 c7 0/subop/copy *Curr-block-depth 0/imm32 -20866 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -20867 (flush _test-output-buffered-file) -20868 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20874 # check output -20875 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") -20876 # . epilogue -20877 89/<- %esp 5/r32/ebp -20878 5d/pop-to-ebp -20879 c3/return -20880 -20881 test-add-mem-to-reg: -20882 # var1/reg <- add var2 -20883 # => -20884 # 03/add *(ebp+__) var1 -20885 # -20886 # . prologue -20887 55/push-ebp -20888 89/<- %ebp 4/r32/esp -20889 # setup -20890 (clear-stream _test-output-stream) -20891 (clear-stream $_test-output-buffered-file->buffer) -20892 $test-add-mem-to-reg:initialize-type: -20893 # var type/ecx: (payload type-tree) = int -20894 68/push 0/imm32/right:null -20895 68/push 0/imm32/right:null -20896 68/push 0/imm32/left:unused -20897 68/push 1/imm32/value:int -20898 68/push 1/imm32/is-atom?:true -20899 68/push 0x11/imm32/alloc-id:fake:payload -20900 89/<- %ecx 4/r32/esp -20901 $test-add-mem-to-reg:initialize-var: -20902 # var var1/ecx: (payload var) -20903 68/push 0/imm32/register -20904 68/push 0/imm32/register -20905 68/push 0/imm32/no-stack-offset -20906 68/push 1/imm32/block-depth -20907 51/push-ecx -20908 68/push 0x11/imm32/alloc-id:fake -20909 68/push 0/imm32/name -20910 68/push 0/imm32/name -20911 68/push 0x11/imm32/alloc-id:fake:payload -20912 89/<- %ecx 4/r32/esp -20913 $test-add-mem-to-reg:initialize-var-name: -20914 # var1->name = "foo" -20915 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -20916 (copy-array Heap "var1" %eax) -20917 $test-add-mem-to-reg:initialize-var-register: -20918 # var1->register = "eax" -20919 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -20920 (copy-array Heap "eax" %eax) -20921 $test-add-mem-to-reg:initialize-var2: -20922 # var var2/edx: (payload var) -20923 68/push 0/imm32/register -20924 68/push 0/imm32/register -20925 68/push 8/imm32/stack-offset -20926 68/push 1/imm32/block-depth -20927 ff 6/subop/push *(ecx+0x10) -20928 68/push 0x11/imm32/alloc-id:fake -20929 68/push 0/imm32/name -20930 68/push 0/imm32/name -20931 68/push 0x11/imm32/alloc-id:fake:payload -20932 89/<- %edx 4/r32/esp -20933 $test-add-mem-to-reg:initialize-var2-name: -20934 # var2->name = "var2" -20935 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -20936 (copy-array Heap "var2" %eax) -20937 $test-add-mem-to-reg:initialize-inouts: -20938 # var inouts/esi: (payload stmt-var) = [var2] -20939 68/push 0/imm32/is-deref:false -20940 68/push 0/imm32/next -20941 68/push 0/imm32/next -20942 52/push-edx/var2 -20943 68/push 0x11/imm32/alloc-id:fake -20944 68/push 0x11/imm32/alloc-id:fake:payload -20945 89/<- %esi 4/r32/esp -20946 $test-add-mem-to-reg:initialize-outputs: -20947 # var outputs/edi: (payload stmt-var) = [var1] -20948 68/push 0/imm32/is-deref:false -20949 68/push 0/imm32/next -20950 68/push 0/imm32/next -20951 51/push-ecx/var1 -20952 68/push 0x11/imm32/alloc-id:fake -20953 68/push 0x11/imm32/alloc-id:fake:payload -20954 89/<- %edi 4/r32/esp -20955 $test-add-mem-to-reg:initialize-stmt: -20956 # var stmt/esi: (addr statement) -20957 68/push 0/imm32/next -20958 68/push 0/imm32/next -20959 57/push-edi/outputs -20960 68/push 0x11/imm32/alloc-id:fake -20961 56/push-esi/inouts -20962 68/push 0x11/imm32/alloc-id:fake -20963 68/push 0/imm32/operation -20964 68/push 0/imm32/operation -20965 68/push 1/imm32/tag:stmt1 -20966 89/<- %esi 4/r32/esp -20967 $test-add-mem-to-reg:initialize-stmt-operation: -20968 # stmt->operation = "add" -20969 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -20970 (copy-array Heap "add" %eax) -20971 # convert -20972 c7 0/subop/copy *Curr-block-depth 0/imm32 -20973 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -20974 (flush _test-output-buffered-file) -20975 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -20981 # check output -20982 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") -20983 # . epilogue -20984 89/<- %esp 5/r32/ebp -20985 5d/pop-to-ebp -20986 c3/return -20987 -20988 test-add-literal-to-eax: -20989 # var1/eax <- add 0x34 -20990 # => -20991 # 05/add-to-eax 0x34/imm32 -20992 # -20993 # . prologue -20994 55/push-ebp -20995 89/<- %ebp 4/r32/esp -20996 # setup -20997 (clear-stream _test-output-stream) -20998 (clear-stream $_test-output-buffered-file->buffer) -20999 $test-add-literal-to-eax:initialize-var-type: -21000 # var type/ecx: (payload type-tree) = int -21001 68/push 0/imm32/right:null -21002 68/push 0/imm32/right:null -21003 68/push 0/imm32/left:unused -21004 68/push 1/imm32/value:int -21005 68/push 1/imm32/is-atom?:true -21006 68/push 0x11/imm32/alloc-id:fake:payload -21007 89/<- %ecx 4/r32/esp -21008 $test-add-literal-to-eax:initialize-var: -21009 # var v/ecx: (payload var) -21010 68/push 0/imm32/register -21011 68/push 0/imm32/register -21012 68/push 0/imm32/no-stack-offset -21013 68/push 1/imm32/block-depth -21014 51/push-ecx -21015 68/push 0x11/imm32/alloc-id:fake -21016 68/push 0/imm32/name -21017 68/push 0/imm32/name -21018 68/push 0x11/imm32/alloc-id:fake:payload -21019 89/<- %ecx 4/r32/esp -21020 $test-add-literal-to-eax:initialize-var-name: -21021 # v->name = "v" -21022 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21023 (copy-array Heap "v" %eax) -21024 $test-add-literal-to-eax:initialize-var-register: -21025 # v->register = "eax" -21026 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -21027 (copy-array Heap "eax" %eax) -21028 $test-add-literal-to-eax:initialize-literal-type: -21029 # var type/edx: (payload type-tree) = literal -21030 68/push 0/imm32/right:null -21031 68/push 0/imm32/right:null -21032 68/push 0/imm32/left:unused -21033 68/push 0/imm32/value:literal -21034 68/push 1/imm32/is-atom?:true -21035 68/push 0x11/imm32/alloc-id:fake:payload -21036 89/<- %edx 4/r32/esp -21037 $test-add-literal-to-eax:initialize-literal: -21038 # var l/edx: (payload var) -21039 68/push 0/imm32/register -21040 68/push 0/imm32/register -21041 68/push 0/imm32/no-stack-offset -21042 68/push 1/imm32/block-depth -21043 52/push-edx -21044 68/push 0x11/imm32/alloc-id:fake -21045 68/push 0/imm32/name -21046 68/push 0/imm32/name -21047 68/push 0x11/imm32/alloc-id:fake:payload -21048 89/<- %edx 4/r32/esp -21049 $test-add-literal-to-eax:initialize-literal-value: -21050 # l->name = "0x34" -21051 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21052 (copy-array Heap "0x34" %eax) -21053 $test-add-literal-to-eax:initialize-inouts: -21054 # var inouts/esi: (payload stmt-var) = [l] -21055 68/push 0/imm32/is-deref:false -21056 68/push 0/imm32/next -21057 68/push 0/imm32/next -21058 52/push-edx/l -21059 68/push 0x11/imm32/alloc-id:fake -21060 68/push 0x11/imm32/alloc-id:fake:payload -21061 89/<- %esi 4/r32/esp -21062 $test-add-literal-to-eax:initialize-outputs: -21063 # var outputs/edi: (payload stmt-var) = [v] -21064 68/push 0/imm32/is-deref:false -21065 68/push 0/imm32/next -21066 68/push 0/imm32/next -21067 51/push-ecx/v -21068 68/push 0x11/imm32/alloc-id:fake -21069 68/push 0x11/imm32/alloc-id:fake:payload -21070 89/<- %edi 4/r32/esp -21071 $test-add-literal-to-eax:initialize-stmt: -21072 # var stmt/esi: (addr statement) -21073 68/push 0/imm32/next -21074 68/push 0/imm32/next -21075 57/push-edi/outputs -21076 68/push 0x11/imm32/alloc-id:fake -21077 56/push-esi/inouts -21078 68/push 0x11/imm32/alloc-id:fake -21079 68/push 0/imm32/operation -21080 68/push 0/imm32/operation -21081 68/push 1/imm32/tag:stmt1 -21082 89/<- %esi 4/r32/esp -21083 $test-add-literal-to-eax:initialize-stmt-operation: -21084 # stmt->operation = "add" -21085 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21086 (copy-array Heap "add" %eax) -21087 # convert -21088 c7 0/subop/copy *Curr-block-depth 0/imm32 -21089 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21090 (flush _test-output-buffered-file) -21091 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21097 # check output -21098 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") -21099 # . epilogue -21100 89/<- %esp 5/r32/ebp -21101 5d/pop-to-ebp -21102 c3/return -21103 -21104 test-add-literal-to-reg: -21105 # var1/ecx <- add 0x34 -21106 # => -21107 # 81 0/subop/add %ecx 0x34/imm32 -21108 # -21109 # . prologue -21110 55/push-ebp -21111 89/<- %ebp 4/r32/esp -21112 # setup -21113 (clear-stream _test-output-stream) -21114 (clear-stream $_test-output-buffered-file->buffer) -21115 $test-add-literal-to-reg:initialize-var-type: -21116 # var type/ecx: (payload type-tree) = int -21117 68/push 0/imm32/right:null -21118 68/push 0/imm32/right:null -21119 68/push 0/imm32/left:unused -21120 68/push 1/imm32/value:int -21121 68/push 1/imm32/is-atom?:true -21122 68/push 0x11/imm32/alloc-id:fake:payload -21123 89/<- %ecx 4/r32/esp -21124 $test-add-literal-to-reg:initialize-var: -21125 # var v/ecx: (payload var) -21126 68/push 0/imm32/register -21127 68/push 0/imm32/register -21128 68/push 0/imm32/no-stack-offset -21129 68/push 1/imm32/block-depth -21130 51/push-ecx -21131 68/push 0x11/imm32/alloc-id:fake -21132 68/push 0/imm32/name -21133 68/push 0/imm32/name -21134 68/push 0x11/imm32/alloc-id:fake:payload -21135 89/<- %ecx 4/r32/esp -21136 $test-add-literal-to-reg:initialize-var-name: -21137 # v->name = "v" -21138 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21139 (copy-array Heap "v" %eax) -21140 $test-add-literal-to-reg:initialize-var-register: -21141 # v->register = "ecx" -21142 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -21143 (copy-array Heap "ecx" %eax) -21144 $test-add-literal-to-reg:initialize-literal-type: -21145 # var type/edx: (payload type-tree) = literal -21146 68/push 0/imm32/right:null -21147 68/push 0/imm32/right:null -21148 68/push 0/imm32/left:unused -21149 68/push 0/imm32/value:literal -21150 68/push 1/imm32/is-atom?:true -21151 68/push 0x11/imm32/alloc-id:fake:payload -21152 89/<- %edx 4/r32/esp -21153 $test-add-literal-to-reg:initialize-literal: -21154 # var l/edx: (payload var) -21155 68/push 0/imm32/register -21156 68/push 0/imm32/register -21157 68/push 0/imm32/no-stack-offset -21158 68/push 1/imm32/block-depth -21159 52/push-edx -21160 68/push 0x11/imm32/alloc-id:fake -21161 68/push 0/imm32/name -21162 68/push 0/imm32/name -21163 68/push 0x11/imm32/alloc-id:fake:payload -21164 89/<- %edx 4/r32/esp -21165 $test-add-literal-to-reg:initialize-literal-value: -21166 # l->name = "0x34" -21167 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21168 (copy-array Heap "0x34" %eax) -21169 $test-add-literal-to-reg:initialize-inouts: -21170 # var inouts/esi: (payload stmt-var) = [l] -21171 68/push 0/imm32/is-deref:false -21172 68/push 0/imm32/next -21173 68/push 0/imm32/next -21174 52/push-edx/l -21175 68/push 0x11/imm32/alloc-id:fake -21176 68/push 0x11/imm32/alloc-id:fake:payload -21177 89/<- %esi 4/r32/esp -21178 $test-add-literal-to-reg:initialize-outputs: -21179 # var outputs/edi: (payload stmt-var) = [v] -21180 68/push 0/imm32/is-deref:false -21181 68/push 0/imm32/next -21182 68/push 0/imm32/next -21183 51/push-ecx/v -21184 68/push 0x11/imm32/alloc-id:fake -21185 68/push 0x11/imm32/alloc-id:fake:payload -21186 89/<- %edi 4/r32/esp -21187 $test-add-literal-to-reg:initialize-stmt: -21188 # var stmt/esi: (addr statement) -21189 68/push 0/imm32/next -21190 68/push 0/imm32/next -21191 57/push-edi/outputs -21192 68/push 0x11/imm32/alloc-id:fake -21193 56/push-esi/inouts -21194 68/push 0x11/imm32/alloc-id:fake -21195 68/push 0/imm32/operation -21196 68/push 0/imm32/operation -21197 68/push 1/imm32/tag:stmt1 -21198 89/<- %esi 4/r32/esp -21199 $test-add-literal-to-reg:initialize-stmt-operation: -21200 # stmt->operation = "add" -21201 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21202 (copy-array Heap "add" %eax) -21203 # convert -21204 c7 0/subop/copy *Curr-block-depth 0/imm32 -21205 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21206 (flush _test-output-buffered-file) -21207 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21213 # check output -21214 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") -21215 # . epilogue -21216 89/<- %esp 5/r32/ebp -21217 5d/pop-to-ebp -21218 c3/return -21219 -21220 test-add-literal-to-mem: -21221 # add-to var1, 0x34 -21222 # => -21223 # 81 0/subop/add %eax 0x34/imm32 -21224 # -21225 # . prologue -21226 55/push-ebp -21227 89/<- %ebp 4/r32/esp -21228 # setup -21229 (clear-stream _test-output-stream) -21230 (clear-stream $_test-output-buffered-file->buffer) -21231 $test-add-literal-to-mem:initialize-type: -21232 # var type/ecx: (payload type-tree) = int -21233 68/push 0/imm32/right:null -21234 68/push 0/imm32/right:null -21235 68/push 0/imm32/left:unused -21236 68/push 1/imm32/value:int -21237 68/push 1/imm32/is-atom?:true -21238 68/push 0x11/imm32/alloc-id:fake:payload -21239 89/<- %ecx 4/r32/esp -21240 $test-add-literal-to-mem:initialize-var1: -21241 # var var1/ecx: (payload var) -21242 68/push 0/imm32/register -21243 68/push 0/imm32/register -21244 68/push 8/imm32/stack-offset -21245 68/push 1/imm32/block-depth -21246 51/push-ecx -21247 68/push 0x11/imm32/alloc-id:fake -21248 68/push 0/imm32/name -21249 68/push 0/imm32/name -21250 68/push 0x11/imm32/alloc-id:fake:payload -21251 89/<- %ecx 4/r32/esp -21252 $test-add-literal-to-mem:initialize-var1-name: -21253 # var1->name = "var1" -21254 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21255 (copy-array Heap "var1" %eax) -21256 $test-add-literal-to-mem:initialize-literal-type: -21257 # var type/edx: (payload type-tree) = literal -21258 68/push 0/imm32/right:null -21259 68/push 0/imm32/right:null -21260 68/push 0/imm32/left:unused -21261 68/push 0/imm32/value:literal -21262 68/push 1/imm32/is-atom?:true -21263 68/push 0x11/imm32/alloc-id:fake:payload -21264 89/<- %edx 4/r32/esp -21265 $test-add-literal-to-mem:initialize-literal: -21266 # var l/edx: (payload var) -21267 68/push 0/imm32/register -21268 68/push 0/imm32/register -21269 68/push 0/imm32/no-stack-offset -21270 68/push 1/imm32/block-depth -21271 52/push-edx -21272 68/push 0x11/imm32/alloc-id:fake -21273 68/push 0/imm32/name -21274 68/push 0/imm32/name -21275 68/push 0x11/imm32/alloc-id:fake:payload -21276 89/<- %edx 4/r32/esp -21277 $test-add-literal-to-mem:initialize-literal-value: -21278 # l->name = "0x34" -21279 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21280 (copy-array Heap "0x34" %eax) -21281 $test-add-literal-to-mem:initialize-inouts: -21282 # var inouts/esi: (payload stmt-var) = [l] -21283 68/push 0/imm32/is-deref:false -21284 68/push 0/imm32/next -21285 68/push 0/imm32/next -21286 52/push-edx/l +20839 89/<- %ecx 4/r32/esp +20840 $test-add-reg-to-reg:initialize-var1: +20841 # var var1/ecx: (payload var) +20842 68/push 0/imm32/register +20843 68/push 0/imm32/register +20844 68/push 0/imm32/no-stack-offset +20845 68/push 1/imm32/block-depth +20846 51/push-ecx +20847 68/push 0x11/imm32/alloc-id:fake +20848 68/push 0/imm32/name +20849 68/push 0/imm32/name +20850 68/push 0x11/imm32/alloc-id:fake:payload +20851 89/<- %ecx 4/r32/esp +20852 $test-add-reg-to-reg:initialize-var1-name: +20853 # var1->name = "var1" +20854 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20855 (copy-array Heap "var1" %eax) +20856 $test-add-reg-to-reg:initialize-var1-register: +20857 # var1->register = "eax" +20858 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +20859 (copy-array Heap "eax" %eax) +20860 $test-add-reg-to-reg:initialize-var2: +20861 # var var2/edx: (payload var) +20862 68/push 0/imm32/register +20863 68/push 0/imm32/register +20864 68/push 0/imm32/no-stack-offset +20865 68/push 1/imm32/block-depth +20866 ff 6/subop/push *(ecx+0x10) +20867 68/push 0x11/imm32/alloc-id:fake +20868 68/push 0/imm32/name +20869 68/push 0/imm32/name +20870 68/push 0x11/imm32/alloc-id:fake:payload +20871 89/<- %edx 4/r32/esp +20872 $test-add-reg-to-reg:initialize-var2-name: +20873 # var2->name = "var2" +20874 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +20875 (copy-array Heap "var2" %eax) +20876 $test-add-reg-to-reg:initialize-var2-register: +20877 # var2->register = "ecx" +20878 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +20879 (copy-array Heap "ecx" %eax) +20880 $test-add-reg-to-reg:initialize-inouts: +20881 # var inouts/esi: (payload stmt-var) = [var2] +20882 68/push 0/imm32/is-deref:false +20883 68/push 0/imm32/next +20884 68/push 0/imm32/next +20885 52/push-edx/var2 +20886 68/push 0x11/imm32/alloc-id:fake +20887 68/push 0x11/imm32/alloc-id:fake:payload +20888 89/<- %esi 4/r32/esp +20889 $test-add-reg-to-reg:initialize-outputs: +20890 # var outputs/edi: (payload stmt-var) = [var1] +20891 68/push 0/imm32/is-deref:false +20892 68/push 0/imm32/next +20893 68/push 0/imm32/next +20894 51/push-ecx/var1 +20895 68/push 0x11/imm32/alloc-id:fake +20896 68/push 0x11/imm32/alloc-id:fake:payload +20897 89/<- %edi 4/r32/esp +20898 $test-add-reg-to-reg:initialize-stmt: +20899 # var stmt/esi: (addr statement) +20900 68/push 0/imm32/next +20901 68/push 0/imm32/next +20902 57/push-edi/outputs +20903 68/push 0x11/imm32/alloc-id:fake +20904 56/push-esi/inouts +20905 68/push 0x11/imm32/alloc-id:fake +20906 68/push 0/imm32/operation +20907 68/push 0/imm32/operation +20908 68/push 1/imm32/tag:stmt1 +20909 89/<- %esi 4/r32/esp +20910 $test-add-reg-to-reg:initialize-stmt-operation: +20911 # stmt->operation = "add" +20912 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +20913 (copy-array Heap "add" %eax) +20914 # convert +20915 c7 0/subop/copy *Curr-block-depth 0/imm32 +20916 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +20917 (flush _test-output-buffered-file) +20918 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +20924 # check output +20925 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") +20926 # . epilogue +20927 89/<- %esp 5/r32/ebp +20928 5d/pop-to-ebp +20929 c3/return +20930 +20931 test-add-reg-to-mem: +20932 # add-to var1 var2/reg +20933 # => +20934 # 01/add-to *(ebp+__) var2 +20935 # +20936 # . prologue +20937 55/push-ebp +20938 89/<- %ebp 4/r32/esp +20939 # setup +20940 (clear-stream _test-output-stream) +20941 (clear-stream $_test-output-buffered-file->buffer) +20942 $test-add-reg-to-mem:initialize-type: +20943 # var type/ecx: (payload type-tree) = int +20944 68/push 0/imm32/right:null +20945 68/push 0/imm32/right:null +20946 68/push 0/imm32/left:unused +20947 68/push 1/imm32/value:int +20948 68/push 1/imm32/is-atom?:true +20949 68/push 0x11/imm32/alloc-id:fake:payload +20950 89/<- %ecx 4/r32/esp +20951 $test-add-reg-to-mem:initialize-var1: +20952 # var var1/ecx: (payload var) +20953 68/push 0/imm32/register +20954 68/push 0/imm32/register +20955 68/push 8/imm32/stack-offset +20956 68/push 1/imm32/block-depth +20957 51/push-ecx +20958 68/push 0x11/imm32/alloc-id:fake +20959 68/push 0/imm32/name +20960 68/push 0/imm32/name +20961 68/push 0x11/imm32/alloc-id:fake:payload +20962 89/<- %ecx 4/r32/esp +20963 $test-add-reg-to-mem:initialize-var1-name: +20964 # var1->name = "var1" +20965 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +20966 (copy-array Heap "var1" %eax) +20967 $test-add-reg-to-mem:initialize-var2: +20968 # var var2/edx: (payload var) +20969 68/push 0/imm32/register +20970 68/push 0/imm32/register +20971 68/push 0/imm32/no-stack-offset +20972 68/push 1/imm32/block-depth +20973 ff 6/subop/push *(ecx+0x10) +20974 68/push 0x11/imm32/alloc-id:fake +20975 68/push 0/imm32/name +20976 68/push 0/imm32/name +20977 68/push 0x11/imm32/alloc-id:fake:payload +20978 89/<- %edx 4/r32/esp +20979 $test-add-reg-to-mem:initialize-var2-name: +20980 # var2->name = "var2" +20981 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +20982 (copy-array Heap "var2" %eax) +20983 $test-add-reg-to-mem:initialize-var2-register: +20984 # var2->register = "ecx" +20985 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +20986 (copy-array Heap "ecx" %eax) +20987 $test-add-reg-to-mem:initialize-inouts: +20988 # var inouts/esi: (payload stmt-var) = [var2] +20989 68/push 0/imm32/is-deref:false +20990 68/push 0/imm32/next +20991 68/push 0/imm32/next +20992 52/push-edx/var2 +20993 68/push 0x11/imm32/alloc-id:fake +20994 68/push 0x11/imm32/alloc-id:fake:payload +20995 89/<- %esi 4/r32/esp +20996 # inouts = [var1, var2] +20997 68/push 0/imm32/is-deref:false +20998 56/push-esi/next +20999 68/push 0x11/imm32/alloc-id:fake +21000 51/push-ecx/var1 +21001 68/push 0x11/imm32/alloc-id:fake +21002 68/push 0x11/imm32/alloc-id:fake:payload +21003 89/<- %esi 4/r32/esp +21004 $test-add-reg-to-mem:initialize-stmt: +21005 # var stmt/esi: (addr statement) +21006 68/push 0/imm32/next +21007 68/push 0/imm32/next +21008 68/push 0/imm32/outputs +21009 68/push 0/imm32/outputs +21010 56/push-esi/inouts +21011 68/push 0x11/imm32/alloc-id:fake +21012 68/push 0/imm32/operation +21013 68/push 0/imm32/operation +21014 68/push 1/imm32/tag:stmt1 +21015 89/<- %esi 4/r32/esp +21016 $test-add-reg-to-mem:initialize-stmt-operation: +21017 # stmt->operation = "add-to" +21018 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21019 (copy-array Heap "add-to" %eax) +21020 # convert +21021 c7 0/subop/copy *Curr-block-depth 0/imm32 +21022 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21023 (flush _test-output-buffered-file) +21024 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21030 # check output +21031 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") +21032 # . epilogue +21033 89/<- %esp 5/r32/ebp +21034 5d/pop-to-ebp +21035 c3/return +21036 +21037 test-add-mem-to-reg: +21038 # var1/reg <- add var2 +21039 # => +21040 # 03/add *(ebp+__) var1 +21041 # +21042 # . prologue +21043 55/push-ebp +21044 89/<- %ebp 4/r32/esp +21045 # setup +21046 (clear-stream _test-output-stream) +21047 (clear-stream $_test-output-buffered-file->buffer) +21048 $test-add-mem-to-reg:initialize-type: +21049 # var type/ecx: (payload type-tree) = int +21050 68/push 0/imm32/right:null +21051 68/push 0/imm32/right:null +21052 68/push 0/imm32/left:unused +21053 68/push 1/imm32/value:int +21054 68/push 1/imm32/is-atom?:true +21055 68/push 0x11/imm32/alloc-id:fake:payload +21056 89/<- %ecx 4/r32/esp +21057 $test-add-mem-to-reg:initialize-var: +21058 # var var1/ecx: (payload var) +21059 68/push 0/imm32/register +21060 68/push 0/imm32/register +21061 68/push 0/imm32/no-stack-offset +21062 68/push 1/imm32/block-depth +21063 51/push-ecx +21064 68/push 0x11/imm32/alloc-id:fake +21065 68/push 0/imm32/name +21066 68/push 0/imm32/name +21067 68/push 0x11/imm32/alloc-id:fake:payload +21068 89/<- %ecx 4/r32/esp +21069 $test-add-mem-to-reg:initialize-var-name: +21070 # var1->name = "foo" +21071 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21072 (copy-array Heap "var1" %eax) +21073 $test-add-mem-to-reg:initialize-var-register: +21074 # var1->register = "eax" +21075 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21076 (copy-array Heap "eax" %eax) +21077 $test-add-mem-to-reg:initialize-var2: +21078 # var var2/edx: (payload var) +21079 68/push 0/imm32/register +21080 68/push 0/imm32/register +21081 68/push 8/imm32/stack-offset +21082 68/push 1/imm32/block-depth +21083 ff 6/subop/push *(ecx+0x10) +21084 68/push 0x11/imm32/alloc-id:fake +21085 68/push 0/imm32/name +21086 68/push 0/imm32/name +21087 68/push 0x11/imm32/alloc-id:fake:payload +21088 89/<- %edx 4/r32/esp +21089 $test-add-mem-to-reg:initialize-var2-name: +21090 # var2->name = "var2" +21091 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21092 (copy-array Heap "var2" %eax) +21093 $test-add-mem-to-reg:initialize-inouts: +21094 # var inouts/esi: (payload stmt-var) = [var2] +21095 68/push 0/imm32/is-deref:false +21096 68/push 0/imm32/next +21097 68/push 0/imm32/next +21098 52/push-edx/var2 +21099 68/push 0x11/imm32/alloc-id:fake +21100 68/push 0x11/imm32/alloc-id:fake:payload +21101 89/<- %esi 4/r32/esp +21102 $test-add-mem-to-reg:initialize-outputs: +21103 # var outputs/edi: (payload stmt-var) = [var1] +21104 68/push 0/imm32/is-deref:false +21105 68/push 0/imm32/next +21106 68/push 0/imm32/next +21107 51/push-ecx/var1 +21108 68/push 0x11/imm32/alloc-id:fake +21109 68/push 0x11/imm32/alloc-id:fake:payload +21110 89/<- %edi 4/r32/esp +21111 $test-add-mem-to-reg:initialize-stmt: +21112 # var stmt/esi: (addr statement) +21113 68/push 0/imm32/next +21114 68/push 0/imm32/next +21115 57/push-edi/outputs +21116 68/push 0x11/imm32/alloc-id:fake +21117 56/push-esi/inouts +21118 68/push 0x11/imm32/alloc-id:fake +21119 68/push 0/imm32/operation +21120 68/push 0/imm32/operation +21121 68/push 1/imm32/tag:stmt1 +21122 89/<- %esi 4/r32/esp +21123 $test-add-mem-to-reg:initialize-stmt-operation: +21124 # stmt->operation = "add" +21125 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21126 (copy-array Heap "add" %eax) +21127 # convert +21128 c7 0/subop/copy *Curr-block-depth 0/imm32 +21129 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21130 (flush _test-output-buffered-file) +21131 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21137 # check output +21138 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") +21139 # . epilogue +21140 89/<- %esp 5/r32/ebp +21141 5d/pop-to-ebp +21142 c3/return +21143 +21144 test-add-literal-to-eax: +21145 # var1/eax <- add 0x34 +21146 # => +21147 # 05/add-to-eax 0x34/imm32 +21148 # +21149 # . prologue +21150 55/push-ebp +21151 89/<- %ebp 4/r32/esp +21152 # setup +21153 (clear-stream _test-output-stream) +21154 (clear-stream $_test-output-buffered-file->buffer) +21155 $test-add-literal-to-eax:initialize-var-type: +21156 # var type/ecx: (payload type-tree) = int +21157 68/push 0/imm32/right:null +21158 68/push 0/imm32/right:null +21159 68/push 0/imm32/left:unused +21160 68/push 1/imm32/value:int +21161 68/push 1/imm32/is-atom?:true +21162 68/push 0x11/imm32/alloc-id:fake:payload +21163 89/<- %ecx 4/r32/esp +21164 $test-add-literal-to-eax:initialize-var: +21165 # var v/ecx: (payload var) +21166 68/push 0/imm32/register +21167 68/push 0/imm32/register +21168 68/push 0/imm32/no-stack-offset +21169 68/push 1/imm32/block-depth +21170 51/push-ecx +21171 68/push 0x11/imm32/alloc-id:fake +21172 68/push 0/imm32/name +21173 68/push 0/imm32/name +21174 68/push 0x11/imm32/alloc-id:fake:payload +21175 89/<- %ecx 4/r32/esp +21176 $test-add-literal-to-eax:initialize-var-name: +21177 # v->name = "v" +21178 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21179 (copy-array Heap "v" %eax) +21180 $test-add-literal-to-eax:initialize-var-register: +21181 # v->register = "eax" +21182 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21183 (copy-array Heap "eax" %eax) +21184 $test-add-literal-to-eax:initialize-literal-type: +21185 # var type/edx: (payload type-tree) = literal +21186 68/push 0/imm32/right:null +21187 68/push 0/imm32/right:null +21188 68/push 0/imm32/left:unused +21189 68/push 0/imm32/value:literal +21190 68/push 1/imm32/is-atom?:true +21191 68/push 0x11/imm32/alloc-id:fake:payload +21192 89/<- %edx 4/r32/esp +21193 $test-add-literal-to-eax:initialize-literal: +21194 # var l/edx: (payload var) +21195 68/push 0/imm32/register +21196 68/push 0/imm32/register +21197 68/push 0/imm32/no-stack-offset +21198 68/push 1/imm32/block-depth +21199 52/push-edx +21200 68/push 0x11/imm32/alloc-id:fake +21201 68/push 0/imm32/name +21202 68/push 0/imm32/name +21203 68/push 0x11/imm32/alloc-id:fake:payload +21204 89/<- %edx 4/r32/esp +21205 $test-add-literal-to-eax:initialize-literal-value: +21206 # l->name = "0x34" +21207 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21208 (copy-array Heap "0x34" %eax) +21209 $test-add-literal-to-eax:initialize-inouts: +21210 # var inouts/esi: (payload stmt-var) = [l] +21211 68/push 0/imm32/is-deref:false +21212 68/push 0/imm32/next +21213 68/push 0/imm32/next +21214 52/push-edx/l +21215 68/push 0x11/imm32/alloc-id:fake +21216 68/push 0x11/imm32/alloc-id:fake:payload +21217 89/<- %esi 4/r32/esp +21218 $test-add-literal-to-eax:initialize-outputs: +21219 # var outputs/edi: (payload stmt-var) = [v] +21220 68/push 0/imm32/is-deref:false +21221 68/push 0/imm32/next +21222 68/push 0/imm32/next +21223 51/push-ecx/v +21224 68/push 0x11/imm32/alloc-id:fake +21225 68/push 0x11/imm32/alloc-id:fake:payload +21226 89/<- %edi 4/r32/esp +21227 $test-add-literal-to-eax:initialize-stmt: +21228 # var stmt/esi: (addr statement) +21229 68/push 0/imm32/next +21230 68/push 0/imm32/next +21231 57/push-edi/outputs +21232 68/push 0x11/imm32/alloc-id:fake +21233 56/push-esi/inouts +21234 68/push 0x11/imm32/alloc-id:fake +21235 68/push 0/imm32/operation +21236 68/push 0/imm32/operation +21237 68/push 1/imm32/tag:stmt1 +21238 89/<- %esi 4/r32/esp +21239 $test-add-literal-to-eax:initialize-stmt-operation: +21240 # stmt->operation = "add" +21241 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21242 (copy-array Heap "add" %eax) +21243 # convert +21244 c7 0/subop/copy *Curr-block-depth 0/imm32 +21245 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21246 (flush _test-output-buffered-file) +21247 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21253 # check output +21254 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") +21255 # . epilogue +21256 89/<- %esp 5/r32/ebp +21257 5d/pop-to-ebp +21258 c3/return +21259 +21260 test-add-literal-to-reg: +21261 # var1/ecx <- add 0x34 +21262 # => +21263 # 81 0/subop/add %ecx 0x34/imm32 +21264 # +21265 # . prologue +21266 55/push-ebp +21267 89/<- %ebp 4/r32/esp +21268 # setup +21269 (clear-stream _test-output-stream) +21270 (clear-stream $_test-output-buffered-file->buffer) +21271 $test-add-literal-to-reg:initialize-var-type: +21272 # var type/ecx: (payload type-tree) = int +21273 68/push 0/imm32/right:null +21274 68/push 0/imm32/right:null +21275 68/push 0/imm32/left:unused +21276 68/push 1/imm32/value:int +21277 68/push 1/imm32/is-atom?:true +21278 68/push 0x11/imm32/alloc-id:fake:payload +21279 89/<- %ecx 4/r32/esp +21280 $test-add-literal-to-reg:initialize-var: +21281 # var v/ecx: (payload var) +21282 68/push 0/imm32/register +21283 68/push 0/imm32/register +21284 68/push 0/imm32/no-stack-offset +21285 68/push 1/imm32/block-depth +21286 51/push-ecx 21287 68/push 0x11/imm32/alloc-id:fake -21288 68/push 0x11/imm32/alloc-id:fake:payload -21289 89/<- %esi 4/r32/esp -21290 # var inouts = (handle stmt-var) = [var1, var2] -21291 68/push 0/imm32/is-deref:false -21292 56/push-esi/next -21293 68/push 0x11/imm32/alloc-id:fake -21294 51/push-ecx/var1 -21295 68/push 0x11/imm32/alloc-id:fake -21296 68/push 0x11/imm32/alloc-id:fake:payload -21297 89/<- %esi 4/r32/esp -21298 $test-add-literal-to-mem:initialize-stmt: -21299 # var stmt/esi: (addr statement) -21300 68/push 0/imm32/next -21301 68/push 0/imm32/next -21302 68/push 0/imm32/outputs -21303 68/push 0/imm32/outputs -21304 56/push-esi/inouts -21305 68/push 0x11/imm32/alloc-id:fake -21306 68/push 0/imm32/operation -21307 68/push 0/imm32/operation -21308 68/push 1/imm32/tag:stmt1 -21309 89/<- %esi 4/r32/esp -21310 $test-add-literal-to-mem:initialize-stmt-operation: -21311 # stmt->operation = "add-to" -21312 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21313 (copy-array Heap "add-to" %eax) -21314 # convert -21315 c7 0/subop/copy *Curr-block-depth 0/imm32 -21316 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21317 (flush _test-output-buffered-file) -21318 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21324 # check output -21325 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") -21326 # . epilogue -21327 89/<- %esp 5/r32/ebp -21328 5d/pop-to-ebp -21329 c3/return -21330 -21331 test-shift-reg-by-literal: -21332 # var1/ecx <- shift-left 2 -21333 # => -21334 # c1/shift 4/subop/left %ecx 2/imm8 -21335 # -21336 # . prologue -21337 55/push-ebp -21338 89/<- %ebp 4/r32/esp -21339 # setup -21340 (clear-stream _test-output-stream) -21341 (clear-stream $_test-output-buffered-file->buffer) -21342 $test-shift-reg-by-literal:initialize-var-type: -21343 # var type/ecx: (payload type-tree) = int -21344 68/push 0/imm32/right:null -21345 68/push 0/imm32/right:null -21346 68/push 0/imm32/left:unused -21347 68/push 1/imm32/value:int -21348 68/push 1/imm32/is-atom?:true -21349 68/push 0x11/imm32/alloc-id:fake:payload -21350 89/<- %ecx 4/r32/esp -21351 $test-shift-reg-by-literal:initialize-var: -21352 # var v/ecx: (payload var) -21353 68/push 0/imm32/register -21354 68/push 0/imm32/register -21355 68/push 0/imm32/no-stack-offset -21356 68/push 1/imm32/block-depth -21357 51/push-ecx -21358 68/push 0x11/imm32/alloc-id:fake -21359 68/push 0/imm32/name -21360 68/push 0/imm32/name -21361 68/push 0x11/imm32/alloc-id:fake:payload -21362 89/<- %ecx 4/r32/esp -21363 $test-shift-reg-by-literal:initialize-var-name: -21364 # v->name = "v" -21365 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21366 (copy-array Heap "v" %eax) -21367 $test-shift-reg-by-literal:initialize-var-register: -21368 # v->register = "ecx" -21369 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -21370 (copy-array Heap "ecx" %eax) -21371 $test-shift-reg-by-literal:initialize-literal-type: -21372 # var type/edx: (payload type-tree) = literal -21373 68/push 0/imm32/right:null -21374 68/push 0/imm32/right:null -21375 68/push 0/imm32/left:unused -21376 68/push 0/imm32/value:literal -21377 68/push 1/imm32/is-atom?:true -21378 68/push 0x11/imm32/alloc-id:fake:payload -21379 89/<- %edx 4/r32/esp -21380 $test-shift-reg-by-literal:initialize-literal: -21381 # var l/edx: (payload var) -21382 68/push 0/imm32/register -21383 68/push 0/imm32/register -21384 68/push 0/imm32/no-stack-offset -21385 68/push 1/imm32/block-depth -21386 52/push-edx -21387 68/push 0x11/imm32/alloc-id:fake -21388 68/push 0/imm32/name -21389 68/push 0/imm32/name -21390 68/push 0x11/imm32/alloc-id:fake:payload -21391 89/<- %edx 4/r32/esp -21392 $test-shift-reg-by-literal:initialize-literal-value: -21393 # l->name = "2" -21394 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21395 (copy-array Heap "2" %eax) -21396 $test-shift-reg-by-literal:initialize-inouts: -21397 # var inouts/esi: (payload stmt-var) = [l] -21398 68/push 0/imm32/is-deref:false -21399 68/push 0/imm32/next -21400 68/push 0/imm32/next -21401 52/push-edx/l -21402 68/push 0x11/imm32/alloc-id:fake -21403 68/push 0x11/imm32/alloc-id:fake:payload -21404 89/<- %esi 4/r32/esp -21405 $test-shift-reg-by-literal:initialize-outputs: -21406 # var outputs/edi: (payload stmt-var) = [v] -21407 68/push 0/imm32/is-deref:false -21408 68/push 0/imm32/next -21409 68/push 0/imm32/next -21410 51/push-ecx/v -21411 68/push 0x11/imm32/alloc-id:fake -21412 68/push 0x11/imm32/alloc-id:fake:payload -21413 89/<- %edi 4/r32/esp -21414 $test-shift-reg-by-literal:initialize-stmt: -21415 # var stmt/esi: (addr statement) -21416 68/push 0/imm32/next -21417 68/push 0/imm32/next -21418 57/push-edi/outputs -21419 68/push 0x11/imm32/alloc-id:fake -21420 56/push-esi/inouts -21421 68/push 0x11/imm32/alloc-id:fake -21422 68/push 0/imm32/operation -21423 68/push 0/imm32/operation -21424 68/push 1/imm32/tag:stmt1 -21425 89/<- %esi 4/r32/esp -21426 $test-shift-reg-by-literal:initialize-stmt-operation: -21427 # stmt->operation = "shift-left" -21428 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21429 (copy-array Heap "shift-left" %eax) -21430 # convert -21431 c7 0/subop/copy *Curr-block-depth 0/imm32 -21432 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21433 (flush _test-output-buffered-file) -21434 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21440 # check output -21441 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal") -21442 # . epilogue -21443 89/<- %esp 5/r32/ebp -21444 5d/pop-to-ebp -21445 c3/return -21446 -21447 test-shift-mem-by-literal: -21448 # shift-left var 3 -21449 # => -21450 # c1/shift 4/subop/left *(ebp+8) 3/imm8 -21451 # -21452 # . prologue -21453 55/push-ebp -21454 89/<- %ebp 4/r32/esp -21455 # setup -21456 (clear-stream _test-output-stream) -21457 (clear-stream $_test-output-buffered-file->buffer) -21458 $test-shift-mem-by-literal:initialize-type: -21459 # var type/ecx: (payload type-tree) = int -21460 68/push 0/imm32/right:null -21461 68/push 0/imm32/right:null -21462 68/push 0/imm32/left:unused -21463 68/push 1/imm32/value:int -21464 68/push 1/imm32/is-atom?:true -21465 68/push 0x11/imm32/alloc-id:fake:payload -21466 89/<- %ecx 4/r32/esp -21467 $test-shift-mem-by-literal:initialize-var1: -21468 # var var1/ecx: (payload var) -21469 68/push 0/imm32/register -21470 68/push 0/imm32/register -21471 68/push 8/imm32/stack-offset -21472 68/push 1/imm32/block-depth -21473 51/push-ecx -21474 68/push 0x11/imm32/alloc-id:fake -21475 68/push 0/imm32/name -21476 68/push 0/imm32/name -21477 68/push 0x11/imm32/alloc-id:fake:payload -21478 89/<- %ecx 4/r32/esp -21479 $test-shift-mem-by-literal:initialize-var1-name: -21480 # var1->name = "var1" -21481 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21482 (copy-array Heap "var1" %eax) -21483 $test-shift-mem-by-literal:initialize-literal-type: -21484 # var type/edx: (payload type-tree) = literal -21485 68/push 0/imm32/right:null -21486 68/push 0/imm32/right:null -21487 68/push 0/imm32/left:unused -21488 68/push 0/imm32/value:literal -21489 68/push 1/imm32/is-atom?:true -21490 68/push 0x11/imm32/alloc-id:fake:payload -21491 89/<- %edx 4/r32/esp -21492 $test-shift-mem-by-literal:initialize-literal: -21493 # var l/edx: (payload var) -21494 68/push 0/imm32/register -21495 68/push 0/imm32/register -21496 68/push 0/imm32/no-stack-offset -21497 68/push 1/imm32/block-depth -21498 52/push-edx -21499 68/push 0x11/imm32/alloc-id:fake -21500 68/push 0/imm32/name -21501 68/push 0/imm32/name -21502 68/push 0x11/imm32/alloc-id:fake:payload -21503 89/<- %edx 4/r32/esp -21504 $test-shift-mem-by-literal:initialize-literal-value: -21505 # l->name = "3" -21506 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21507 (copy-array Heap "3" %eax) -21508 $test-shift-mem-by-literal:initialize-inouts: -21509 # var inouts/esi: (payload stmt-var) = [l] -21510 68/push 0/imm32/is-deref:false -21511 68/push 0/imm32/next -21512 68/push 0/imm32/next -21513 52/push-edx/l +21288 68/push 0/imm32/name +21289 68/push 0/imm32/name +21290 68/push 0x11/imm32/alloc-id:fake:payload +21291 89/<- %ecx 4/r32/esp +21292 $test-add-literal-to-reg:initialize-var-name: +21293 # v->name = "v" +21294 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21295 (copy-array Heap "v" %eax) +21296 $test-add-literal-to-reg:initialize-var-register: +21297 # v->register = "ecx" +21298 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21299 (copy-array Heap "ecx" %eax) +21300 $test-add-literal-to-reg:initialize-literal-type: +21301 # var type/edx: (payload type-tree) = literal +21302 68/push 0/imm32/right:null +21303 68/push 0/imm32/right:null +21304 68/push 0/imm32/left:unused +21305 68/push 0/imm32/value:literal +21306 68/push 1/imm32/is-atom?:true +21307 68/push 0x11/imm32/alloc-id:fake:payload +21308 89/<- %edx 4/r32/esp +21309 $test-add-literal-to-reg:initialize-literal: +21310 # var l/edx: (payload var) +21311 68/push 0/imm32/register +21312 68/push 0/imm32/register +21313 68/push 0/imm32/no-stack-offset +21314 68/push 1/imm32/block-depth +21315 52/push-edx +21316 68/push 0x11/imm32/alloc-id:fake +21317 68/push 0/imm32/name +21318 68/push 0/imm32/name +21319 68/push 0x11/imm32/alloc-id:fake:payload +21320 89/<- %edx 4/r32/esp +21321 $test-add-literal-to-reg:initialize-literal-value: +21322 # l->name = "0x34" +21323 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21324 (copy-array Heap "0x34" %eax) +21325 $test-add-literal-to-reg:initialize-inouts: +21326 # var inouts/esi: (payload stmt-var) = [l] +21327 68/push 0/imm32/is-deref:false +21328 68/push 0/imm32/next +21329 68/push 0/imm32/next +21330 52/push-edx/l +21331 68/push 0x11/imm32/alloc-id:fake +21332 68/push 0x11/imm32/alloc-id:fake:payload +21333 89/<- %esi 4/r32/esp +21334 $test-add-literal-to-reg:initialize-outputs: +21335 # var outputs/edi: (payload stmt-var) = [v] +21336 68/push 0/imm32/is-deref:false +21337 68/push 0/imm32/next +21338 68/push 0/imm32/next +21339 51/push-ecx/v +21340 68/push 0x11/imm32/alloc-id:fake +21341 68/push 0x11/imm32/alloc-id:fake:payload +21342 89/<- %edi 4/r32/esp +21343 $test-add-literal-to-reg:initialize-stmt: +21344 # var stmt/esi: (addr statement) +21345 68/push 0/imm32/next +21346 68/push 0/imm32/next +21347 57/push-edi/outputs +21348 68/push 0x11/imm32/alloc-id:fake +21349 56/push-esi/inouts +21350 68/push 0x11/imm32/alloc-id:fake +21351 68/push 0/imm32/operation +21352 68/push 0/imm32/operation +21353 68/push 1/imm32/tag:stmt1 +21354 89/<- %esi 4/r32/esp +21355 $test-add-literal-to-reg:initialize-stmt-operation: +21356 # stmt->operation = "add" +21357 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21358 (copy-array Heap "add" %eax) +21359 # convert +21360 c7 0/subop/copy *Curr-block-depth 0/imm32 +21361 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21362 (flush _test-output-buffered-file) +21363 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21369 # check output +21370 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") +21371 # . epilogue +21372 89/<- %esp 5/r32/ebp +21373 5d/pop-to-ebp +21374 c3/return +21375 +21376 test-add-literal-to-mem: +21377 # add-to var1, 0x34 +21378 # => +21379 # 81 0/subop/add %eax 0x34/imm32 +21380 # +21381 # . prologue +21382 55/push-ebp +21383 89/<- %ebp 4/r32/esp +21384 # setup +21385 (clear-stream _test-output-stream) +21386 (clear-stream $_test-output-buffered-file->buffer) +21387 $test-add-literal-to-mem:initialize-type: +21388 # var type/ecx: (payload type-tree) = int +21389 68/push 0/imm32/right:null +21390 68/push 0/imm32/right:null +21391 68/push 0/imm32/left:unused +21392 68/push 1/imm32/value:int +21393 68/push 1/imm32/is-atom?:true +21394 68/push 0x11/imm32/alloc-id:fake:payload +21395 89/<- %ecx 4/r32/esp +21396 $test-add-literal-to-mem:initialize-var1: +21397 # var var1/ecx: (payload var) +21398 68/push 0/imm32/register +21399 68/push 0/imm32/register +21400 68/push 8/imm32/stack-offset +21401 68/push 1/imm32/block-depth +21402 51/push-ecx +21403 68/push 0x11/imm32/alloc-id:fake +21404 68/push 0/imm32/name +21405 68/push 0/imm32/name +21406 68/push 0x11/imm32/alloc-id:fake:payload +21407 89/<- %ecx 4/r32/esp +21408 $test-add-literal-to-mem:initialize-var1-name: +21409 # var1->name = "var1" +21410 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21411 (copy-array Heap "var1" %eax) +21412 $test-add-literal-to-mem:initialize-literal-type: +21413 # var type/edx: (payload type-tree) = literal +21414 68/push 0/imm32/right:null +21415 68/push 0/imm32/right:null +21416 68/push 0/imm32/left:unused +21417 68/push 0/imm32/value:literal +21418 68/push 1/imm32/is-atom?:true +21419 68/push 0x11/imm32/alloc-id:fake:payload +21420 89/<- %edx 4/r32/esp +21421 $test-add-literal-to-mem:initialize-literal: +21422 # var l/edx: (payload var) +21423 68/push 0/imm32/register +21424 68/push 0/imm32/register +21425 68/push 0/imm32/no-stack-offset +21426 68/push 1/imm32/block-depth +21427 52/push-edx +21428 68/push 0x11/imm32/alloc-id:fake +21429 68/push 0/imm32/name +21430 68/push 0/imm32/name +21431 68/push 0x11/imm32/alloc-id:fake:payload +21432 89/<- %edx 4/r32/esp +21433 $test-add-literal-to-mem:initialize-literal-value: +21434 # l->name = "0x34" +21435 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21436 (copy-array Heap "0x34" %eax) +21437 $test-add-literal-to-mem:initialize-inouts: +21438 # var inouts/esi: (payload stmt-var) = [l] +21439 68/push 0/imm32/is-deref:false +21440 68/push 0/imm32/next +21441 68/push 0/imm32/next +21442 52/push-edx/l +21443 68/push 0x11/imm32/alloc-id:fake +21444 68/push 0x11/imm32/alloc-id:fake:payload +21445 89/<- %esi 4/r32/esp +21446 # var inouts = (handle stmt-var) = [var1, var2] +21447 68/push 0/imm32/is-deref:false +21448 56/push-esi/next +21449 68/push 0x11/imm32/alloc-id:fake +21450 51/push-ecx/var1 +21451 68/push 0x11/imm32/alloc-id:fake +21452 68/push 0x11/imm32/alloc-id:fake:payload +21453 89/<- %esi 4/r32/esp +21454 $test-add-literal-to-mem:initialize-stmt: +21455 # var stmt/esi: (addr statement) +21456 68/push 0/imm32/next +21457 68/push 0/imm32/next +21458 68/push 0/imm32/outputs +21459 68/push 0/imm32/outputs +21460 56/push-esi/inouts +21461 68/push 0x11/imm32/alloc-id:fake +21462 68/push 0/imm32/operation +21463 68/push 0/imm32/operation +21464 68/push 1/imm32/tag:stmt1 +21465 89/<- %esi 4/r32/esp +21466 $test-add-literal-to-mem:initialize-stmt-operation: +21467 # stmt->operation = "add-to" +21468 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21469 (copy-array Heap "add-to" %eax) +21470 # convert +21471 c7 0/subop/copy *Curr-block-depth 0/imm32 +21472 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21473 (flush _test-output-buffered-file) +21474 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21480 # check output +21481 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") +21482 # . epilogue +21483 89/<- %esp 5/r32/ebp +21484 5d/pop-to-ebp +21485 c3/return +21486 +21487 test-shift-reg-by-literal: +21488 # var1/ecx <- shift-left 2 +21489 # => +21490 # c1/shift 4/subop/left %ecx 2/imm8 +21491 # +21492 # . prologue +21493 55/push-ebp +21494 89/<- %ebp 4/r32/esp +21495 # setup +21496 (clear-stream _test-output-stream) +21497 (clear-stream $_test-output-buffered-file->buffer) +21498 $test-shift-reg-by-literal:initialize-var-type: +21499 # var type/ecx: (payload type-tree) = int +21500 68/push 0/imm32/right:null +21501 68/push 0/imm32/right:null +21502 68/push 0/imm32/left:unused +21503 68/push 1/imm32/value:int +21504 68/push 1/imm32/is-atom?:true +21505 68/push 0x11/imm32/alloc-id:fake:payload +21506 89/<- %ecx 4/r32/esp +21507 $test-shift-reg-by-literal:initialize-var: +21508 # var v/ecx: (payload var) +21509 68/push 0/imm32/register +21510 68/push 0/imm32/register +21511 68/push 0/imm32/no-stack-offset +21512 68/push 1/imm32/block-depth +21513 51/push-ecx 21514 68/push 0x11/imm32/alloc-id:fake -21515 68/push 0x11/imm32/alloc-id:fake:payload -21516 89/<- %esi 4/r32/esp -21517 # var inouts = (handle stmt-var) = [var1, var2] -21518 68/push 0/imm32/is-deref:false -21519 56/push-esi/next -21520 68/push 0x11/imm32/alloc-id:fake -21521 51/push-ecx/var1 -21522 68/push 0x11/imm32/alloc-id:fake -21523 68/push 0x11/imm32/alloc-id:fake:payload -21524 89/<- %esi 4/r32/esp -21525 $test-shift-mem-by-literal:initialize-stmt: -21526 # var stmt/esi: (addr statement) -21527 68/push 0/imm32/next -21528 68/push 0/imm32/next -21529 68/push 0/imm32/outputs -21530 68/push 0/imm32/outputs -21531 56/push-esi/inouts -21532 68/push 0x11/imm32/alloc-id:fake -21533 68/push 0/imm32/operation -21534 68/push 0/imm32/operation -21535 68/push 1/imm32/tag:stmt1 -21536 89/<- %esi 4/r32/esp -21537 $test-shift-mem-by-literal:initialize-stmt-operation: -21538 # stmt->operation = "shift-left" -21539 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21540 (copy-array Heap "shift-left" %eax) -21541 # convert -21542 c7 0/subop/copy *Curr-block-depth 0/imm32 -21543 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21544 (flush _test-output-buffered-file) -21545 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21551 # check output -21552 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal") -21553 # . epilogue -21554 89/<- %esp 5/r32/ebp -21555 5d/pop-to-ebp -21556 c3/return -21557 -21558 test-compare-reg-with-reg: -21559 # compare var1/ecx, var2/eax -21560 # => -21561 # 39/compare %ecx 0/r32/eax -21562 # -21563 # . prologue -21564 55/push-ebp -21565 89/<- %ebp 4/r32/esp -21566 # setup -21567 (clear-stream _test-output-stream) -21568 (clear-stream $_test-output-buffered-file->buffer) -21569 $test-compare-reg-with-reg:initialize-type: -21570 # var type/ecx: (payload type-tree) = int -21571 68/push 0/imm32/right:null -21572 68/push 0/imm32/right:null -21573 68/push 0/imm32/left:unused -21574 68/push 1/imm32/value:int -21575 68/push 1/imm32/is-atom?:true -21576 68/push 0x11/imm32/alloc-id:fake:payload -21577 89/<- %ecx 4/r32/esp -21578 $test-compare-reg-with-reg:initialize-var1: -21579 # var var1/ecx: (payload var) -21580 68/push 0/imm32/register -21581 68/push 0/imm32/register -21582 68/push 0/imm32/no-stack-offset -21583 68/push 1/imm32/block-depth -21584 51/push-ecx -21585 68/push 0x11/imm32/alloc-id:fake -21586 68/push 0/imm32/name -21587 68/push 0/imm32/name -21588 68/push 0x11/imm32/alloc-id:fake:payload -21589 89/<- %ecx 4/r32/esp -21590 $test-compare-reg-with-reg:initialize-var1-name: -21591 # var1->name = "var1" -21592 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21593 (copy-array Heap "var1" %eax) -21594 $test-compare-reg-with-reg:initialize-var1-register: -21595 # var1->register = "ecx" -21596 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -21597 (copy-array Heap "ecx" %eax) -21598 $test-compare-reg-with-reg:initialize-var2: -21599 # var var2/edx: (payload var) -21600 68/push 0/imm32/register -21601 68/push 0/imm32/register -21602 68/push 0/imm32/no-stack-offset -21603 68/push 1/imm32/block-depth -21604 ff 6/subop/push *(ecx+0x10) -21605 68/push 0x11/imm32/alloc-id:fake -21606 68/push 0/imm32/name -21607 68/push 0/imm32/name -21608 68/push 0x11/imm32/alloc-id:fake:payload -21609 89/<- %edx 4/r32/esp -21610 $test-compare-reg-with-reg:initialize-var2-name: -21611 # var2->name = "var2" -21612 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21613 (copy-array Heap "var2" %eax) -21614 $test-compare-reg-with-reg:initialize-var2-register: -21615 # var2->register = "eax" -21616 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -21617 (copy-array Heap "eax" %eax) -21618 $test-compare-reg-with-reg:initialize-inouts: -21619 # var inouts/esi: (payload stmt-var) = [var2] -21620 68/push 0/imm32/is-deref:false -21621 68/push 0/imm32/next -21622 68/push 0/imm32/next -21623 52/push-edx/var2 -21624 68/push 0x11/imm32/alloc-id:fake -21625 68/push 0x11/imm32/alloc-id:fake:payload -21626 89/<- %esi 4/r32/esp -21627 # inouts = [var1, var2] -21628 68/push 0/imm32/is-deref:false -21629 56/push-esi/next +21515 68/push 0/imm32/name +21516 68/push 0/imm32/name +21517 68/push 0x11/imm32/alloc-id:fake:payload +21518 89/<- %ecx 4/r32/esp +21519 $test-shift-reg-by-literal:initialize-var-name: +21520 # v->name = "v" +21521 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21522 (copy-array Heap "v" %eax) +21523 $test-shift-reg-by-literal:initialize-var-register: +21524 # v->register = "ecx" +21525 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21526 (copy-array Heap "ecx" %eax) +21527 $test-shift-reg-by-literal:initialize-literal-type: +21528 # var type/edx: (payload type-tree) = literal +21529 68/push 0/imm32/right:null +21530 68/push 0/imm32/right:null +21531 68/push 0/imm32/left:unused +21532 68/push 0/imm32/value:literal +21533 68/push 1/imm32/is-atom?:true +21534 68/push 0x11/imm32/alloc-id:fake:payload +21535 89/<- %edx 4/r32/esp +21536 $test-shift-reg-by-literal:initialize-literal: +21537 # var l/edx: (payload var) +21538 68/push 0/imm32/register +21539 68/push 0/imm32/register +21540 68/push 0/imm32/no-stack-offset +21541 68/push 1/imm32/block-depth +21542 52/push-edx +21543 68/push 0x11/imm32/alloc-id:fake +21544 68/push 0/imm32/name +21545 68/push 0/imm32/name +21546 68/push 0x11/imm32/alloc-id:fake:payload +21547 89/<- %edx 4/r32/esp +21548 $test-shift-reg-by-literal:initialize-literal-value: +21549 # l->name = "2" +21550 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21551 (copy-array Heap "2" %eax) +21552 $test-shift-reg-by-literal:initialize-inouts: +21553 # var inouts/esi: (payload stmt-var) = [l] +21554 68/push 0/imm32/is-deref:false +21555 68/push 0/imm32/next +21556 68/push 0/imm32/next +21557 52/push-edx/l +21558 68/push 0x11/imm32/alloc-id:fake +21559 68/push 0x11/imm32/alloc-id:fake:payload +21560 89/<- %esi 4/r32/esp +21561 $test-shift-reg-by-literal:initialize-outputs: +21562 # var outputs/edi: (payload stmt-var) = [v] +21563 68/push 0/imm32/is-deref:false +21564 68/push 0/imm32/next +21565 68/push 0/imm32/next +21566 51/push-ecx/v +21567 68/push 0x11/imm32/alloc-id:fake +21568 68/push 0x11/imm32/alloc-id:fake:payload +21569 89/<- %edi 4/r32/esp +21570 $test-shift-reg-by-literal:initialize-stmt: +21571 # var stmt/esi: (addr statement) +21572 68/push 0/imm32/next +21573 68/push 0/imm32/next +21574 57/push-edi/outputs +21575 68/push 0x11/imm32/alloc-id:fake +21576 56/push-esi/inouts +21577 68/push 0x11/imm32/alloc-id:fake +21578 68/push 0/imm32/operation +21579 68/push 0/imm32/operation +21580 68/push 1/imm32/tag:stmt1 +21581 89/<- %esi 4/r32/esp +21582 $test-shift-reg-by-literal:initialize-stmt-operation: +21583 # stmt->operation = "shift-left" +21584 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21585 (copy-array Heap "shift-left" %eax) +21586 # convert +21587 c7 0/subop/copy *Curr-block-depth 0/imm32 +21588 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21589 (flush _test-output-buffered-file) +21590 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21596 # check output +21597 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal") +21598 # . epilogue +21599 89/<- %esp 5/r32/ebp +21600 5d/pop-to-ebp +21601 c3/return +21602 +21603 test-shift-mem-by-literal: +21604 # shift-left var 3 +21605 # => +21606 # c1/shift 4/subop/left *(ebp+8) 3/imm8 +21607 # +21608 # . prologue +21609 55/push-ebp +21610 89/<- %ebp 4/r32/esp +21611 # setup +21612 (clear-stream _test-output-stream) +21613 (clear-stream $_test-output-buffered-file->buffer) +21614 $test-shift-mem-by-literal:initialize-type: +21615 # var type/ecx: (payload type-tree) = int +21616 68/push 0/imm32/right:null +21617 68/push 0/imm32/right:null +21618 68/push 0/imm32/left:unused +21619 68/push 1/imm32/value:int +21620 68/push 1/imm32/is-atom?:true +21621 68/push 0x11/imm32/alloc-id:fake:payload +21622 89/<- %ecx 4/r32/esp +21623 $test-shift-mem-by-literal:initialize-var1: +21624 # var var1/ecx: (payload var) +21625 68/push 0/imm32/register +21626 68/push 0/imm32/register +21627 68/push 8/imm32/stack-offset +21628 68/push 1/imm32/block-depth +21629 51/push-ecx 21630 68/push 0x11/imm32/alloc-id:fake -21631 51/push-ecx/var1 -21632 68/push 0x11/imm32/alloc-id:fake +21631 68/push 0/imm32/name +21632 68/push 0/imm32/name 21633 68/push 0x11/imm32/alloc-id:fake:payload -21634 89/<- %esi 4/r32/esp -21635 $test-compare-reg-with-reg:initialize-stmt: -21636 # var stmt/esi: (addr statement) -21637 68/push 0/imm32/next -21638 68/push 0/imm32/next -21639 68/push 0/imm32/outputs -21640 68/push 0/imm32/outputs -21641 56/push-esi/inouts -21642 68/push 0x11/imm32/alloc-id:fake -21643 68/push 0/imm32/operation -21644 68/push 0/imm32/operation -21645 68/push 1/imm32/tag:stmt1 -21646 89/<- %esi 4/r32/esp -21647 $test-compare-reg-with-reg:initialize-stmt-operation: -21648 # stmt->operation = "compare" -21649 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21650 (copy-array Heap "compare" %eax) -21651 # convert -21652 c7 0/subop/copy *Curr-block-depth 0/imm32 -21653 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21654 (flush _test-output-buffered-file) -21655 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21661 # check output -21662 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg") -21663 # . epilogue -21664 89/<- %esp 5/r32/ebp -21665 5d/pop-to-ebp -21666 c3/return -21667 -21668 test-compare-mem-with-reg: -21669 # compare var1, var2/eax -21670 # => -21671 # 39/compare *(ebp+___) 0/r32/eax -21672 # -21673 # . prologue -21674 55/push-ebp -21675 89/<- %ebp 4/r32/esp -21676 # setup -21677 (clear-stream _test-output-stream) -21678 (clear-stream $_test-output-buffered-file->buffer) -21679 $test-compare-mem-with-reg:initialize-type: -21680 # var type/ecx: (payload type-tree) = int -21681 68/push 0/imm32/right:null -21682 68/push 0/imm32/right:null -21683 68/push 0/imm32/left:unused -21684 68/push 1/imm32/value:int -21685 68/push 1/imm32/is-atom?:true -21686 68/push 0x11/imm32/alloc-id:fake:payload -21687 89/<- %ecx 4/r32/esp -21688 $test-compare-mem-with-reg:initialize-var1: -21689 # var var1/ecx: (payload var) -21690 68/push 0/imm32/register -21691 68/push 0/imm32/register -21692 68/push 8/imm32/stack-offset -21693 68/push 1/imm32/block-depth -21694 51/push-ecx -21695 68/push 0x11/imm32/alloc-id:fake -21696 68/push 0/imm32/name -21697 68/push 0/imm32/name -21698 68/push 0x11/imm32/alloc-id:fake:payload -21699 89/<- %ecx 4/r32/esp -21700 $test-compare-mem-with-reg:initialize-var1-name: -21701 # var1->name = "var1" -21702 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21703 (copy-array Heap "var1" %eax) -21704 $test-compare-mem-with-reg:initialize-var2: -21705 # var var2/edx: (payload var) -21706 68/push 0/imm32/register -21707 68/push 0/imm32/register -21708 68/push 0/imm32/no-stack-offset -21709 68/push 1/imm32/block-depth -21710 ff 6/subop/push *(ecx+0x10) -21711 68/push 0x11/imm32/alloc-id:fake -21712 68/push 0/imm32/name -21713 68/push 0/imm32/name -21714 68/push 0x11/imm32/alloc-id:fake:payload -21715 89/<- %edx 4/r32/esp -21716 $test-compare-mem-with-reg:initialize-var2-name: -21717 # var2->name = "var2" -21718 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21719 (copy-array Heap "var2" %eax) -21720 $test-compare-mem-with-reg:initialize-var2-register: -21721 # var2->register = "eax" -21722 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -21723 (copy-array Heap "eax" %eax) -21724 $test-compare-mem-with-reg:initialize-inouts: -21725 # var inouts/esi: (payload stmt-var) = [var2] -21726 68/push 0/imm32/is-deref:false -21727 68/push 0/imm32/next -21728 68/push 0/imm32/next -21729 52/push-edx/var2 -21730 68/push 0x11/imm32/alloc-id:fake -21731 68/push 0x11/imm32/alloc-id:fake:payload -21732 89/<- %esi 4/r32/esp -21733 # inouts = [var1, var2] -21734 68/push 0/imm32/is-deref:false -21735 56/push-esi/next -21736 68/push 0x11/imm32/alloc-id:fake -21737 51/push-ecx/var1 -21738 68/push 0x11/imm32/alloc-id:fake -21739 68/push 0x11/imm32/alloc-id:fake:payload -21740 89/<- %esi 4/r32/esp -21741 $test-compare-mem-with-reg:initialize-stmt: -21742 # var stmt/esi: (addr statement) -21743 68/push 0/imm32/next -21744 68/push 0/imm32/next -21745 68/push 0/imm32/outputs -21746 68/push 0/imm32/outputs -21747 56/push-esi/inouts -21748 68/push 0x11/imm32/alloc-id:fake -21749 68/push 0/imm32/operation -21750 68/push 0/imm32/operation -21751 68/push 1/imm32/tag:stmt1 -21752 89/<- %esi 4/r32/esp -21753 $test-compare-mem-with-reg:initialize-stmt-operation: -21754 # stmt->operation = "compare" -21755 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21756 (copy-array Heap "compare" %eax) -21757 # convert -21758 c7 0/subop/copy *Curr-block-depth 0/imm32 -21759 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21760 (flush _test-output-buffered-file) -21761 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21767 # check output -21768 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") -21769 # . epilogue -21770 89/<- %esp 5/r32/ebp -21771 5d/pop-to-ebp -21772 c3/return -21773 -21774 test-compare-reg-with-mem: -21775 # compare var1/eax, var2 -21776 # => -21777 # 3b/compare<- *(ebp+___) 0/r32/eax -21778 # -21779 # . prologue -21780 55/push-ebp -21781 89/<- %ebp 4/r32/esp -21782 # setup -21783 (clear-stream _test-output-stream) -21784 (clear-stream $_test-output-buffered-file->buffer) -21785 $test-compare-reg-with-mem:initialize-type: -21786 # var type/ecx: (payload type-tree) = int -21787 68/push 0/imm32/right:null -21788 68/push 0/imm32/right:null -21789 68/push 0/imm32/left:unused -21790 68/push 1/imm32/value:int -21791 68/push 1/imm32/is-atom?:true -21792 68/push 0x11/imm32/alloc-id:fake:payload -21793 89/<- %ecx 4/r32/esp -21794 $test-compare-reg-with-mem:initialize-var1: -21795 # var var1/ecx: (payload var) -21796 68/push 0/imm32/register -21797 68/push 0/imm32/register -21798 68/push 0/imm32/no-stack-offset -21799 68/push 1/imm32/block-depth -21800 51/push-ecx -21801 68/push 0x11/imm32/alloc-id:fake -21802 68/push 0/imm32/name -21803 68/push 0/imm32/name -21804 68/push 0x11/imm32/alloc-id:fake:payload -21805 89/<- %ecx 4/r32/esp -21806 $test-compare-reg-with-mem:initialize-var1-name: -21807 # var1->name = "var1" -21808 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21809 (copy-array Heap "var1" %eax) -21810 $test-compare-reg-with-mem:initialize-var1-register: -21811 # var1->register = "eax" -21812 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -21813 (copy-array Heap "eax" %eax) -21814 $test-compare-reg-with-mem:initialize-var2: -21815 # var var2/edx: (payload var) -21816 68/push 0/imm32/register -21817 68/push 0/imm32/register -21818 68/push 8/imm32/stack-offset -21819 68/push 1/imm32/block-depth -21820 ff 6/subop/push *(ecx+0x10) -21821 68/push 0x11/imm32/alloc-id:fake -21822 68/push 0/imm32/name -21823 68/push 0/imm32/name -21824 68/push 0x11/imm32/alloc-id:fake:payload -21825 89/<- %edx 4/r32/esp -21826 $test-compare-reg-with-mem:initialize-var2-name: -21827 # var2->name = "var2" -21828 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21829 (copy-array Heap "var2" %eax) -21830 $test-compare-reg-with-mem:initialize-inouts: -21831 # var inouts/esi: (payload stmt-var) = [var2] -21832 68/push 0/imm32/is-deref:false -21833 68/push 0/imm32/next -21834 68/push 0/imm32/next -21835 52/push-edx/var2 -21836 68/push 0x11/imm32/alloc-id:fake -21837 68/push 0x11/imm32/alloc-id:fake:payload -21838 89/<- %esi 4/r32/esp -21839 # inouts = [var1, var2] -21840 68/push 0/imm32/is-deref:false -21841 56/push-esi/next -21842 68/push 0x11/imm32/alloc-id:fake -21843 51/push-ecx/var1 -21844 68/push 0x11/imm32/alloc-id:fake -21845 68/push 0x11/imm32/alloc-id:fake:payload -21846 89/<- %esi 4/r32/esp -21847 $test-compare-reg-with-mem:initialize-stmt: -21848 # var stmt/esi: (addr statement) -21849 68/push 0/imm32/next -21850 68/push 0/imm32/next -21851 68/push 0/imm32/outputs -21852 68/push 0/imm32/outputs -21853 56/push-esi/inouts -21854 68/push 0x11/imm32/alloc-id:fake -21855 68/push 0/imm32/operation -21856 68/push 0/imm32/operation -21857 68/push 1/imm32/tag:stmt1 -21858 89/<- %esi 4/r32/esp -21859 $test-compare-reg-with-mem:initialize-stmt-operation: -21860 # stmt->operation = "compare" -21861 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21862 (copy-array Heap "compare" %eax) -21863 # convert -21864 c7 0/subop/copy *Curr-block-depth 0/imm32 -21865 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21866 (flush _test-output-buffered-file) -21867 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21873 # check output -21874 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") -21875 # . epilogue -21876 89/<- %esp 5/r32/ebp -21877 5d/pop-to-ebp -21878 c3/return -21879 -21880 test-compare-mem-with-literal: -21881 # compare var1, 0x34 -21882 # => -21883 # 81 7/subop/compare *(ebp+___) 0x34/imm32 -21884 # -21885 # . prologue -21886 55/push-ebp -21887 89/<- %ebp 4/r32/esp -21888 # setup -21889 (clear-stream _test-output-stream) -21890 (clear-stream $_test-output-buffered-file->buffer) -21891 $test-compare-mem-with-literal:initialize-type: -21892 # var type/ecx: (payload type-tree) = int -21893 68/push 0/imm32/right:null -21894 68/push 0/imm32/right:null -21895 68/push 0/imm32/left:unused -21896 68/push 1/imm32/value:int -21897 68/push 1/imm32/is-atom?:true -21898 68/push 0x11/imm32/alloc-id:fake:payload -21899 89/<- %ecx 4/r32/esp -21900 $test-compare-mem-with-literal:initialize-var1: -21901 # var var1/ecx: (payload var) -21902 68/push 0/imm32/register -21903 68/push 0/imm32/register -21904 68/push 8/imm32/stack-offset -21905 68/push 1/imm32/block-depth -21906 51/push-ecx -21907 68/push 0x11/imm32/alloc-id:fake -21908 68/push 0/imm32/name -21909 68/push 0/imm32/name -21910 68/push 0x11/imm32/alloc-id:fake:payload -21911 89/<- %ecx 4/r32/esp -21912 $test-compare-mem-with-literal:initialize-var1-name: -21913 # var1->name = "var1" -21914 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -21915 (copy-array Heap "var1" %eax) -21916 $test-compare-mem-with-literal:initialize-literal-type: -21917 # var type/edx: (payload type-tree) = literal -21918 68/push 0/imm32/right:null -21919 68/push 0/imm32/right:null -21920 68/push 0/imm32/left:unused -21921 68/push 0/imm32/value:literal -21922 68/push 1/imm32/is-atom?:true -21923 68/push 0x11/imm32/alloc-id:fake:payload -21924 89/<- %edx 4/r32/esp -21925 $test-compare-mem-with-literal:initialize-literal: -21926 # var l/edx: (payload var) -21927 68/push 0/imm32/register -21928 68/push 0/imm32/register -21929 68/push 0/imm32/no-stack-offset -21930 68/push 1/imm32/block-depth -21931 52/push-edx -21932 68/push 0x11/imm32/alloc-id:fake -21933 68/push 0/imm32/name -21934 68/push 0/imm32/name -21935 68/push 0x11/imm32/alloc-id:fake:payload -21936 89/<- %edx 4/r32/esp -21937 $test-compare-mem-with-literal:initialize-literal-value: -21938 # l->name = "0x34" -21939 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -21940 (copy-array Heap "0x34" %eax) -21941 $test-compare-mem-with-literal:initialize-inouts: -21942 # var inouts/esi: (payload stmt-var) = [l] -21943 68/push 0/imm32/is-deref:false -21944 68/push 0/imm32/next -21945 68/push 0/imm32/next -21946 52/push-edx/l -21947 68/push 0x11/imm32/alloc-id:fake +21634 89/<- %ecx 4/r32/esp +21635 $test-shift-mem-by-literal:initialize-var1-name: +21636 # var1->name = "var1" +21637 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21638 (copy-array Heap "var1" %eax) +21639 $test-shift-mem-by-literal:initialize-literal-type: +21640 # var type/edx: (payload type-tree) = literal +21641 68/push 0/imm32/right:null +21642 68/push 0/imm32/right:null +21643 68/push 0/imm32/left:unused +21644 68/push 0/imm32/value:literal +21645 68/push 1/imm32/is-atom?:true +21646 68/push 0x11/imm32/alloc-id:fake:payload +21647 89/<- %edx 4/r32/esp +21648 $test-shift-mem-by-literal:initialize-literal: +21649 # var l/edx: (payload var) +21650 68/push 0/imm32/register +21651 68/push 0/imm32/register +21652 68/push 0/imm32/no-stack-offset +21653 68/push 1/imm32/block-depth +21654 52/push-edx +21655 68/push 0x11/imm32/alloc-id:fake +21656 68/push 0/imm32/name +21657 68/push 0/imm32/name +21658 68/push 0x11/imm32/alloc-id:fake:payload +21659 89/<- %edx 4/r32/esp +21660 $test-shift-mem-by-literal:initialize-literal-value: +21661 # l->name = "3" +21662 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21663 (copy-array Heap "3" %eax) +21664 $test-shift-mem-by-literal:initialize-inouts: +21665 # var inouts/esi: (payload stmt-var) = [l] +21666 68/push 0/imm32/is-deref:false +21667 68/push 0/imm32/next +21668 68/push 0/imm32/next +21669 52/push-edx/l +21670 68/push 0x11/imm32/alloc-id:fake +21671 68/push 0x11/imm32/alloc-id:fake:payload +21672 89/<- %esi 4/r32/esp +21673 # var inouts = (handle stmt-var) = [var1, var2] +21674 68/push 0/imm32/is-deref:false +21675 56/push-esi/next +21676 68/push 0x11/imm32/alloc-id:fake +21677 51/push-ecx/var1 +21678 68/push 0x11/imm32/alloc-id:fake +21679 68/push 0x11/imm32/alloc-id:fake:payload +21680 89/<- %esi 4/r32/esp +21681 $test-shift-mem-by-literal:initialize-stmt: +21682 # var stmt/esi: (addr statement) +21683 68/push 0/imm32/next +21684 68/push 0/imm32/next +21685 68/push 0/imm32/outputs +21686 68/push 0/imm32/outputs +21687 56/push-esi/inouts +21688 68/push 0x11/imm32/alloc-id:fake +21689 68/push 0/imm32/operation +21690 68/push 0/imm32/operation +21691 68/push 1/imm32/tag:stmt1 +21692 89/<- %esi 4/r32/esp +21693 $test-shift-mem-by-literal:initialize-stmt-operation: +21694 # stmt->operation = "shift-left" +21695 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21696 (copy-array Heap "shift-left" %eax) +21697 # convert +21698 c7 0/subop/copy *Curr-block-depth 0/imm32 +21699 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21700 (flush _test-output-buffered-file) +21701 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21707 # check output +21708 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal") +21709 # . epilogue +21710 89/<- %esp 5/r32/ebp +21711 5d/pop-to-ebp +21712 c3/return +21713 +21714 test-compare-reg-with-reg: +21715 # compare var1/ecx, var2/eax +21716 # => +21717 # 39/compare %ecx 0/r32/eax +21718 # +21719 # . prologue +21720 55/push-ebp +21721 89/<- %ebp 4/r32/esp +21722 # setup +21723 (clear-stream _test-output-stream) +21724 (clear-stream $_test-output-buffered-file->buffer) +21725 $test-compare-reg-with-reg:initialize-type: +21726 # var type/ecx: (payload type-tree) = int +21727 68/push 0/imm32/right:null +21728 68/push 0/imm32/right:null +21729 68/push 0/imm32/left:unused +21730 68/push 1/imm32/value:int +21731 68/push 1/imm32/is-atom?:true +21732 68/push 0x11/imm32/alloc-id:fake:payload +21733 89/<- %ecx 4/r32/esp +21734 $test-compare-reg-with-reg:initialize-var1: +21735 # var var1/ecx: (payload var) +21736 68/push 0/imm32/register +21737 68/push 0/imm32/register +21738 68/push 0/imm32/no-stack-offset +21739 68/push 1/imm32/block-depth +21740 51/push-ecx +21741 68/push 0x11/imm32/alloc-id:fake +21742 68/push 0/imm32/name +21743 68/push 0/imm32/name +21744 68/push 0x11/imm32/alloc-id:fake:payload +21745 89/<- %ecx 4/r32/esp +21746 $test-compare-reg-with-reg:initialize-var1-name: +21747 # var1->name = "var1" +21748 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21749 (copy-array Heap "var1" %eax) +21750 $test-compare-reg-with-reg:initialize-var1-register: +21751 # var1->register = "ecx" +21752 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21753 (copy-array Heap "ecx" %eax) +21754 $test-compare-reg-with-reg:initialize-var2: +21755 # var var2/edx: (payload var) +21756 68/push 0/imm32/register +21757 68/push 0/imm32/register +21758 68/push 0/imm32/no-stack-offset +21759 68/push 1/imm32/block-depth +21760 ff 6/subop/push *(ecx+0x10) +21761 68/push 0x11/imm32/alloc-id:fake +21762 68/push 0/imm32/name +21763 68/push 0/imm32/name +21764 68/push 0x11/imm32/alloc-id:fake:payload +21765 89/<- %edx 4/r32/esp +21766 $test-compare-reg-with-reg:initialize-var2-name: +21767 # var2->name = "var2" +21768 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21769 (copy-array Heap "var2" %eax) +21770 $test-compare-reg-with-reg:initialize-var2-register: +21771 # var2->register = "eax" +21772 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +21773 (copy-array Heap "eax" %eax) +21774 $test-compare-reg-with-reg:initialize-inouts: +21775 # var inouts/esi: (payload stmt-var) = [var2] +21776 68/push 0/imm32/is-deref:false +21777 68/push 0/imm32/next +21778 68/push 0/imm32/next +21779 52/push-edx/var2 +21780 68/push 0x11/imm32/alloc-id:fake +21781 68/push 0x11/imm32/alloc-id:fake:payload +21782 89/<- %esi 4/r32/esp +21783 # inouts = [var1, var2] +21784 68/push 0/imm32/is-deref:false +21785 56/push-esi/next +21786 68/push 0x11/imm32/alloc-id:fake +21787 51/push-ecx/var1 +21788 68/push 0x11/imm32/alloc-id:fake +21789 68/push 0x11/imm32/alloc-id:fake:payload +21790 89/<- %esi 4/r32/esp +21791 $test-compare-reg-with-reg:initialize-stmt: +21792 # var stmt/esi: (addr statement) +21793 68/push 0/imm32/next +21794 68/push 0/imm32/next +21795 68/push 0/imm32/outputs +21796 68/push 0/imm32/outputs +21797 56/push-esi/inouts +21798 68/push 0x11/imm32/alloc-id:fake +21799 68/push 0/imm32/operation +21800 68/push 0/imm32/operation +21801 68/push 1/imm32/tag:stmt1 +21802 89/<- %esi 4/r32/esp +21803 $test-compare-reg-with-reg:initialize-stmt-operation: +21804 # stmt->operation = "compare" +21805 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21806 (copy-array Heap "compare" %eax) +21807 # convert +21808 c7 0/subop/copy *Curr-block-depth 0/imm32 +21809 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21810 (flush _test-output-buffered-file) +21811 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21817 # check output +21818 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg") +21819 # . epilogue +21820 89/<- %esp 5/r32/ebp +21821 5d/pop-to-ebp +21822 c3/return +21823 +21824 test-compare-mem-with-reg: +21825 # compare var1, var2/eax +21826 # => +21827 # 39/compare *(ebp+___) 0/r32/eax +21828 # +21829 # . prologue +21830 55/push-ebp +21831 89/<- %ebp 4/r32/esp +21832 # setup +21833 (clear-stream _test-output-stream) +21834 (clear-stream $_test-output-buffered-file->buffer) +21835 $test-compare-mem-with-reg:initialize-type: +21836 # var type/ecx: (payload type-tree) = int +21837 68/push 0/imm32/right:null +21838 68/push 0/imm32/right:null +21839 68/push 0/imm32/left:unused +21840 68/push 1/imm32/value:int +21841 68/push 1/imm32/is-atom?:true +21842 68/push 0x11/imm32/alloc-id:fake:payload +21843 89/<- %ecx 4/r32/esp +21844 $test-compare-mem-with-reg:initialize-var1: +21845 # var var1/ecx: (payload var) +21846 68/push 0/imm32/register +21847 68/push 0/imm32/register +21848 68/push 8/imm32/stack-offset +21849 68/push 1/imm32/block-depth +21850 51/push-ecx +21851 68/push 0x11/imm32/alloc-id:fake +21852 68/push 0/imm32/name +21853 68/push 0/imm32/name +21854 68/push 0x11/imm32/alloc-id:fake:payload +21855 89/<- %ecx 4/r32/esp +21856 $test-compare-mem-with-reg:initialize-var1-name: +21857 # var1->name = "var1" +21858 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21859 (copy-array Heap "var1" %eax) +21860 $test-compare-mem-with-reg:initialize-var2: +21861 # var var2/edx: (payload var) +21862 68/push 0/imm32/register +21863 68/push 0/imm32/register +21864 68/push 0/imm32/no-stack-offset +21865 68/push 1/imm32/block-depth +21866 ff 6/subop/push *(ecx+0x10) +21867 68/push 0x11/imm32/alloc-id:fake +21868 68/push 0/imm32/name +21869 68/push 0/imm32/name +21870 68/push 0x11/imm32/alloc-id:fake:payload +21871 89/<- %edx 4/r32/esp +21872 $test-compare-mem-with-reg:initialize-var2-name: +21873 # var2->name = "var2" +21874 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21875 (copy-array Heap "var2" %eax) +21876 $test-compare-mem-with-reg:initialize-var2-register: +21877 # var2->register = "eax" +21878 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +21879 (copy-array Heap "eax" %eax) +21880 $test-compare-mem-with-reg:initialize-inouts: +21881 # var inouts/esi: (payload stmt-var) = [var2] +21882 68/push 0/imm32/is-deref:false +21883 68/push 0/imm32/next +21884 68/push 0/imm32/next +21885 52/push-edx/var2 +21886 68/push 0x11/imm32/alloc-id:fake +21887 68/push 0x11/imm32/alloc-id:fake:payload +21888 89/<- %esi 4/r32/esp +21889 # inouts = [var1, var2] +21890 68/push 0/imm32/is-deref:false +21891 56/push-esi/next +21892 68/push 0x11/imm32/alloc-id:fake +21893 51/push-ecx/var1 +21894 68/push 0x11/imm32/alloc-id:fake +21895 68/push 0x11/imm32/alloc-id:fake:payload +21896 89/<- %esi 4/r32/esp +21897 $test-compare-mem-with-reg:initialize-stmt: +21898 # var stmt/esi: (addr statement) +21899 68/push 0/imm32/next +21900 68/push 0/imm32/next +21901 68/push 0/imm32/outputs +21902 68/push 0/imm32/outputs +21903 56/push-esi/inouts +21904 68/push 0x11/imm32/alloc-id:fake +21905 68/push 0/imm32/operation +21906 68/push 0/imm32/operation +21907 68/push 1/imm32/tag:stmt1 +21908 89/<- %esi 4/r32/esp +21909 $test-compare-mem-with-reg:initialize-stmt-operation: +21910 # stmt->operation = "compare" +21911 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +21912 (copy-array Heap "compare" %eax) +21913 # convert +21914 c7 0/subop/copy *Curr-block-depth 0/imm32 +21915 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +21916 (flush _test-output-buffered-file) +21917 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +21923 # check output +21924 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") +21925 # . epilogue +21926 89/<- %esp 5/r32/ebp +21927 5d/pop-to-ebp +21928 c3/return +21929 +21930 test-compare-reg-with-mem: +21931 # compare var1/eax, var2 +21932 # => +21933 # 3b/compare<- *(ebp+___) 0/r32/eax +21934 # +21935 # . prologue +21936 55/push-ebp +21937 89/<- %ebp 4/r32/esp +21938 # setup +21939 (clear-stream _test-output-stream) +21940 (clear-stream $_test-output-buffered-file->buffer) +21941 $test-compare-reg-with-mem:initialize-type: +21942 # var type/ecx: (payload type-tree) = int +21943 68/push 0/imm32/right:null +21944 68/push 0/imm32/right:null +21945 68/push 0/imm32/left:unused +21946 68/push 1/imm32/value:int +21947 68/push 1/imm32/is-atom?:true 21948 68/push 0x11/imm32/alloc-id:fake:payload -21949 89/<- %esi 4/r32/esp -21950 # var inouts = (handle stmt-var) = [var1, var2] -21951 68/push 0/imm32/is-deref:false -21952 56/push-esi/next -21953 68/push 0x11/imm32/alloc-id:fake -21954 51/push-ecx/var1 -21955 68/push 0x11/imm32/alloc-id:fake -21956 68/push 0x11/imm32/alloc-id:fake:payload -21957 89/<- %esi 4/r32/esp -21958 $test-compare-mem-with-literal:initialize-stmt: -21959 # var stmt/esi: (addr statement) -21960 68/push 0/imm32/next -21961 68/push 0/imm32/next -21962 68/push 0/imm32/outputs -21963 68/push 0/imm32/outputs -21964 56/push-esi/inouts -21965 68/push 0x11/imm32/alloc-id:fake -21966 68/push 0/imm32/operation -21967 68/push 0/imm32/operation -21968 68/push 1/imm32/tag:stmt1 -21969 89/<- %esi 4/r32/esp -21970 $test-compare-mem-with-literal:initialize-stmt-operation: -21971 # stmt->operation = "compare" -21972 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -21973 (copy-array Heap "compare" %eax) -21974 # convert -21975 c7 0/subop/copy *Curr-block-depth 0/imm32 -21976 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -21977 (flush _test-output-buffered-file) -21978 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -21984 # check output -21985 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") -21986 # . epilogue -21987 89/<- %esp 5/r32/ebp -21988 5d/pop-to-ebp -21989 c3/return -21990 -21991 test-compare-eax-with-literal: -21992 # compare var1/eax 0x34 -21993 # => -21994 # 3d/compare-eax-with 0x34/imm32 -21995 # -21996 # . prologue -21997 55/push-ebp -21998 89/<- %ebp 4/r32/esp -21999 # setup -22000 (clear-stream _test-output-stream) -22001 (clear-stream $_test-output-buffered-file->buffer) -22002 $test-compare-eax-with-literal:initialize-type: -22003 # var type/ecx: (payload type-tree) = int -22004 68/push 0/imm32/right:null -22005 68/push 0/imm32/right:null -22006 68/push 0/imm32/left:unused -22007 68/push 1/imm32/value:int -22008 68/push 1/imm32/is-atom?:true -22009 68/push 0x11/imm32/alloc-id:fake:payload -22010 89/<- %ecx 4/r32/esp -22011 $test-compare-eax-with-literal:initialize-var1: -22012 # var var1/ecx: (payload var) -22013 68/push 0/imm32/register -22014 68/push 0/imm32/register -22015 68/push 0/imm32/no-stack-offset -22016 68/push 1/imm32/block-depth -22017 51/push-ecx -22018 68/push 0x11/imm32/alloc-id:fake -22019 68/push 0/imm32/name -22020 68/push 0/imm32/name -22021 68/push 0x11/imm32/alloc-id:fake:payload -22022 89/<- %ecx 4/r32/esp -22023 $test-compare-eax-with-literal:initialize-var1-name: -22024 # var1->name = "var1" -22025 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -22026 (copy-array Heap "var1" %eax) -22027 $test-compare-eax-with-literal:initialize-var1-register: -22028 # v->register = "eax" -22029 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -22030 (copy-array Heap "eax" %eax) -22031 $test-compare-eax-with-literal:initialize-literal-type: -22032 # var type/edx: (payload type-tree) = literal -22033 68/push 0/imm32/right:null -22034 68/push 0/imm32/right:null -22035 68/push 0/imm32/left:unused -22036 68/push 0/imm32/value:literal -22037 68/push 1/imm32/is-atom?:true -22038 68/push 0x11/imm32/alloc-id:fake:payload -22039 89/<- %edx 4/r32/esp -22040 $test-compare-eax-with-literal:initialize-literal: -22041 # var l/edx: (payload var) -22042 68/push 0/imm32/register -22043 68/push 0/imm32/register -22044 68/push 0/imm32/no-stack-offset -22045 68/push 1/imm32/block-depth -22046 52/push-edx -22047 68/push 0x11/imm32/alloc-id:fake -22048 68/push 0/imm32/name -22049 68/push 0/imm32/name -22050 68/push 0x11/imm32/alloc-id:fake:payload -22051 89/<- %edx 4/r32/esp -22052 $test-compare-eax-with-literal:initialize-literal-value: -22053 # l->name = "0x34" -22054 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -22055 (copy-array Heap "0x34" %eax) -22056 $test-compare-eax-with-literal:initialize-inouts: -22057 # var inouts/esi: (payload stmt-var) = [l] -22058 68/push 0/imm32/is-deref:false -22059 68/push 0/imm32/next -22060 68/push 0/imm32/next -22061 52/push-edx/l -22062 68/push 0x11/imm32/alloc-id:fake -22063 68/push 0x11/imm32/alloc-id:fake:payload -22064 89/<- %esi 4/r32/esp -22065 # var inouts = (handle stmt-var) = [var1, var2] -22066 68/push 0/imm32/is-deref:false -22067 56/push-esi/next -22068 68/push 0x11/imm32/alloc-id:fake -22069 51/push-ecx/var1 -22070 68/push 0x11/imm32/alloc-id:fake -22071 68/push 0x11/imm32/alloc-id:fake:payload -22072 89/<- %esi 4/r32/esp -22073 $test-compare-eax-with-literal:initialize-stmt: -22074 # var stmt/esi: (addr statement) -22075 68/push 0/imm32/next -22076 68/push 0/imm32/next -22077 68/push 0/imm32/outputs -22078 68/push 0/imm32/outputs -22079 56/push-esi/inouts -22080 68/push 0x11/imm32/alloc-id:fake -22081 68/push 0/imm32/operation -22082 68/push 0/imm32/operation -22083 68/push 1/imm32/tag:stmt1 -22084 89/<- %esi 4/r32/esp -22085 $test-compare-eax-with-literal:initialize-stmt-operation: -22086 # stmt->operation = "compare" -22087 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -22088 (copy-array Heap "compare" %eax) -22089 # convert -22090 c7 0/subop/copy *Curr-block-depth 0/imm32 -22091 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -22092 (flush _test-output-buffered-file) -22093 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -22099 # check output -22100 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") -22101 # . epilogue -22102 89/<- %esp 5/r32/ebp -22103 5d/pop-to-ebp -22104 c3/return -22105 -22106 test-compare-reg-with-literal: -22107 # compare var1/ecx 0x34 -22108 # => -22109 # 81 7/subop/compare %ecx 0x34/imm32 -22110 # -22111 # . prologue -22112 55/push-ebp -22113 89/<- %ebp 4/r32/esp -22114 # setup -22115 (clear-stream _test-output-stream) -22116 (clear-stream $_test-output-buffered-file->buffer) -22117 $test-compare-reg-with-literal:initialize-type: -22118 # var type/ecx: (payload type-tree) = int -22119 68/push 0/imm32/right:null -22120 68/push 0/imm32/right:null -22121 68/push 0/imm32/left:unused -22122 68/push 1/imm32/value:int -22123 68/push 1/imm32/is-atom?:true -22124 68/push 0x11/imm32/alloc-id:fake:payload -22125 89/<- %ecx 4/r32/esp -22126 $test-compare-reg-with-literal:initialize-var1: -22127 # var var1/ecx: (payload var) -22128 68/push 0/imm32/register -22129 68/push 0/imm32/register -22130 68/push 0/imm32/no-stack-offset -22131 68/push 1/imm32/block-depth -22132 51/push-ecx -22133 68/push 0x11/imm32/alloc-id:fake -22134 68/push 0/imm32/name -22135 68/push 0/imm32/name -22136 68/push 0x11/imm32/alloc-id:fake:payload -22137 89/<- %ecx 4/r32/esp -22138 $test-compare-reg-with-literal:initialize-var1-name: -22139 # var1->name = "var1" -22140 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -22141 (copy-array Heap "var1" %eax) -22142 $test-compare-reg-with-literal:initialize-var1-register: -22143 # v->register = "ecx" -22144 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -22145 (copy-array Heap "ecx" %eax) -22146 $test-compare-reg-with-literal:initialize-literal-type: -22147 # var type/edx: (payload type-tree) = literal -22148 68/push 0/imm32/right:null -22149 68/push 0/imm32/right:null -22150 68/push 0/imm32/left:unused -22151 68/push 0/imm32/value:literal -22152 68/push 1/imm32/is-atom?:true -22153 68/push 0x11/imm32/alloc-id:fake:payload -22154 89/<- %edx 4/r32/esp -22155 $test-compare-reg-with-literal:initialize-literal: -22156 # var l/edx: (payload var) -22157 68/push 0/imm32/register -22158 68/push 0/imm32/register -22159 68/push 0/imm32/no-stack-offset -22160 68/push 1/imm32/block-depth -22161 52/push-edx -22162 68/push 0x11/imm32/alloc-id:fake -22163 68/push 0/imm32/name -22164 68/push 0/imm32/name +21949 89/<- %ecx 4/r32/esp +21950 $test-compare-reg-with-mem:initialize-var1: +21951 # var var1/ecx: (payload var) +21952 68/push 0/imm32/register +21953 68/push 0/imm32/register +21954 68/push 0/imm32/no-stack-offset +21955 68/push 1/imm32/block-depth +21956 51/push-ecx +21957 68/push 0x11/imm32/alloc-id:fake +21958 68/push 0/imm32/name +21959 68/push 0/imm32/name +21960 68/push 0x11/imm32/alloc-id:fake:payload +21961 89/<- %ecx 4/r32/esp +21962 $test-compare-reg-with-mem:initialize-var1-name: +21963 # var1->name = "var1" +21964 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +21965 (copy-array Heap "var1" %eax) +21966 $test-compare-reg-with-mem:initialize-var1-register: +21967 # var1->register = "eax" +21968 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +21969 (copy-array Heap "eax" %eax) +21970 $test-compare-reg-with-mem:initialize-var2: +21971 # var var2/edx: (payload var) +21972 68/push 0/imm32/register +21973 68/push 0/imm32/register +21974 68/push 8/imm32/stack-offset +21975 68/push 1/imm32/block-depth +21976 ff 6/subop/push *(ecx+0x10) +21977 68/push 0x11/imm32/alloc-id:fake +21978 68/push 0/imm32/name +21979 68/push 0/imm32/name +21980 68/push 0x11/imm32/alloc-id:fake:payload +21981 89/<- %edx 4/r32/esp +21982 $test-compare-reg-with-mem:initialize-var2-name: +21983 # var2->name = "var2" +21984 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +21985 (copy-array Heap "var2" %eax) +21986 $test-compare-reg-with-mem:initialize-inouts: +21987 # var inouts/esi: (payload stmt-var) = [var2] +21988 68/push 0/imm32/is-deref:false +21989 68/push 0/imm32/next +21990 68/push 0/imm32/next +21991 52/push-edx/var2 +21992 68/push 0x11/imm32/alloc-id:fake +21993 68/push 0x11/imm32/alloc-id:fake:payload +21994 89/<- %esi 4/r32/esp +21995 # inouts = [var1, var2] +21996 68/push 0/imm32/is-deref:false +21997 56/push-esi/next +21998 68/push 0x11/imm32/alloc-id:fake +21999 51/push-ecx/var1 +22000 68/push 0x11/imm32/alloc-id:fake +22001 68/push 0x11/imm32/alloc-id:fake:payload +22002 89/<- %esi 4/r32/esp +22003 $test-compare-reg-with-mem:initialize-stmt: +22004 # var stmt/esi: (addr statement) +22005 68/push 0/imm32/next +22006 68/push 0/imm32/next +22007 68/push 0/imm32/outputs +22008 68/push 0/imm32/outputs +22009 56/push-esi/inouts +22010 68/push 0x11/imm32/alloc-id:fake +22011 68/push 0/imm32/operation +22012 68/push 0/imm32/operation +22013 68/push 1/imm32/tag:stmt1 +22014 89/<- %esi 4/r32/esp +22015 $test-compare-reg-with-mem:initialize-stmt-operation: +22016 # stmt->operation = "compare" +22017 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22018 (copy-array Heap "compare" %eax) +22019 # convert +22020 c7 0/subop/copy *Curr-block-depth 0/imm32 +22021 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +22022 (flush _test-output-buffered-file) +22023 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22029 # check output +22030 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") +22031 # . epilogue +22032 89/<- %esp 5/r32/ebp +22033 5d/pop-to-ebp +22034 c3/return +22035 +22036 test-compare-mem-with-literal: +22037 # compare var1, 0x34 +22038 # => +22039 # 81 7/subop/compare *(ebp+___) 0x34/imm32 +22040 # +22041 # . prologue +22042 55/push-ebp +22043 89/<- %ebp 4/r32/esp +22044 # setup +22045 (clear-stream _test-output-stream) +22046 (clear-stream $_test-output-buffered-file->buffer) +22047 $test-compare-mem-with-literal:initialize-type: +22048 # var type/ecx: (payload type-tree) = int +22049 68/push 0/imm32/right:null +22050 68/push 0/imm32/right:null +22051 68/push 0/imm32/left:unused +22052 68/push 1/imm32/value:int +22053 68/push 1/imm32/is-atom?:true +22054 68/push 0x11/imm32/alloc-id:fake:payload +22055 89/<- %ecx 4/r32/esp +22056 $test-compare-mem-with-literal:initialize-var1: +22057 # var var1/ecx: (payload var) +22058 68/push 0/imm32/register +22059 68/push 0/imm32/register +22060 68/push 8/imm32/stack-offset +22061 68/push 1/imm32/block-depth +22062 51/push-ecx +22063 68/push 0x11/imm32/alloc-id:fake +22064 68/push 0/imm32/name +22065 68/push 0/imm32/name +22066 68/push 0x11/imm32/alloc-id:fake:payload +22067 89/<- %ecx 4/r32/esp +22068 $test-compare-mem-with-literal:initialize-var1-name: +22069 # var1->name = "var1" +22070 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +22071 (copy-array Heap "var1" %eax) +22072 $test-compare-mem-with-literal:initialize-literal-type: +22073 # var type/edx: (payload type-tree) = literal +22074 68/push 0/imm32/right:null +22075 68/push 0/imm32/right:null +22076 68/push 0/imm32/left:unused +22077 68/push 0/imm32/value:literal +22078 68/push 1/imm32/is-atom?:true +22079 68/push 0x11/imm32/alloc-id:fake:payload +22080 89/<- %edx 4/r32/esp +22081 $test-compare-mem-with-literal:initialize-literal: +22082 # var l/edx: (payload var) +22083 68/push 0/imm32/register +22084 68/push 0/imm32/register +22085 68/push 0/imm32/no-stack-offset +22086 68/push 1/imm32/block-depth +22087 52/push-edx +22088 68/push 0x11/imm32/alloc-id:fake +22089 68/push 0/imm32/name +22090 68/push 0/imm32/name +22091 68/push 0x11/imm32/alloc-id:fake:payload +22092 89/<- %edx 4/r32/esp +22093 $test-compare-mem-with-literal:initialize-literal-value: +22094 # l->name = "0x34" +22095 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +22096 (copy-array Heap "0x34" %eax) +22097 $test-compare-mem-with-literal:initialize-inouts: +22098 # var inouts/esi: (payload stmt-var) = [l] +22099 68/push 0/imm32/is-deref:false +22100 68/push 0/imm32/next +22101 68/push 0/imm32/next +22102 52/push-edx/l +22103 68/push 0x11/imm32/alloc-id:fake +22104 68/push 0x11/imm32/alloc-id:fake:payload +22105 89/<- %esi 4/r32/esp +22106 # var inouts = (handle stmt-var) = [var1, var2] +22107 68/push 0/imm32/is-deref:false +22108 56/push-esi/next +22109 68/push 0x11/imm32/alloc-id:fake +22110 51/push-ecx/var1 +22111 68/push 0x11/imm32/alloc-id:fake +22112 68/push 0x11/imm32/alloc-id:fake:payload +22113 89/<- %esi 4/r32/esp +22114 $test-compare-mem-with-literal:initialize-stmt: +22115 # var stmt/esi: (addr statement) +22116 68/push 0/imm32/next +22117 68/push 0/imm32/next +22118 68/push 0/imm32/outputs +22119 68/push 0/imm32/outputs +22120 56/push-esi/inouts +22121 68/push 0x11/imm32/alloc-id:fake +22122 68/push 0/imm32/operation +22123 68/push 0/imm32/operation +22124 68/push 1/imm32/tag:stmt1 +22125 89/<- %esi 4/r32/esp +22126 $test-compare-mem-with-literal:initialize-stmt-operation: +22127 # stmt->operation = "compare" +22128 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22129 (copy-array Heap "compare" %eax) +22130 # convert +22131 c7 0/subop/copy *Curr-block-depth 0/imm32 +22132 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +22133 (flush _test-output-buffered-file) +22134 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22140 # check output +22141 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") +22142 # . epilogue +22143 89/<- %esp 5/r32/ebp +22144 5d/pop-to-ebp +22145 c3/return +22146 +22147 test-compare-eax-with-literal: +22148 # compare var1/eax 0x34 +22149 # => +22150 # 3d/compare-eax-with 0x34/imm32 +22151 # +22152 # . prologue +22153 55/push-ebp +22154 89/<- %ebp 4/r32/esp +22155 # setup +22156 (clear-stream _test-output-stream) +22157 (clear-stream $_test-output-buffered-file->buffer) +22158 $test-compare-eax-with-literal:initialize-type: +22159 # var type/ecx: (payload type-tree) = int +22160 68/push 0/imm32/right:null +22161 68/push 0/imm32/right:null +22162 68/push 0/imm32/left:unused +22163 68/push 1/imm32/value:int +22164 68/push 1/imm32/is-atom?:true 22165 68/push 0x11/imm32/alloc-id:fake:payload -22166 89/<- %edx 4/r32/esp -22167 $test-compare-reg-with-literal:initialize-literal-value: -22168 # l->name = "0x34" -22169 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -22170 (copy-array Heap "0x34" %eax) -22171 $test-compare-reg-with-literal:initialize-inouts: -22172 # var inouts/esi: (payload stmt-var) = [l] -22173 68/push 0/imm32/is-deref:false -22174 68/push 0/imm32/next -22175 68/push 0/imm32/next -22176 52/push-edx/l -22177 68/push 0x11/imm32/alloc-id:fake -22178 68/push 0x11/imm32/alloc-id:fake:payload -22179 89/<- %esi 4/r32/esp -22180 # var inouts = (handle stmt-var) = [var1, var2] -22181 68/push 0/imm32/is-deref:false -22182 56/push-esi/next -22183 68/push 0x11/imm32/alloc-id:fake -22184 51/push-ecx/var1 -22185 68/push 0x11/imm32/alloc-id:fake -22186 68/push 0x11/imm32/alloc-id:fake:payload -22187 89/<- %esi 4/r32/esp -22188 $test-compare-reg-with-literal:initialize-stmt: -22189 # var stmt/esi: (addr statement) -22190 68/push 0/imm32/next -22191 68/push 0/imm32/next -22192 68/push 0/imm32/outputs -22193 68/push 0/imm32/outputs -22194 56/push-esi/inouts -22195 68/push 0x11/imm32/alloc-id:fake -22196 68/push 0/imm32/operation -22197 68/push 0/imm32/operation -22198 68/push 1/imm32/tag:stmt1 -22199 89/<- %esi 4/r32/esp -22200 $test-compare-reg-with-literal:initialize-stmt-operation: -22201 # stmt->operation = "compare" -22202 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -22203 (copy-array Heap "compare" %eax) -22204 # convert -22205 c7 0/subop/copy *Curr-block-depth 0/imm32 -22206 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -22207 (flush _test-output-buffered-file) -22208 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -22214 # check output -22215 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") -22216 # . epilogue -22217 89/<- %esp 5/r32/ebp -22218 5d/pop-to-ebp -22219 c3/return -22220 -22221 test-emit-subx-stmt-function-call: -22222 # Call a function on a variable on the stack. -22223 # f foo -22224 # => -22225 # (f *(ebp-8)) -22226 # (Changing the function name supports overloading in general, but here it -22227 # just serves to help disambiguate things.) -22228 # -22229 # There's a variable on the var stack as follows: -22230 # name: 'foo' -22231 # type: int -22232 # stack-offset: -8 -22233 # -22234 # There's nothing in primitives. -22235 # -22236 # We don't perform any checking here on the type of 'f'. -22237 # -22238 # . prologue -22239 55/push-ebp -22240 89/<- %ebp 4/r32/esp -22241 # setup -22242 (clear-stream _test-output-stream) -22243 (clear-stream $_test-output-buffered-file->buffer) -22244 $test-emit-subx-function-call:initialize-type: -22245 # var type/ecx: (payload type-tree) = int -22246 68/push 0/imm32/right:null -22247 68/push 0/imm32/right:null -22248 68/push 0/imm32/left:unused -22249 68/push 1/imm32/value:int -22250 68/push 1/imm32/is-atom?:true -22251 68/push 0x11/imm32/alloc-id:fake:payload -22252 89/<- %ecx 4/r32/esp -22253 $test-emit-subx-function-call:initialize-var: -22254 # var var-foo/ecx: (payload var) = var(type) -22255 68/push 0/imm32/no-register -22256 68/push 0/imm32/no-register -22257 68/push -8/imm32/stack-offset -22258 68/push 1/imm32/block-depth -22259 51/push-ecx/type -22260 68/push 0x11/imm32/alloc-id:fake -22261 68/push 0/imm32/name -22262 68/push 0/imm32/name -22263 68/push 0x11/imm32/alloc-id:fake:payload -22264 89/<- %ecx 4/r32/esp -22265 $test-emit-subx-function-call:initialize-var-name: -22266 # var-foo->name = "foo" -22267 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -22268 (copy-array Heap "foo" %eax) -22269 $test-emit-subx-function-call:initialize-stmt-var: -22270 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -22271 68/push 0/imm32/is-deref:false -22272 68/push 0/imm32/next -22273 68/push 0/imm32/next -22274 51/push-ecx/var-foo -22275 68/push 0x11/imm32/alloc-id:fake -22276 68/push 0x11/imm32/alloc-id:fake:payload -22277 89/<- %ebx 4/r32/esp -22278 $test-emit-subx-function-call:initialize-stmt: -22279 # var stmt/esi: (addr statement) -22280 68/push 0/imm32/no-outputs -22281 68/push 0/imm32/no-outputs -22282 53/push-ebx/inouts -22283 68/push 0x11/imm32/alloc-id:fake -22284 68/push 0/imm32/operation -22285 68/push 0/imm32/operation -22286 68/push 1/imm32/tag -22287 89/<- %esi 4/r32/esp -22288 $test-emit-subx-function-call:initialize-stmt-operation: -22289 # stmt->operation = "f" -22290 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -22291 (copy-array Heap "f" %eax) -22292 # convert -22293 c7 0/subop/copy *Curr-block-depth 0/imm32 -22294 (emit-subx-stmt _test-output-buffered-file %esi 0 Stderr 0) -22295 (flush _test-output-buffered-file) -22296 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -22302 # check output -22303 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") -22304 # . epilogue -22305 89/<- %esp 5/r32/ebp -22306 5d/pop-to-ebp -22307 c3/return -22308 -22309 test-emit-subx-stmt-function-call-with-literal-arg: -22310 # Call a function on a literal. -22311 # f 0x34 -22312 # => -22313 # (f2 0x34) -22314 # -22315 # . prologue -22316 55/push-ebp -22317 89/<- %ebp 4/r32/esp -22318 # setup -22319 (clear-stream _test-output-stream) -22320 (clear-stream $_test-output-buffered-file->buffer) -22321 $test-emit-subx-function-call-with-literal-arg:initialize-type: -22322 # var type/ecx: (payload type-tree) = int -22323 68/push 0/imm32/right:null -22324 68/push 0/imm32/right:null -22325 68/push 0/imm32/left:unused -22326 68/push 0/imm32/value:literal -22327 68/push 1/imm32/is-atom?:true -22328 68/push 0x11/imm32/alloc-id:fake:payload -22329 89/<- %ecx 4/r32/esp -22330 $test-emit-subx-function-call-with-literal-arg:initialize-var: -22331 # var var-foo/ecx: (payload var) = var(lit) -22332 68/push 0/imm32/no-register -22333 68/push 0/imm32/no-register -22334 68/push 0/imm32/no-stack-offset -22335 68/push 1/imm32/block-depth -22336 51/push-ecx/type -22337 68/push 0x11/imm32/alloc-id:fake -22338 68/push 0/imm32/name -22339 68/push 0/imm32/name -22340 68/push 0x11/imm32/alloc-id:fake:payload -22341 89/<- %ecx 4/r32/esp -22342 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: -22343 # var-foo->name = "0x34" -22344 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -22345 (copy-array Heap "0x34" %eax) -22346 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: -22347 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -22348 68/push 0/imm32/is-deref:false -22349 68/push 0/imm32/next -22350 68/push 0/imm32/next -22351 51/push-ecx/var-foo -22352 68/push 0x11/imm32/alloc-id:fake -22353 68/push 0x11/imm32/alloc-id:fake:payload -22354 89/<- %ebx 4/r32/esp -22355 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: -22356 # var stmt/esi: (addr statement) -22357 68/push 0/imm32/no-outputs -22358 68/push 0/imm32/no-outputs -22359 53/push-ebx/inouts -22360 68/push 0x11/imm32/alloc-id:fake -22361 68/push 0/imm32/operation -22362 68/push 0/imm32/operation -22363 68/push 1/imm32/tag -22364 89/<- %esi 4/r32/esp -22365 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: -22366 # stmt->operation = "f" -22367 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -22368 (copy-array Heap "f" %eax) -22369 # convert -22370 c7 0/subop/copy *Curr-block-depth 0/imm32 -22371 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx Stderr 0) -22372 (flush _test-output-buffered-file) -22373 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -22379 # check output -22380 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") -22381 # . epilogue -22382 89/<- %esp 5/r32/ebp -22383 5d/pop-to-ebp -22384 c3/return -22385 -22386 emit-indent: # out: (addr buffered-file), n: int -22387 # . prologue -22388 55/push-ebp -22389 89/<- %ebp 4/r32/esp -22390 # . save registers -22391 50/push-eax -22392 # var i/eax: int = n -22393 8b/-> *(ebp+0xc) 0/r32/eax -22394 { -22395 # if (i <= 0) break -22396 3d/compare-eax-with 0/imm32 -22397 7e/jump-if-<= break/disp8 -22398 (write-buffered *(ebp+8) " ") -22399 48/decrement-eax -22400 eb/jump loop/disp8 -22401 } -22402 $emit-indent:end: -22403 # . restore registers -22404 58/pop-to-eax -22405 # . epilogue -22406 89/<- %esp 5/r32/ebp -22407 5d/pop-to-ebp -22408 c3/return -22409 -22410 emit-subx-prologue: # out: (addr buffered-file) -22411 # . prologue -22412 55/push-ebp -22413 89/<- %ebp 4/r32/esp -22414 # -22415 (write-buffered *(ebp+8) " # . prologue\n") -22416 (write-buffered *(ebp+8) " 55/push-ebp\n") -22417 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") -22418 $emit-subx-prologue:end: -22419 # . epilogue -22420 89/<- %esp 5/r32/ebp -22421 5d/pop-to-ebp -22422 c3/return -22423 -22424 emit-subx-epilogue: # out: (addr buffered-file) -22425 # . prologue -22426 55/push-ebp -22427 89/<- %ebp 4/r32/esp -22428 # -22429 (write-buffered *(ebp+8) " # . epilogue\n") -22430 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") -22431 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") -22432 (write-buffered *(ebp+8) " c3/return\n") -22433 $emit-subx-epilogue:end: -22434 # . epilogue -22435 89/<- %esp 5/r32/ebp -22436 5d/pop-to-ebp -22437 c3/return +22166 89/<- %ecx 4/r32/esp +22167 $test-compare-eax-with-literal:initialize-var1: +22168 # var var1/ecx: (payload var) +22169 68/push 0/imm32/register +22170 68/push 0/imm32/register +22171 68/push 0/imm32/no-stack-offset +22172 68/push 1/imm32/block-depth +22173 51/push-ecx +22174 68/push 0x11/imm32/alloc-id:fake +22175 68/push 0/imm32/name +22176 68/push 0/imm32/name +22177 68/push 0x11/imm32/alloc-id:fake:payload +22178 89/<- %ecx 4/r32/esp +22179 $test-compare-eax-with-literal:initialize-var1-name: +22180 # var1->name = "var1" +22181 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +22182 (copy-array Heap "var1" %eax) +22183 $test-compare-eax-with-literal:initialize-var1-register: +22184 # v->register = "eax" +22185 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +22186 (copy-array Heap "eax" %eax) +22187 $test-compare-eax-with-literal:initialize-literal-type: +22188 # var type/edx: (payload type-tree) = literal +22189 68/push 0/imm32/right:null +22190 68/push 0/imm32/right:null +22191 68/push 0/imm32/left:unused +22192 68/push 0/imm32/value:literal +22193 68/push 1/imm32/is-atom?:true +22194 68/push 0x11/imm32/alloc-id:fake:payload +22195 89/<- %edx 4/r32/esp +22196 $test-compare-eax-with-literal:initialize-literal: +22197 # var l/edx: (payload var) +22198 68/push 0/imm32/register +22199 68/push 0/imm32/register +22200 68/push 0/imm32/no-stack-offset +22201 68/push 1/imm32/block-depth +22202 52/push-edx +22203 68/push 0x11/imm32/alloc-id:fake +22204 68/push 0/imm32/name +22205 68/push 0/imm32/name +22206 68/push 0x11/imm32/alloc-id:fake:payload +22207 89/<- %edx 4/r32/esp +22208 $test-compare-eax-with-literal:initialize-literal-value: +22209 # l->name = "0x34" +22210 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +22211 (copy-array Heap "0x34" %eax) +22212 $test-compare-eax-with-literal:initialize-inouts: +22213 # var inouts/esi: (payload stmt-var) = [l] +22214 68/push 0/imm32/is-deref:false +22215 68/push 0/imm32/next +22216 68/push 0/imm32/next +22217 52/push-edx/l +22218 68/push 0x11/imm32/alloc-id:fake +22219 68/push 0x11/imm32/alloc-id:fake:payload +22220 89/<- %esi 4/r32/esp +22221 # var inouts = (handle stmt-var) = [var1, var2] +22222 68/push 0/imm32/is-deref:false +22223 56/push-esi/next +22224 68/push 0x11/imm32/alloc-id:fake +22225 51/push-ecx/var1 +22226 68/push 0x11/imm32/alloc-id:fake +22227 68/push 0x11/imm32/alloc-id:fake:payload +22228 89/<- %esi 4/r32/esp +22229 $test-compare-eax-with-literal:initialize-stmt: +22230 # var stmt/esi: (addr statement) +22231 68/push 0/imm32/next +22232 68/push 0/imm32/next +22233 68/push 0/imm32/outputs +22234 68/push 0/imm32/outputs +22235 56/push-esi/inouts +22236 68/push 0x11/imm32/alloc-id:fake +22237 68/push 0/imm32/operation +22238 68/push 0/imm32/operation +22239 68/push 1/imm32/tag:stmt1 +22240 89/<- %esi 4/r32/esp +22241 $test-compare-eax-with-literal:initialize-stmt-operation: +22242 # stmt->operation = "compare" +22243 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22244 (copy-array Heap "compare" %eax) +22245 # convert +22246 c7 0/subop/copy *Curr-block-depth 0/imm32 +22247 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +22248 (flush _test-output-buffered-file) +22249 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22255 # check output +22256 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") +22257 # . epilogue +22258 89/<- %esp 5/r32/ebp +22259 5d/pop-to-ebp +22260 c3/return +22261 +22262 test-compare-reg-with-literal: +22263 # compare var1/ecx 0x34 +22264 # => +22265 # 81 7/subop/compare %ecx 0x34/imm32 +22266 # +22267 # . prologue +22268 55/push-ebp +22269 89/<- %ebp 4/r32/esp +22270 # setup +22271 (clear-stream _test-output-stream) +22272 (clear-stream $_test-output-buffered-file->buffer) +22273 $test-compare-reg-with-literal:initialize-type: +22274 # var type/ecx: (payload type-tree) = int +22275 68/push 0/imm32/right:null +22276 68/push 0/imm32/right:null +22277 68/push 0/imm32/left:unused +22278 68/push 1/imm32/value:int +22279 68/push 1/imm32/is-atom?:true +22280 68/push 0x11/imm32/alloc-id:fake:payload +22281 89/<- %ecx 4/r32/esp +22282 $test-compare-reg-with-literal:initialize-var1: +22283 # var var1/ecx: (payload var) +22284 68/push 0/imm32/register +22285 68/push 0/imm32/register +22286 68/push 0/imm32/no-stack-offset +22287 68/push 1/imm32/block-depth +22288 51/push-ecx +22289 68/push 0x11/imm32/alloc-id:fake +22290 68/push 0/imm32/name +22291 68/push 0/imm32/name +22292 68/push 0x11/imm32/alloc-id:fake:payload +22293 89/<- %ecx 4/r32/esp +22294 $test-compare-reg-with-literal:initialize-var1-name: +22295 # var1->name = "var1" +22296 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +22297 (copy-array Heap "var1" %eax) +22298 $test-compare-reg-with-literal:initialize-var1-register: +22299 # v->register = "ecx" +22300 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +22301 (copy-array Heap "ecx" %eax) +22302 $test-compare-reg-with-literal:initialize-literal-type: +22303 # var type/edx: (payload type-tree) = literal +22304 68/push 0/imm32/right:null +22305 68/push 0/imm32/right:null +22306 68/push 0/imm32/left:unused +22307 68/push 0/imm32/value:literal +22308 68/push 1/imm32/is-atom?:true +22309 68/push 0x11/imm32/alloc-id:fake:payload +22310 89/<- %edx 4/r32/esp +22311 $test-compare-reg-with-literal:initialize-literal: +22312 # var l/edx: (payload var) +22313 68/push 0/imm32/register +22314 68/push 0/imm32/register +22315 68/push 0/imm32/no-stack-offset +22316 68/push 1/imm32/block-depth +22317 52/push-edx +22318 68/push 0x11/imm32/alloc-id:fake +22319 68/push 0/imm32/name +22320 68/push 0/imm32/name +22321 68/push 0x11/imm32/alloc-id:fake:payload +22322 89/<- %edx 4/r32/esp +22323 $test-compare-reg-with-literal:initialize-literal-value: +22324 # l->name = "0x34" +22325 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +22326 (copy-array Heap "0x34" %eax) +22327 $test-compare-reg-with-literal:initialize-inouts: +22328 # var inouts/esi: (payload stmt-var) = [l] +22329 68/push 0/imm32/is-deref:false +22330 68/push 0/imm32/next +22331 68/push 0/imm32/next +22332 52/push-edx/l +22333 68/push 0x11/imm32/alloc-id:fake +22334 68/push 0x11/imm32/alloc-id:fake:payload +22335 89/<- %esi 4/r32/esp +22336 # var inouts = (handle stmt-var) = [var1, var2] +22337 68/push 0/imm32/is-deref:false +22338 56/push-esi/next +22339 68/push 0x11/imm32/alloc-id:fake +22340 51/push-ecx/var1 +22341 68/push 0x11/imm32/alloc-id:fake +22342 68/push 0x11/imm32/alloc-id:fake:payload +22343 89/<- %esi 4/r32/esp +22344 $test-compare-reg-with-literal:initialize-stmt: +22345 # var stmt/esi: (addr statement) +22346 68/push 0/imm32/next +22347 68/push 0/imm32/next +22348 68/push 0/imm32/outputs +22349 68/push 0/imm32/outputs +22350 56/push-esi/inouts +22351 68/push 0x11/imm32/alloc-id:fake +22352 68/push 0/imm32/operation +22353 68/push 0/imm32/operation +22354 68/push 1/imm32/tag:stmt1 +22355 89/<- %esi 4/r32/esp +22356 $test-compare-reg-with-literal:initialize-stmt-operation: +22357 # stmt->operation = "compare" +22358 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22359 (copy-array Heap "compare" %eax) +22360 # convert +22361 c7 0/subop/copy *Curr-block-depth 0/imm32 +22362 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +22363 (flush _test-output-buffered-file) +22364 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22370 # check output +22371 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") +22372 # . epilogue +22373 89/<- %esp 5/r32/ebp +22374 5d/pop-to-ebp +22375 c3/return +22376 +22377 test-emit-subx-stmt-function-call: +22378 # Call a function on a variable on the stack. +22379 # f foo +22380 # => +22381 # (f *(ebp-8)) +22382 # (Changing the function name supports overloading in general, but here it +22383 # just serves to help disambiguate things.) +22384 # +22385 # There's a variable on the var stack as follows: +22386 # name: 'foo' +22387 # type: int +22388 # stack-offset: -8 +22389 # +22390 # There's nothing in primitives. +22391 # +22392 # We don't perform any checking here on the type of 'f'. +22393 # +22394 # . prologue +22395 55/push-ebp +22396 89/<- %ebp 4/r32/esp +22397 # setup +22398 (clear-stream _test-output-stream) +22399 (clear-stream $_test-output-buffered-file->buffer) +22400 $test-emit-subx-function-call:initialize-type: +22401 # var type/ecx: (payload type-tree) = int +22402 68/push 0/imm32/right:null +22403 68/push 0/imm32/right:null +22404 68/push 0/imm32/left:unused +22405 68/push 1/imm32/value:int +22406 68/push 1/imm32/is-atom?:true +22407 68/push 0x11/imm32/alloc-id:fake:payload +22408 89/<- %ecx 4/r32/esp +22409 $test-emit-subx-function-call:initialize-var: +22410 # var var-foo/ecx: (payload var) = var(type) +22411 68/push 0/imm32/no-register +22412 68/push 0/imm32/no-register +22413 68/push -8/imm32/stack-offset +22414 68/push 1/imm32/block-depth +22415 51/push-ecx/type +22416 68/push 0x11/imm32/alloc-id:fake +22417 68/push 0/imm32/name +22418 68/push 0/imm32/name +22419 68/push 0x11/imm32/alloc-id:fake:payload +22420 89/<- %ecx 4/r32/esp +22421 $test-emit-subx-function-call:initialize-var-name: +22422 # var-foo->name = "foo" +22423 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +22424 (copy-array Heap "foo" %eax) +22425 $test-emit-subx-function-call:initialize-stmt-var: +22426 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +22427 68/push 0/imm32/is-deref:false +22428 68/push 0/imm32/next +22429 68/push 0/imm32/next +22430 51/push-ecx/var-foo +22431 68/push 0x11/imm32/alloc-id:fake +22432 68/push 0x11/imm32/alloc-id:fake:payload +22433 89/<- %ebx 4/r32/esp +22434 $test-emit-subx-function-call:initialize-stmt: +22435 # var stmt/esi: (addr statement) +22436 68/push 0/imm32/no-outputs +22437 68/push 0/imm32/no-outputs +22438 53/push-ebx/inouts +22439 68/push 0x11/imm32/alloc-id:fake +22440 68/push 0/imm32/operation +22441 68/push 0/imm32/operation +22442 68/push 1/imm32/tag +22443 89/<- %esi 4/r32/esp +22444 $test-emit-subx-function-call:initialize-stmt-operation: +22445 # stmt->operation = "f" +22446 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22447 (copy-array Heap "f" %eax) +22448 # convert +22449 c7 0/subop/copy *Curr-block-depth 0/imm32 +22450 (emit-subx-stmt _test-output-buffered-file %esi 0 Stderr 0) +22451 (flush _test-output-buffered-file) +22452 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22458 # check output +22459 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") +22460 # . epilogue +22461 89/<- %esp 5/r32/ebp +22462 5d/pop-to-ebp +22463 c3/return +22464 +22465 test-emit-subx-stmt-function-call-with-literal-arg: +22466 # Call a function on a literal. +22467 # f 0x34 +22468 # => +22469 # (f2 0x34) +22470 # +22471 # . prologue +22472 55/push-ebp +22473 89/<- %ebp 4/r32/esp +22474 # setup +22475 (clear-stream _test-output-stream) +22476 (clear-stream $_test-output-buffered-file->buffer) +22477 $test-emit-subx-function-call-with-literal-arg:initialize-type: +22478 # var type/ecx: (payload type-tree) = int +22479 68/push 0/imm32/right:null +22480 68/push 0/imm32/right:null +22481 68/push 0/imm32/left:unused +22482 68/push 0/imm32/value:literal +22483 68/push 1/imm32/is-atom?:true +22484 68/push 0x11/imm32/alloc-id:fake:payload +22485 89/<- %ecx 4/r32/esp +22486 $test-emit-subx-function-call-with-literal-arg:initialize-var: +22487 # var var-foo/ecx: (payload var) = var(lit) +22488 68/push 0/imm32/no-register +22489 68/push 0/imm32/no-register +22490 68/push 0/imm32/no-stack-offset +22491 68/push 1/imm32/block-depth +22492 51/push-ecx/type +22493 68/push 0x11/imm32/alloc-id:fake +22494 68/push 0/imm32/name +22495 68/push 0/imm32/name +22496 68/push 0x11/imm32/alloc-id:fake:payload +22497 89/<- %ecx 4/r32/esp +22498 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: +22499 # var-foo->name = "0x34" +22500 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +22501 (copy-array Heap "0x34" %eax) +22502 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: +22503 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +22504 68/push 0/imm32/is-deref:false +22505 68/push 0/imm32/next +22506 68/push 0/imm32/next +22507 51/push-ecx/var-foo +22508 68/push 0x11/imm32/alloc-id:fake +22509 68/push 0x11/imm32/alloc-id:fake:payload +22510 89/<- %ebx 4/r32/esp +22511 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: +22512 # var stmt/esi: (addr statement) +22513 68/push 0/imm32/no-outputs +22514 68/push 0/imm32/no-outputs +22515 53/push-ebx/inouts +22516 68/push 0x11/imm32/alloc-id:fake +22517 68/push 0/imm32/operation +22518 68/push 0/imm32/operation +22519 68/push 1/imm32/tag +22520 89/<- %esi 4/r32/esp +22521 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: +22522 # stmt->operation = "f" +22523 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +22524 (copy-array Heap "f" %eax) +22525 # convert +22526 c7 0/subop/copy *Curr-block-depth 0/imm32 +22527 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx Stderr 0) +22528 (flush _test-output-buffered-file) +22529 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- +22535 # check output +22536 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") +22537 # . epilogue +22538 89/<- %esp 5/r32/ebp +22539 5d/pop-to-ebp +22540 c3/return +22541 +22542 emit-indent: # out: (addr buffered-file), n: int +22543 # . prologue +22544 55/push-ebp +22545 89/<- %ebp 4/r32/esp +22546 # . save registers +22547 50/push-eax +22548 # var i/eax: int = n +22549 8b/-> *(ebp+0xc) 0/r32/eax +22550 { +22551 # if (i <= 0) break +22552 3d/compare-eax-with 0/imm32 +22553 7e/jump-if-<= break/disp8 +22554 (write-buffered *(ebp+8) " ") +22555 48/decrement-eax +22556 eb/jump loop/disp8 +22557 } +22558 $emit-indent:end: +22559 # . restore registers +22560 58/pop-to-eax +22561 # . epilogue +22562 89/<- %esp 5/r32/ebp +22563 5d/pop-to-ebp +22564 c3/return +22565 +22566 emit-subx-prologue: # out: (addr buffered-file) +22567 # . prologue +22568 55/push-ebp +22569 89/<- %ebp 4/r32/esp +22570 # +22571 (write-buffered *(ebp+8) " # . prologue\n") +22572 (write-buffered *(ebp+8) " 55/push-ebp\n") +22573 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") +22574 $emit-subx-prologue:end: +22575 # . epilogue +22576 89/<- %esp 5/r32/ebp +22577 5d/pop-to-ebp +22578 c3/return +22579 +22580 emit-subx-epilogue: # out: (addr buffered-file) +22581 # . prologue +22582 55/push-ebp +22583 89/<- %ebp 4/r32/esp +22584 # +22585 (write-buffered *(ebp+8) " # . epilogue\n") +22586 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") +22587 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") +22588 (write-buffered *(ebp+8) " c3/return\n") +22589 $emit-subx-epilogue:end: +22590 # . epilogue +22591 89/<- %esp 5/r32/ebp +22592 5d/pop-to-ebp +22593 c3/return -- cgit 1.4.1-2-gfad0