From 43ce7fdf594cd22e59db3ccdf331f0887ce4e35d Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Thu, 28 May 2020 22:51:10 -0700 Subject: 6425 --- html/apps/mu.subx.html | 14595 ++++++++++++++++++++++++----------------------- 1 file changed, 7301 insertions(+), 7294 deletions(-) (limited to 'html/apps/mu.subx.html') diff --git a/html/apps/mu.subx.html b/html/apps/mu.subx.html index 9378c31e..d6d57b25 100644 --- a/html/apps/mu.subx.html +++ b/html/apps/mu.subx.html @@ -548,7 +548,7 @@ if ('onhashchange' in window) { 486 (populate-mu-type-sizes) 487 #? (dump-typeinfos "=== typeinfos\n") 488 (check-mu-types) - 489 (emit-subx *(ebp+0xc)) + 489 (emit-subx *(ebp+0xc)) 490 $convert-mu:end: 491 # . epilogue 492 89/<- %esp 5/r32/ebp @@ -589,7 +589,7 @@ if ('onhashchange' in window) { 527 # convert 528 (convert-mu _test-input-buffered-file _test-output-buffered-file) 529 (flush _test-output-buffered-file) - 530 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 530 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 536 # check output 537 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-skeleton/0") 538 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-skeleton/1") @@ -621,7 +621,7 @@ if ('onhashchange' in window) { 564 # convert 565 (convert-mu _test-input-buffered-file _test-output-buffered-file) 566 (flush _test-output-buffered-file) - 567 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 567 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 573 # check first function 574 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-multiple-function-skeletons/0") 575 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-multiple-function-skeletons/1") @@ -660,7 +660,7 @@ if ('onhashchange' in window) { 608 # convert 609 (convert-mu _test-input-buffered-file _test-output-buffered-file) 610 (flush _test-output-buffered-file) - 611 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 611 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 617 # check output 618 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg/0") 619 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg/1") @@ -691,7 +691,7 @@ if ('onhashchange' in window) { 644 # convert 645 (convert-mu _test-input-buffered-file _test-output-buffered-file) 646 (flush _test-output-buffered-file) - 647 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 647 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 653 # check output 654 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg-and-body/0") 655 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg-and-body/1") @@ -727,7 +727,7 @@ if ('onhashchange' in window) { 685 # convert 686 (convert-mu _test-input-buffered-file _test-output-buffered-file) 687 (flush _test-output-buffered-file) - 688 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 688 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 694 # check output 695 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-distinguishes-args/0") 696 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-distinguishes-args/1") @@ -764,7 +764,7 @@ if ('onhashchange' in window) { 727 # convert 728 (convert-mu _test-input-buffered-file _test-output-buffered-file) 729 (flush _test-output-buffered-file) - 730 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 730 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 736 # check output 737 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-returns-result/0") 738 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-returns-result/1") @@ -802,7 +802,7 @@ if ('onhashchange' in window) { 770 # convert 771 (convert-mu _test-input-buffered-file _test-output-buffered-file) 772 (flush _test-output-buffered-file) - 773 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 773 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 779 # check output 780 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg/0") 781 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg/1") @@ -840,7 +840,7 @@ if ('onhashchange' in window) { 813 # convert 814 (convert-mu _test-input-buffered-file _test-output-buffered-file) 815 (flush _test-output-buffered-file) - 816 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 816 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 822 # check output 823 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg-2/0") 824 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg-2/1") @@ -881,7 +881,7 @@ if ('onhashchange' in window) { 859 # convert 860 (convert-mu _test-input-buffered-file _test-output-buffered-file) 861 (flush _test-output-buffered-file) - 862 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 862 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 868 # check output 869 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-literal-arg/0") 870 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/1") @@ -932,7 +932,7 @@ if ('onhashchange' in window) { 915 # convert 916 (convert-mu _test-input-buffered-file _test-output-buffered-file) 917 (flush _test-output-buffered-file) - 918 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 918 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 924 # check output 925 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem/0") 926 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem/1") @@ -971,7 +971,7 @@ if ('onhashchange' in window) { 959 # convert 960 (convert-mu _test-input-buffered-file _test-output-buffered-file) 961 (flush _test-output-buffered-file) - 962 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 962 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 968 # check output 969 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/0") 970 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/1") @@ -1010,7 +1010,7 @@ if ('onhashchange' in window) { 1003 # convert 1004 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1005 (flush _test-output-buffered-file) - 1006 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1006 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1012 # check output 1013 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-reg/0") 1014 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-reg/1") @@ -1051,7 +1051,7 @@ if ('onhashchange' in window) { 1049 # convert 1050 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1051 (flush _test-output-buffered-file) - 1052 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1052 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1058 # check output 1059 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-second-local-var-in-same-reg/0") 1060 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-second-local-var-in-same-reg/1") @@ -1092,7 +1092,7 @@ if ('onhashchange' in window) { 1095 # convert 1096 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1097 (flush _test-output-buffered-file) - 1098 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1098 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1104 # check output 1105 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") 1106 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") @@ -1132,7 +1132,7 @@ if ('onhashchange' in window) { 1140 # convert 1141 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1142 (flush _test-output-buffered-file) - 1143 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1143 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1149 # check output 1150 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") 1151 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") @@ -1174,7 +1174,7 @@ if ('onhashchange' in window) { 1187 # convert 1188 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1189 (flush _test-output-buffered-file) - 1190 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1190 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1196 # check output 1197 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") 1198 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") @@ -1219,7 +1219,7 @@ if ('onhashchange' in window) { 1237 # convert 1238 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1239 (flush _test-output-buffered-file) - 1240 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1240 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1246 # check output 1247 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") 1248 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") @@ -1261,7 +1261,7 @@ if ('onhashchange' in window) { 1284 # convert 1285 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1286 (flush _test-output-buffered-file) - 1287 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1287 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1293 # check output 1294 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") 1295 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") @@ -1302,7 +1302,7 @@ if ('onhashchange' in window) { 1330 # convert 1331 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1332 (flush _test-output-buffered-file) - 1333 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1333 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1339 # check output 1340 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-clobber-dead-local/0") 1341 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-clobber-dead-local/1") @@ -1349,7 +1349,7 @@ if ('onhashchange' in window) { 1382 # convert 1383 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1384 (flush _test-output-buffered-file) - 1385 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1385 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1391 # check output 1392 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-local/0") 1393 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-local/1") @@ -1397,7 +1397,7 @@ if ('onhashchange' in window) { 1435 # convert 1436 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1437 (flush _test-output-buffered-file) - 1438 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1438 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1444 # check output 1445 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") 1446 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") @@ -1439,7 +1439,7 @@ if ('onhashchange' in window) { 1482 # convert 1483 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1484 (flush _test-output-buffered-file) - 1485 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1485 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1491 # check output 1492 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") 1493 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") @@ -1485,7 +1485,7 @@ if ('onhashchange' in window) { 1533 # convert 1534 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1535 (flush _test-output-buffered-file) - 1536 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1536 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1542 # check output 1543 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-live-output/0") 1544 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-live-output/1") @@ -1531,7 +1531,7 @@ if ('onhashchange' in window) { 1584 # convert 1585 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1586 (flush _test-output-buffered-file) - 1587 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1587 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1593 # check output 1594 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-local-clobbered-by-output/0") 1595 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-local-clobbered-by-output/1") @@ -1573,7 +1573,7 @@ if ('onhashchange' in window) { 1631 # convert 1632 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1633 (flush _test-output-buffered-file) - 1634 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1634 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1640 # check output 1641 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") 1642 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") @@ -1621,7 +1621,7 @@ if ('onhashchange' in window) { 1684 # convert 1685 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1686 (flush _test-output-buffered-file) - 1687 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1687 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1693 # check output 1694 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") 1695 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") @@ -1669,7 +1669,7 @@ if ('onhashchange' in window) { 1737 # convert 1738 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1739 (flush _test-output-buffered-file) - 1740 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1740 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1746 # check output 1747 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") 1748 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") @@ -1721,7 +1721,7 @@ if ('onhashchange' in window) { 1794 # convert 1795 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1796 (flush _test-output-buffered-file) - 1797 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1797 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1803 # check output 1804 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") 1805 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") @@ -1777,7 +1777,7 @@ if ('onhashchange' in window) { 1855 # convert 1856 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1857 (flush _test-output-buffered-file) - 1858 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1858 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1864 # check output 1865 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") 1866 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") @@ -1831,7 +1831,7 @@ if ('onhashchange' in window) { 1914 # convert 1915 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1916 (flush _test-output-buffered-file) - 1917 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1917 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1923 # check output 1924 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") 1925 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") @@ -1885,7 +1885,7 @@ if ('onhashchange' in window) { 1973 # convert 1974 (convert-mu _test-input-buffered-file _test-output-buffered-file) 1975 (flush _test-output-buffered-file) - 1976 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 1976 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1982 # check output 1983 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") 1984 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") @@ -1933,7 +1933,7 @@ if ('onhashchange' in window) { 2026 # convert 2027 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2028 (flush _test-output-buffered-file) - 2029 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2029 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2035 # check output 2036 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") 2037 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") @@ -1989,7 +1989,7 @@ if ('onhashchange' in window) { 2087 # convert 2088 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2089 (flush _test-output-buffered-file) - 2090 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2090 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2096 # check output 2097 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") 2098 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") @@ -2051,7 +2051,7 @@ if ('onhashchange' in window) { 2154 # convert 2155 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2156 (flush _test-output-buffered-file) - 2157 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2157 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2163 # check output 2164 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") 2165 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") @@ -2107,7 +2107,7 @@ if ('onhashchange' in window) { 2215 # convert 2216 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2217 (flush _test-output-buffered-file) - 2218 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2218 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2224 # check output 2225 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") 2226 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") @@ -2161,7 +2161,7 @@ if ('onhashchange' in window) { 2274 # convert 2275 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2276 (flush _test-output-buffered-file) - 2277 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2277 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2283 # check output 2284 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") 2285 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") @@ -2210,7 +2210,7 @@ if ('onhashchange' in window) { 2328 # convert 2329 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2330 (flush _test-output-buffered-file) - 2331 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2331 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2337 # check output 2338 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") 2339 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") @@ -2252,7 +2252,7 @@ if ('onhashchange' in window) { 2375 # convert 2376 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2377 (flush _test-output-buffered-file) - 2378 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2378 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2384 # check output 2385 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") 2386 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") @@ -2293,7 +2293,7 @@ if ('onhashchange' in window) { 2421 # convert 2422 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2423 (flush _test-output-buffered-file) - 2424 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2424 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2430 # check output 2431 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") 2432 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") @@ -2334,7 +2334,7 @@ if ('onhashchange' in window) { 2467 # convert 2468 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2469 (flush _test-output-buffered-file) - 2470 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2470 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2476 # check output 2477 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") 2478 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") @@ -2379,7 +2379,7 @@ if ('onhashchange' in window) { 2517 # convert 2518 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2519 (flush _test-output-buffered-file) - 2520 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2520 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2526 # check output 2527 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") 2528 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") @@ -2422,7 +2422,7 @@ if ('onhashchange' in window) { 2565 # convert 2566 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2567 (flush _test-output-buffered-file) - 2568 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2568 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2574 # check output 2575 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") 2576 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") @@ -2464,7 +2464,7 @@ if ('onhashchange' in window) { 2612 # convert 2613 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2614 (flush _test-output-buffered-file) - 2615 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2615 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2621 # check output 2622 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") 2623 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") @@ -2513,7 +2513,7 @@ if ('onhashchange' in window) { 2666 # convert 2667 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2668 (flush _test-output-buffered-file) - 2669 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2669 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2675 # check output 2676 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") 2677 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") @@ -2563,7 +2563,7 @@ if ('onhashchange' in window) { 2721 # convert 2722 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2723 (flush _test-output-buffered-file) - 2724 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2724 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2730 # check output 2731 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") 2732 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") @@ -2609,7 +2609,7 @@ if ('onhashchange' in window) { 2772 # convert 2773 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2774 (flush _test-output-buffered-file) - 2775 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2775 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2781 # check output 2782 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") 2783 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") @@ -2659,7 +2659,7 @@ if ('onhashchange' in window) { 2827 # convert 2828 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2829 (flush _test-output-buffered-file) - 2830 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2830 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2836 # check output 2837 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") 2838 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") @@ -2705,7 +2705,7 @@ if ('onhashchange' in window) { 2878 # convert 2879 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2880 (flush _test-output-buffered-file) - 2881 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2881 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2887 # check output 2888 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") 2889 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") @@ -2750,7 +2750,7 @@ if ('onhashchange' in window) { 2928 # convert 2929 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2930 (flush _test-output-buffered-file) - 2931 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2931 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2937 # check output 2938 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") 2939 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") @@ -2807,7 +2807,7 @@ if ('onhashchange' in window) { 2990 # convert 2991 (convert-mu _test-input-buffered-file _test-output-buffered-file) 2992 (flush _test-output-buffered-file) - 2993 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 2993 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2999 # check output 3000 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") 3001 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") @@ -2869,7 +2869,7 @@ if ('onhashchange' in window) { 3057 # convert 3058 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3059 (flush _test-output-buffered-file) - 3060 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3060 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3066 # check output 3067 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") 3068 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") @@ -2936,7 +2936,7 @@ if ('onhashchange' in window) { 3129 # convert 3130 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3131 (flush _test-output-buffered-file) - 3132 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3132 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3138 # check output 3139 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") 3140 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") @@ -2986,7 +2986,7 @@ if ('onhashchange' in window) { 3184 # convert 3185 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3186 (flush _test-output-buffered-file) - 3187 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3187 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3193 # check output 3194 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") 3195 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") @@ -3031,7 +3031,7 @@ if ('onhashchange' in window) { 3234 # convert 3235 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3236 (flush _test-output-buffered-file) - 3237 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3237 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3243 # check output 3244 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") 3245 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") @@ -3078,7 +3078,7 @@ if ('onhashchange' in window) { 3286 # convert 3287 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3288 (flush _test-output-buffered-file) - 3289 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3289 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3295 # check output 3296 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") 3297 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") @@ -3126,7 +3126,7 @@ if ('onhashchange' in window) { 3339 # convert 3340 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3341 (flush _test-output-buffered-file) - 3342 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3342 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3348 # check output 3349 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") 3350 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") @@ -3182,7 +3182,7 @@ if ('onhashchange' in window) { 3400 # convert 3401 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3402 (flush _test-output-buffered-file) - 3403 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3403 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3409 # check output 3410 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") 3411 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") @@ -3243,7 +3243,7 @@ if ('onhashchange' in window) { 3466 # convert 3467 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3468 (flush _test-output-buffered-file) - 3469 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3469 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3475 # check output 3476 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") 3477 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") @@ -3304,7 +3304,7 @@ if ('onhashchange' in window) { 3532 # convert 3533 (convert-mu _test-input-buffered-file _test-output-buffered-file) 3534 (flush _test-output-buffered-file) - 3535 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- + 3535 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3541 # check output 3542 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") 3543 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") @@ -3409,7 +3409,7 @@ if ('onhashchange' in window) { 3642 # if (line->write == 0) break 3643 81 7/subop/compare *ecx 0/imm32 3644 0f 84/jump-if-= break/disp32 - 3645 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ + 3645 +-- 6 lines: #? # dump line ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3651 (next-mu-token %ecx %edx) 3652 # if slice-empty?(word-slice) continue 3653 (slice-empty? %edx) # => eax @@ -3735,7 +3735,7 @@ if ('onhashchange' in window) { 3973 # var result/ecx: function 3974 2b/subtract *Function-size 4/r32/esp 3975 89/<- %ecx 4/r32/esp - 3976 (zero-out %ecx *Function-size) + 3976 (zero-out %ecx *Function-size) 3977 # var vars/ebx: (stack (handle var) 16) 3978 81 5/subop/subtract %esp 0x80/imm32 3979 68/push 0x80/imm32/size @@ -3773,7 +3773,7 @@ if ('onhashchange' in window) { 4011 # result/ecx: function 4012 2b/subtract *Function-size 4/r32/esp 4013 89/<- %ecx 4/r32/esp - 4014 (zero-out %ecx *Function-size) + 4014 (zero-out %ecx *Function-size) 4015 # var vars/ebx: (stack (handle var) 16) 4016 81 5/subop/subtract %esp 0x80/imm32 4017 68/push 0x80/imm32/size @@ -3844,7 +3844,7 @@ if ('onhashchange' in window) { 4082 # result/ecx: function 4083 2b/subtract *Function-size 4/r32/esp 4084 89/<- %ecx 4/r32/esp - 4085 (zero-out %ecx *Function-size) + 4085 (zero-out %ecx *Function-size) 4086 # var vars/ebx: (stack (handle var) 16) 4087 81 5/subop/subtract %esp 0x80/imm32 4088 68/push 0x80/imm32/size @@ -4070,7 +4070,7 @@ if ('onhashchange' in window) { 4308 51/push-ecx 4309 52/push-edx 4310 # clear out - 4311 (zero-out *(ebp+0x10) *Handle-size) + 4311 (zero-out *(ebp+0x10) *Handle-size) 4312 # var s/ecx: slice 4313 68/push 0/imm32 4314 68/push 0/imm32 @@ -4180,7 +4180,7 @@ if ('onhashchange' in window) { 4418 51/push-ecx 4419 52/push-edx 4420 # - 4421 (zero-out *(ebp+0x10) *Handle-size) + 4421 (zero-out *(ebp+0x10) *Handle-size) 4422 # var tmp/ecx: (handle tree type-id) 4423 68/push 0/imm32 4424 68/push 0/imm32 @@ -5947,7 +5947,7 @@ if ('onhashchange' in window) { 6185 53/push-ebx 6186 56/push-esi 6187 # clear out - 6188 (zero-out *(ebp+0x10) *Handle-size) + 6188 (zero-out *(ebp+0x10) *Handle-size) 6189 # esi = vars 6190 8b/-> *(ebp+0xc) 6/r32/esi 6191 # ebx = vars->top @@ -6115,7 +6115,7 @@ if ('onhashchange' in window) { 6353 68/push 0/imm32 6354 89/<- %eax 4/r32/esp 6355 # v = new var("n") - 6356 (copy-array Heap "n" %eax) + 6356 (copy-array Heap "n" %eax) 6357 (new-var Heap *eax *(eax+4) %edx) 6358 # 6359 (push %ecx *edx) @@ -6170,7 +6170,7 @@ if ('onhashchange' in window) { 6408 68/push 0/imm32 6409 89/<- %eax 4/r32/esp 6410 # v = new var("n") - 6411 (copy-array Heap "n" %eax) + 6411 (copy-array Heap "n" %eax) 6412 (new-var Heap *eax *(eax+4) %edx) 6413 # 6414 (push %ecx *edx) @@ -6751,7 +6751,7 @@ if ('onhashchange' in window) { 6989 68/push 0/imm32 6990 68/push 0/imm32 6991 89/<- %eax 4/r32/esp - 6992 (copy-array Heap "field" %eax) + 6992 (copy-array Heap "field" %eax) 6993 # . new var 6994 8d/copy-address *(edi+0xc) 2/r32/edx 6995 (new-var Heap *eax *(eax+4) %edx) @@ -6907,7 +6907,7 @@ if ('onhashchange' in window) { 7145 # if (line->write == 0) abort 7146 81 7/subop/compare *ecx 0/imm32 7147 0f 84/jump-if-= $populate-mu-type:abort/disp32 - 7148 +-- 6 lines: #? # dump line ------------------------------------------------------------------------------------------------------------------------------------------------------ + 7148 +-- 6 lines: #? # dump line ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 7154 (next-mu-token %ecx %edx) 7155 # if slice-empty?(word-slice) continue 7156 (slice-empty? %edx) # => eax @@ -7700,7462 +7700,7469 @@ if ('onhashchange' in window) { 7943 89/<- %ecx 4/r32/esp 7944 # eax = t 7945 8b/-> *(ebp+8) 0/r32/eax - 7946 # if v is a literal, return 0 + 7946 # if t is a literal, return 0 7947 3d/compare-eax-and 0/imm32 7948 74/jump-if-= $size-of-type-id:end/disp8 # eax changes type from type-id to int - 7949 # if v has a user-defined type, return its size - 7950 # TODO: support non-atom type - 7951 (find-typeinfo %eax %ecx) - 7952 { - 7953 81 7/subop/compare *ecx 0/imm32 - 7954 74/jump-if-= break/disp8 - 7955 $size-of-type-id:user-defined: - 7956 (lookup *ecx *(ecx+4)) # => eax - 7957 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes - 7958 eb/jump $size-of-type-id:end/disp8 - 7959 } - 7960 # otherwise return the word size - 7961 b8/copy-to-eax 4/imm32 - 7962 $size-of-type-id:end: - 7963 # . reclaim locals - 7964 81 0/subop/add %esp 8/imm32 - 7965 # . restore registers - 7966 59/pop-to-ecx - 7967 # . epilogue - 7968 89/<- %esp 5/r32/ebp - 7969 5d/pop-to-ebp - 7970 c3/return - 7971 - 7972 type-equal?: # a: (addr tree type-id), b: (addr tree type-id) -> result/eax: boolean - 7973 # . prologue - 7974 55/push-ebp - 7975 89/<- %ebp 4/r32/esp - 7976 # . save registers - 7977 51/push-ecx - 7978 52/push-edx - 7979 # ecx = a - 7980 8b/-> *(ebp+8) 1/r32/ecx - 7981 # edx = b - 7982 8b/-> *(ebp+0xc) 2/r32/edx - 7983 # if (a == b) return true - 7984 8b/-> %ecx 0/r32/eax # Var-type - 7985 39/compare %edx 0/r32/eax # Var-type - 7986 b8/copy-to-eax 1/imm32/true - 7987 74/jump-if-= $type-equal?:end/disp8 - 7988 # if (a < MAX_TYPE_ID) return false - 7989 81 7/subop/compare %ecx 0x10000/imm32 - 7990 b8/copy-to-eax 0/imm32/false - 7991 72/jump-if-addr< $type-equal?:end/disp8 - 7992 # if (b < MAX_TYPE_ID) return false - 7993 81 7/subop/compare %edx 0x10000/imm32 - 7994 b8/copy-to-eax 0/imm32/false - 7995 72/jump-if-addr< $type-equal?:end/disp8 - 7996 # if (!type-equal?(a->left, b->left)) return false - 7997 (type-equal? *(ecx+4) *(edx+4)) # Tree-left, Tree-left => eax - 7998 3d/compare-eax-and 0/imm32/false - 7999 74/jump-if-= $type-equal?:end/disp8 - 8000 # return type-equal?(a->right, b->right) - 8001 (type-equal? *(ecx+8) *(edx+8)) # Tree-right, Tree-right => eax - 8002 $type-equal?:end: - 8003 # . restore registers - 8004 5a/pop-to-edx - 8005 59/pop-to-ecx - 8006 # . epilogue - 8007 89/<- %esp 5/r32/ebp - 8008 5d/pop-to-ebp - 8009 c3/return - 8010 - 8011 ####################################################### - 8012 # Code-generation - 8013 ####################################################### - 8014 - 8015 == data - 8016 - 8017 Curr-block-depth: # (addr int) - 8018 0/imm32 - 8019 Curr-local-stack-offset: # (addr int) - 8020 0/imm32 + 7949 # if t is a handle, return 8 + 7950 3d/compare-eax-and 4/imm32/handle + 7951 { + 7952 75/jump-if-!= break/disp8 + 7953 b8/copy-to-eax 8/imm32 + 7954 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int + 7955 } + 7956 # if t is a user-defined type, return its size + 7957 # TODO: support non-atom type + 7958 (find-typeinfo %eax %ecx) + 7959 { + 7960 81 7/subop/compare *ecx 0/imm32 + 7961 74/jump-if-= break/disp8 + 7962 $size-of-type-id:user-defined: + 7963 (lookup *ecx *(ecx+4)) # => eax + 7964 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes + 7965 eb/jump $size-of-type-id:end/disp8 + 7966 } + 7967 # otherwise return the word size + 7968 b8/copy-to-eax 4/imm32 + 7969 $size-of-type-id:end: + 7970 # . reclaim locals + 7971 81 0/subop/add %esp 8/imm32 + 7972 # . restore registers + 7973 59/pop-to-ecx + 7974 # . epilogue + 7975 89/<- %esp 5/r32/ebp + 7976 5d/pop-to-ebp + 7977 c3/return + 7978 + 7979 type-equal?: # a: (addr tree type-id), b: (addr tree type-id) -> result/eax: boolean + 7980 # . prologue + 7981 55/push-ebp + 7982 89/<- %ebp 4/r32/esp + 7983 # . save registers + 7984 51/push-ecx + 7985 52/push-edx + 7986 # ecx = a + 7987 8b/-> *(ebp+8) 1/r32/ecx + 7988 # edx = b + 7989 8b/-> *(ebp+0xc) 2/r32/edx + 7990 # if (a == b) return true + 7991 8b/-> %ecx 0/r32/eax # Var-type + 7992 39/compare %edx 0/r32/eax # Var-type + 7993 b8/copy-to-eax 1/imm32/true + 7994 74/jump-if-= $type-equal?:end/disp8 + 7995 # if (a < MAX_TYPE_ID) return false + 7996 81 7/subop/compare %ecx 0x10000/imm32 + 7997 b8/copy-to-eax 0/imm32/false + 7998 72/jump-if-addr< $type-equal?:end/disp8 + 7999 # if (b < MAX_TYPE_ID) return false + 8000 81 7/subop/compare %edx 0x10000/imm32 + 8001 b8/copy-to-eax 0/imm32/false + 8002 72/jump-if-addr< $type-equal?:end/disp8 + 8003 # if (!type-equal?(a->left, b->left)) return false + 8004 (type-equal? *(ecx+4) *(edx+4)) # Tree-left, Tree-left => eax + 8005 3d/compare-eax-and 0/imm32/false + 8006 74/jump-if-= $type-equal?:end/disp8 + 8007 # return type-equal?(a->right, b->right) + 8008 (type-equal? *(ecx+8) *(edx+8)) # Tree-right, Tree-right => eax + 8009 $type-equal?:end: + 8010 # . restore registers + 8011 5a/pop-to-edx + 8012 59/pop-to-ecx + 8013 # . epilogue + 8014 89/<- %esp 5/r32/ebp + 8015 5d/pop-to-ebp + 8016 c3/return + 8017 + 8018 ####################################################### + 8019 # Code-generation + 8020 ####################################################### 8021 - 8022 == code + 8022 == data 8023 - 8024 emit-subx: # out: (addr buffered-file) - 8025 # . prologue - 8026 55/push-ebp - 8027 89/<- %ebp 4/r32/esp - 8028 # . save registers - 8029 50/push-eax - 8030 # var curr/eax: (addr function) = *Program->functions - 8031 (lookup *_Program-functions *_Program-functions->payload) # => eax - 8032 { - 8033 # if (curr == null) break - 8034 3d/compare-eax-and 0/imm32 - 8035 0f 84/jump-if-= break/disp32 - 8036 (emit-subx-function *(ebp+8) %eax) - 8037 # curr = lookup(curr->next) - 8038 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax - 8039 e9/jump loop/disp32 - 8040 } - 8041 $emit-subx:end: - 8042 # . restore registers - 8043 58/pop-to-eax - 8044 # . epilogue - 8045 89/<- %esp 5/r32/ebp - 8046 5d/pop-to-ebp - 8047 c3/return - 8048 - 8049 emit-subx-function: # out: (addr buffered-file), f: (addr function) - 8050 # . prologue - 8051 55/push-ebp - 8052 89/<- %ebp 4/r32/esp - 8053 # some preprocessing - 8054 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) - 8055 # . save registers - 8056 50/push-eax - 8057 51/push-ecx - 8058 52/push-edx - 8059 57/push-edi - 8060 # edi = out - 8061 8b/-> *(ebp+8) 7/r32/edi - 8062 # ecx = f - 8063 8b/-> *(ebp+0xc) 1/r32/ecx - 8064 # var vars/edx: (stack (addr var) 256) - 8065 81 5/subop/subtract %esp 0x800/imm32 - 8066 68/push 0x800/imm32/size - 8067 68/push 0/imm32/top - 8068 89/<- %edx 4/r32/esp - 8069 # - 8070 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax - 8071 (write-buffered %edi %eax) - 8072 (write-buffered %edi ":\n") - 8073 # initialize some global state - 8074 c7 0/subop/copy *Curr-block-depth 1/imm32 - 8075 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 + 8024 Curr-block-depth: # (addr int) + 8025 0/imm32 + 8026 Curr-local-stack-offset: # (addr int) + 8027 0/imm32 + 8028 + 8029 == code + 8030 + 8031 emit-subx: # out: (addr buffered-file) + 8032 # . prologue + 8033 55/push-ebp + 8034 89/<- %ebp 4/r32/esp + 8035 # . save registers + 8036 50/push-eax + 8037 # var curr/eax: (addr function) = *Program->functions + 8038 (lookup *_Program-functions *_Program-functions->payload) # => eax + 8039 { + 8040 # if (curr == null) break + 8041 3d/compare-eax-and 0/imm32 + 8042 0f 84/jump-if-= break/disp32 + 8043 (emit-subx-function *(ebp+8) %eax) + 8044 # curr = lookup(curr->next) + 8045 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax + 8046 e9/jump loop/disp32 + 8047 } + 8048 $emit-subx:end: + 8049 # . restore registers + 8050 58/pop-to-eax + 8051 # . epilogue + 8052 89/<- %esp 5/r32/ebp + 8053 5d/pop-to-ebp + 8054 c3/return + 8055 + 8056 emit-subx-function: # out: (addr buffered-file), f: (addr function) + 8057 # . prologue + 8058 55/push-ebp + 8059 89/<- %ebp 4/r32/esp + 8060 # some preprocessing + 8061 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) + 8062 # . save registers + 8063 50/push-eax + 8064 51/push-ecx + 8065 52/push-edx + 8066 57/push-edi + 8067 # edi = out + 8068 8b/-> *(ebp+8) 7/r32/edi + 8069 # ecx = f + 8070 8b/-> *(ebp+0xc) 1/r32/ecx + 8071 # var vars/edx: (stack (addr var) 256) + 8072 81 5/subop/subtract %esp 0x800/imm32 + 8073 68/push 0x800/imm32/size + 8074 68/push 0/imm32/top + 8075 89/<- %edx 4/r32/esp 8076 # - 8077 (emit-subx-prologue %edi) - 8078 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax - 8079 (emit-subx-block %edi %eax %edx) - 8080 (emit-subx-epilogue %edi) - 8081 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have - 8082 # been cleaned up - 8083 $emit-subx-function:end: - 8084 # . reclaim locals - 8085 81 0/subop/add %esp 808/imm32 - 8086 # . restore registers - 8087 5f/pop-to-edi - 8088 5a/pop-to-edx - 8089 59/pop-to-ecx - 8090 58/pop-to-eax - 8091 # . epilogue - 8092 89/<- %esp 5/r32/ebp - 8093 5d/pop-to-ebp - 8094 c3/return - 8095 - 8096 populate-mu-type-offsets-in-inouts: # f: (addr function) - 8097 # . prologue - 8098 55/push-ebp - 8099 89/<- %ebp 4/r32/esp - 8100 # . save registers - 8101 50/push-eax - 8102 51/push-ecx - 8103 52/push-edx - 8104 53/push-ebx - 8105 57/push-edi - 8106 # var next-offset/edx: int = 8 - 8107 ba/copy-to-edx 8/imm32 - 8108 # var curr/ecx: (addr list var) = lookup(f->inouts) - 8109 8b/-> *(ebp+8) 1/r32/ecx - 8110 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax - 8111 89/<- %ecx 0/r32/eax - 8112 { - 8113 $populate-mu-type-offsets-in-inouts:loop: - 8114 81 7/subop/compare %ecx 0/imm32 - 8115 74/jump-if-= break/disp8 - 8116 # var v/ebx: (addr var) = lookup(curr->value) - 8117 (lookup *ecx *(ecx+4)) # List-value List-value => eax - 8118 89/<- %ebx 0/r32/eax - 8119 #? (lookup *ebx *(ebx+4)) - 8120 #? (write-buffered Stderr "setting offset of fn inout ") - 8121 #? (write-buffered Stderr %eax) - 8122 #? (write-buffered Stderr "@") - 8123 #? (print-int32-buffered Stderr %ebx) - 8124 #? (write-buffered Stderr " to ") - 8125 #? (print-int32-buffered Stderr %edx) - 8126 #? (write-buffered Stderr Newline) - 8127 #? (flush Stderr) - 8128 # v->offset = next-offset - 8129 89/<- *(ebx+0x14) 2/r32/edx # Var-offset - 8130 # next-offset += size-of(v) - 8131 (size-of %ebx) # => eax - 8132 01/add-to %edx 0/r32/eax - 8133 # curr = lookup(curr->next) - 8134 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax - 8135 89/<- %ecx 0/r32/eax - 8136 # - 8137 eb/jump loop/disp8 - 8138 } - 8139 $populate-mu-type-offsets-in-inouts:end: - 8140 # . restore registers - 8141 5f/pop-to-edi - 8142 5b/pop-to-ebx - 8143 5a/pop-to-edx - 8144 59/pop-to-ecx - 8145 58/pop-to-eax - 8146 # . epilogue - 8147 89/<- %esp 5/r32/ebp - 8148 5d/pop-to-ebp - 8149 c3/return - 8150 - 8151 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack (handle var)) - 8152 # . prologue - 8153 55/push-ebp - 8154 89/<- %ebp 4/r32/esp - 8155 # . save registers - 8156 50/push-eax - 8157 51/push-ecx - 8158 52/push-edx - 8159 53/push-ebx - 8160 56/push-esi - 8161 # esi = stmts - 8162 8b/-> *(ebp+0xc) 6/r32/esi - 8163 # var var-seen?/edx: boolean <- copy false - 8164 ba/copy-to-edx 0/imm32/false - 8165 # - 8166 { - 8167 $emit-subx-stmt-list:loop: - 8168 81 7/subop/compare %esi 0/imm32 - 8169 0f 84/jump-if-= break/disp32 - 8170 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) - 8171 (lookup *esi *(esi+4)) # List-value List-value => eax - 8172 89/<- %ecx 0/r32/eax - 8173 { - 8174 $emit-subx-stmt-list:check-for-block: - 8175 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag - 8176 75/jump-if-!= break/disp8 - 8177 $emit-subx-stmt-list:block: - 8178 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10)) - 8179 } + 8077 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax + 8078 (write-buffered %edi %eax) + 8079 (write-buffered %edi ":\n") + 8080 # initialize some global state + 8081 c7 0/subop/copy *Curr-block-depth 1/imm32 + 8082 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 + 8083 # + 8084 (emit-subx-prologue %edi) + 8085 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax + 8086 (emit-subx-block %edi %eax %edx) + 8087 (emit-subx-epilogue %edi) + 8088 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have + 8089 # been cleaned up + 8090 $emit-subx-function:end: + 8091 # . reclaim locals + 8092 81 0/subop/add %esp 808/imm32 + 8093 # . restore registers + 8094 5f/pop-to-edi + 8095 5a/pop-to-edx + 8096 59/pop-to-ecx + 8097 58/pop-to-eax + 8098 # . epilogue + 8099 89/<- %esp 5/r32/ebp + 8100 5d/pop-to-ebp + 8101 c3/return + 8102 + 8103 populate-mu-type-offsets-in-inouts: # f: (addr function) + 8104 # . prologue + 8105 55/push-ebp + 8106 89/<- %ebp 4/r32/esp + 8107 # . save registers + 8108 50/push-eax + 8109 51/push-ecx + 8110 52/push-edx + 8111 53/push-ebx + 8112 57/push-edi + 8113 # var next-offset/edx: int = 8 + 8114 ba/copy-to-edx 8/imm32 + 8115 # var curr/ecx: (addr list var) = lookup(f->inouts) + 8116 8b/-> *(ebp+8) 1/r32/ecx + 8117 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax + 8118 89/<- %ecx 0/r32/eax + 8119 { + 8120 $populate-mu-type-offsets-in-inouts:loop: + 8121 81 7/subop/compare %ecx 0/imm32 + 8122 74/jump-if-= break/disp8 + 8123 # var v/ebx: (addr var) = lookup(curr->value) + 8124 (lookup *ecx *(ecx+4)) # List-value List-value => eax + 8125 89/<- %ebx 0/r32/eax + 8126 #? (lookup *ebx *(ebx+4)) + 8127 #? (write-buffered Stderr "setting offset of fn inout ") + 8128 #? (write-buffered Stderr %eax) + 8129 #? (write-buffered Stderr "@") + 8130 #? (print-int32-buffered Stderr %ebx) + 8131 #? (write-buffered Stderr " to ") + 8132 #? (print-int32-buffered Stderr %edx) + 8133 #? (write-buffered Stderr Newline) + 8134 #? (flush Stderr) + 8135 # v->offset = next-offset + 8136 89/<- *(ebx+0x14) 2/r32/edx # Var-offset + 8137 # next-offset += size-of(v) + 8138 (size-of %ebx) # => eax + 8139 01/add-to %edx 0/r32/eax + 8140 # curr = lookup(curr->next) + 8141 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax + 8142 89/<- %ecx 0/r32/eax + 8143 # + 8144 eb/jump loop/disp8 + 8145 } + 8146 $populate-mu-type-offsets-in-inouts:end: + 8147 # . restore registers + 8148 5f/pop-to-edi + 8149 5b/pop-to-ebx + 8150 5a/pop-to-edx + 8151 59/pop-to-ecx + 8152 58/pop-to-eax + 8153 # . epilogue + 8154 89/<- %esp 5/r32/ebp + 8155 5d/pop-to-ebp + 8156 c3/return + 8157 + 8158 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack (handle var)) + 8159 # . prologue + 8160 55/push-ebp + 8161 89/<- %ebp 4/r32/esp + 8162 # . save registers + 8163 50/push-eax + 8164 51/push-ecx + 8165 52/push-edx + 8166 53/push-ebx + 8167 56/push-esi + 8168 # esi = stmts + 8169 8b/-> *(ebp+0xc) 6/r32/esi + 8170 # var var-seen?/edx: boolean <- copy false + 8171 ba/copy-to-edx 0/imm32/false + 8172 # + 8173 { + 8174 $emit-subx-stmt-list:loop: + 8175 81 7/subop/compare %esi 0/imm32 + 8176 0f 84/jump-if-= break/disp32 + 8177 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) + 8178 (lookup *esi *(esi+4)) # List-value List-value => eax + 8179 89/<- %ecx 0/r32/eax 8180 { - 8181 $emit-subx-stmt-list:check-for-stmt: - 8182 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag - 8183 0f 85/jump-if-!= break/disp32 - 8184 $emit-subx-stmt-list:stmt1: - 8185 { - 8186 (is-mu-branch? %ecx) # => eax - 8187 3d/compare-eax-and 0/imm32/false - 8188 0f 84/jump-if-= break/disp32 - 8189 $emit-subx-stmt-list:branch-stmt: - 8190 # if !var-seen? break - 8191 81 7/subop/compare %edx 0/imm32/false - 8192 0f 84/jump-if-= break/disp32 - 8193 $emit-subx-stmt-list:branch-stmt-and-var-seen: - 8194 +-- 27 lines: # unconditional loops ----------------------------------------------------------------------------------------------------------------------------------------------------- - 8221 +-- 16 lines: # unconditional breaks ---------------------------------------------------------------------------------------------------------------------------------------------------- - 8237 +-- 38 lines: # simple conditional branches without a target ---------------------------------------------------------------------------------------------------------------------------- - 8275 +-- 19 lines: # conditional branches with an explicit target ---------------------------------------------------------------------------------------------------------------------------- - 8294 } - 8295 $emit-subx-stmt-list:1-to-1: - 8296 (emit-subx-stmt *(ebp+8) %ecx Primitives) - 8297 e9/jump $emit-subx-stmt-list:continue/disp32 - 8298 } - 8299 { - 8300 $emit-subx-stmt-list:check-for-var-def: - 8301 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag - 8302 75/jump-if-!= break/disp8 - 8303 $emit-subx-stmt-list:var-def: - 8304 (emit-subx-var-def *(ebp+8) %ecx) - 8305 (push *(ebp+0x10) *(ecx+4)) # Vardef-var - 8306 (push *(ebp+0x10) *(ecx+8)) # Vardef-var - 8307 # var-seen? = true - 8308 ba/copy-to-edx 1/imm32/true - 8309 eb/jump $emit-subx-stmt-list:continue/disp8 - 8310 } - 8311 { - 8312 $emit-subx-stmt-list:check-for-reg-var-def: - 8313 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag - 8314 0f 85/jump-if-!= break/disp32 - 8315 $emit-subx-stmt-list:reg-var-def: - 8316 # TODO: ensure that there's exactly one output - 8317 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10)) - 8318 # emit the instruction as usual - 8319 (emit-subx-stmt *(ebp+8) %ecx Primitives) - 8320 # var-seen? = true - 8321 ba/copy-to-edx 1/imm32/true - 8322 eb/jump $emit-subx-stmt-list:continue/disp8 - 8323 } - 8324 $emit-subx-stmt-list:continue: - 8325 # TODO: raise an error on unrecognized Stmt-tag - 8326 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax - 8327 89/<- %esi 0/r32/eax - 8328 e9/jump loop/disp32 - 8329 } - 8330 $emit-subx-stmt-list:emit-cleanup: - 8331 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) - 8332 $emit-subx-stmt-list:clean-up: - 8333 (clean-up-blocks *(ebp+0x10) *Curr-block-depth) - 8334 $emit-subx-stmt-list:end: - 8335 # . restore registers - 8336 5e/pop-to-esi - 8337 5b/pop-to-ebx - 8338 5a/pop-to-edx - 8339 59/pop-to-ecx - 8340 58/pop-to-eax - 8341 # . epilogue - 8342 89/<- %esp 5/r32/ebp - 8343 5d/pop-to-ebp - 8344 c3/return - 8345 - 8346 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)) - 8347 # . prologue - 8348 55/push-ebp - 8349 89/<- %ebp 4/r32/esp - 8350 # . save registers - 8351 50/push-eax - 8352 51/push-ecx - 8353 # ecx = stmt - 8354 8b/-> *(ebp+0xc) 1/r32/ecx - 8355 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) - 8356 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax - 8357 # TODO: assert !sv->is-deref? - 8358 # var v/ecx: (addr var) = lookup(sv->value) - 8359 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 8360 89/<- %ecx 0/r32/eax - 8361 # v->block-depth = *Curr-block-depth - 8362 8b/-> *Curr-block-depth 0/r32/eax - 8363 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth - 8364 #? (write-buffered Stderr "var ") - 8365 #? (lookup *ecx *(ecx+4)) - 8366 #? (write-buffered Stderr %eax) - 8367 #? (write-buffered Stderr " at depth ") - 8368 #? (print-int32-buffered Stderr *(ecx+0x10)) - 8369 #? (write-buffered Stderr Newline) - 8370 #? (flush Stderr) - 8371 # ensure that v is in a register - 8372 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register - 8373 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 - 8374 # if !already-spilled-this-block?(reg, vars) emit code to spill reg - 8375 (already-spilled-this-block? %ecx *(ebp+0x10)) # => eax - 8376 3d/compare-eax-and 0/imm32/false - 8377 75/jump-if-!= $push-output-and-maybe-emit-spill:push/disp8 - 8378 # TODO: assert(size-of(output) == 4) - 8379 # *Curr-local-stack-offset -= 4 - 8380 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 - 8381 # emit spill - 8382 (emit-indent *(ebp+8) *Curr-block-depth) - 8383 (write-buffered *(ebp+8) "ff 6/subop/push %") - 8384 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax - 8385 (write-buffered *(ebp+8) %eax) - 8386 (write-buffered *(ebp+8) Newline) - 8387 $push-output-and-maybe-emit-spill:push: - 8388 8b/-> *(ebp+0xc) 1/r32/ecx - 8389 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax - 8390 # push(vars, sv->value) - 8391 (push *(ebp+0x10) *eax) # Stmt-var-value - 8392 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value - 8393 $push-output-and-maybe-emit-spill:end: - 8394 # . restore registers - 8395 59/pop-to-ecx - 8396 58/pop-to-eax - 8397 # . epilogue - 8398 89/<- %esp 5/r32/ebp - 8399 5d/pop-to-ebp - 8400 c3/return - 8401 - 8402 $push-output-and-maybe-emit-spill:abort: - 8403 # error("var '" var->name "' initialized from an instruction must live in a register\n") - 8404 (write-buffered Stderr "var '") - 8405 (write-buffered Stderr *eax) # Var-name - 8406 (write-buffered Stderr "' initialized from an instruction must live in a register\n") - 8407 (flush Stderr) - 8408 # . syscall(exit, 1) - 8409 bb/copy-to-ebx 1/imm32 - 8410 b8/copy-to-eax 1/imm32/exit - 8411 cd/syscall 0x80/imm8 - 8412 # never gets here - 8413 - 8414 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack (handle var)) - 8415 # . prologue - 8416 55/push-ebp - 8417 89/<- %ebp 4/r32/esp - 8418 # . save registers - 8419 50/push-eax - 8420 51/push-ecx - 8421 # ecx = stmt - 8422 8b/-> *(ebp+0xc) 1/r32/ecx - 8423 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name - 8424 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 8425 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 8426 (lookup *eax *(eax+4)) # Var-name Var-name => eax - 8427 # clean up until target block - 8428 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) - 8429 # emit jump to target block - 8430 (emit-indent *(ebp+8) *Curr-block-depth) - 8431 (write-buffered *(ebp+8) "e9/jump ") - 8432 (write-buffered *(ebp+8) %eax) - 8433 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax - 8434 (string-starts-with? %eax "break") - 8435 3d/compare-eax-and 0/imm32/false - 8436 { - 8437 74/jump-if-= break/disp8 - 8438 (write-buffered *(ebp+8) ":break/disp32\n") - 8439 } - 8440 3d/compare-eax-and 0/imm32/false # just in case the function call modified flags - 8441 { - 8442 75/jump-if-!= break/disp8 - 8443 (write-buffered *(ebp+8) ":loop/disp32\n") - 8444 } - 8445 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: - 8446 # . restore registers - 8447 59/pop-to-ecx - 8448 58/pop-to-eax - 8449 # . epilogue - 8450 89/<- %esp 5/r32/ebp - 8451 5d/pop-to-ebp - 8452 c3/return - 8453 - 8454 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean - 8455 # . prologue - 8456 55/push-ebp - 8457 89/<- %ebp 4/r32/esp - 8458 # . save registers - 8459 51/push-ecx - 8460 # ecx = lookup(stmt->operation) - 8461 8b/-> *(ebp+8) 1/r32/ecx - 8462 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax - 8463 89/<- %ecx 0/r32/eax - 8464 # if (stmt->operation starts with "loop") return true - 8465 (string-starts-with? %ecx "loop") # => eax - 8466 3d/compare-eax-and 0/imm32/false - 8467 75/jump-if-not-equal $is-mu-branch?:end/disp8 - 8468 # otherwise return (stmt->operation starts with "break") - 8469 (string-starts-with? %ecx "break") # => eax - 8470 $is-mu-branch?:end: - 8471 # . restore registers - 8472 59/pop-to-ecx - 8473 # . epilogue - 8474 89/<- %esp 5/r32/ebp - 8475 5d/pop-to-ebp - 8476 c3/return - 8477 - 8478 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) - 8479 # . prologue - 8480 55/push-ebp - 8481 89/<- %ebp 4/r32/esp - 8482 # . save registers - 8483 50/push-eax - 8484 # eax = stmt - 8485 8b/-> *(ebp+0xc) 0/r32/eax - 8486 # - 8487 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax - 8488 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) - 8489 (emit-indent *(ebp+8) *Curr-block-depth) - 8490 (lookup *eax *(eax+4)) # => eax - 8491 (write-buffered *(ebp+8) %eax) - 8492 (write-buffered *(ebp+8) " break/disp32\n") - 8493 $emit-reverse-break:end: - 8494 # . restore registers - 8495 58/pop-to-eax - 8496 # . epilogue - 8497 89/<- %esp 5/r32/ebp - 8498 5d/pop-to-ebp - 8499 c3/return - 8500 - 8501 == data - 8502 - 8503 # Table from Mu branch instructions to the reverse SubX opcodes for them. - 8504 Reverse-branch: # (table (handle array byte) (handle array byte)) - 8505 # a table is a stream - 8506 0x140/imm32/write - 8507 0/imm32/read - 8508 0x140/imm32/size - 8509 # data - 8510 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 - 8511 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 - 8512 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 - 8513 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 - 8514 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 - 8515 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 - 8516 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 - 8517 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 - 8518 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 - 8519 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 - 8520 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 - 8521 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 - 8522 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 - 8523 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 - 8524 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 - 8525 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 - 8526 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 - 8527 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 - 8528 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 - 8529 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 - 8530 - 8531 == code - 8532 - 8533 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack (handle var)), depth: int, label-suffix: (addr array byte) - 8534 # . prologue - 8535 55/push-ebp - 8536 89/<- %ebp 4/r32/esp - 8537 # . save registers - 8538 50/push-eax - 8539 51/push-ecx - 8540 52/push-edx - 8541 53/push-ebx - 8542 56/push-esi - 8543 # ecx = vars - 8544 8b/-> *(ebp+0xc) 1/r32/ecx - 8545 # var eax: int = vars->top - 8546 8b/-> *ecx 0/r32/eax - 8547 # var curr/esi: (addr handle var) = &vars->data[vars->top - 8] - 8548 8d/copy-address *(ecx+eax) 6/r32/esi # vars + 8 + vars->top - 8 - 8549 # var min/ecx: (addr handle var) = vars->data - 8550 81 0/subop/add %ecx 8/imm32 - 8551 # edx = depth - 8552 8b/-> *(ebp+0x10) 2/r32/edx - 8553 { - 8554 $emit-unconditional-jump-to-depth:loop: - 8555 # if (curr < min) break - 8556 39/compare %esi 1/r32/ecx - 8557 0f 82/jump-if-addr< break/disp32 - 8558 # var v/ebx: (addr var) = lookup(*curr) - 8559 (lookup *esi *(esi+4)) # => eax - 8560 89/<- %ebx 0/r32/eax - 8561 # if (v->block-depth < until-block-depth) break - 8562 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth - 8563 0f 8c/jump-if-< break/disp32 - 8564 { - 8565 $emit-unconditional-jump-to-depth:check: - 8566 # if v->block-depth != until-block-depth, continue - 8567 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth - 8568 0f 85/jump-if-!= break/disp32 - 8569 $emit-unconditional-jump-to-depth:depth-found: - 8570 # if v is not a literal, continue - 8571 (size-of %ebx) # => eax - 8572 3d/compare-eax-and 0/imm32 - 8573 0f 85/jump-if-!= break/disp32 - 8574 $emit-unconditional-jump-to-depth:label-found: - 8575 # emit unconditional jump, then return - 8576 (emit-indent *(ebp+8) *Curr-block-depth) - 8577 (write-buffered *(ebp+8) "e9/jump ") - 8578 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 8579 (write-buffered *(ebp+8) %eax) - 8580 (write-buffered *(ebp+8) ":") - 8581 (write-buffered *(ebp+8) *(ebp+0x14)) - 8582 (write-buffered *(ebp+8) "/disp32\n") - 8583 eb/jump $emit-unconditional-jump-to-depth:end/disp8 - 8584 } - 8585 # curr -= 8 - 8586 81 5/subop/subtract %esi 8/imm32 - 8587 e9/jump loop/disp32 - 8588 } - 8589 # TODO: error if no label at 'depth' was found - 8590 $emit-unconditional-jump-to-depth:end: - 8591 # . restore registers - 8592 5e/pop-to-esi - 8593 5b/pop-to-ebx - 8594 5a/pop-to-edx - 8595 59/pop-to-ecx - 8596 58/pop-to-eax - 8597 # . epilogue - 8598 89/<- %esp 5/r32/ebp - 8599 5d/pop-to-ebp - 8600 c3/return - 8601 - 8602 # emit clean-up code for 'vars' until some block depth - 8603 # doesn't actually modify 'vars' so we need traverse manually inside the stack - 8604 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack (handle var)), until-block-depth: int - 8605 # . prologue - 8606 55/push-ebp - 8607 89/<- %ebp 4/r32/esp - 8608 # . save registers - 8609 50/push-eax - 8610 51/push-ecx - 8611 52/push-edx - 8612 53/push-ebx - 8613 56/push-esi - 8614 #? (write-buffered Stderr "--- cleanup\n") - 8615 #? (flush Stderr) - 8616 # ecx = vars - 8617 8b/-> *(ebp+0xc) 1/r32/ecx - 8618 # var esi: int = vars->top - 8619 8b/-> *ecx 6/r32/esi - 8620 # var curr/esi: (addr handle var) = &vars->data[vars->top - 8] - 8621 8d/copy-address *(ecx+esi) 6/r32/esi # vars + 8 + vars->top - 8 - 8622 # var min/ecx: (addr handle var) = vars->data - 8623 81 0/subop/add %ecx 8/imm32 - 8624 # edx = until-block-depth - 8625 8b/-> *(ebp+0x10) 2/r32/edx - 8626 { - 8627 $emit-cleanup-code-until-depth:loop: - 8628 # if (curr < min) break - 8629 39/compare %esi 1/r32/ecx - 8630 0f 82/jump-if-addr< break/disp32 - 8631 # var v/ebx: (addr var) = lookup(*curr) - 8632 (lookup *esi *(esi+4)) # => eax - 8633 89/<- %ebx 0/r32/eax - 8634 #? (lookup *ebx *(ebx+4)) # Var-name - 8635 #? (write-buffered Stderr "var ") - 8636 #? (write-buffered Stderr %eax) - 8637 #? (write-buffered Stderr Newline) - 8638 #? (flush Stderr) - 8639 # if (v->block-depth < until-block-depth) break - 8640 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth - 8641 0f 8c/jump-if-< break/disp32 - 8642 # if v is in a register - 8643 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register - 8644 { - 8645 0f 84/jump-if-= break/disp32 - 8646 { - 8647 $emit-cleanup-code-until-depth:check-for-previous-spill: - 8648 (same-register-spilled-before? %ebx *(ebp+0xc) %esi) # => eax - 8649 3d/compare-eax-and 0/imm32/false - 8650 0f 85/jump-if-!= break/disp32 - 8651 $emit-cleanup-code-until-depth:reclaim-var-in-register: - 8652 (emit-indent *(ebp+8) *Curr-block-depth) - 8653 (write-buffered *(ebp+8) "8f 0/subop/pop %") - 8654 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 8655 (write-buffered *(ebp+8) %eax) - 8656 (write-buffered *(ebp+8) Newline) - 8657 } - 8658 eb/jump $emit-cleanup-code-until-depth:continue/disp8 - 8659 } - 8660 # otherwise v is on the stack - 8661 { - 8662 75/jump-if-!= break/disp8 - 8663 $emit-cleanup-code-until-depth:var-on-stack: - 8664 (size-of %ebx) # => eax - 8665 # don't emit code for labels - 8666 3d/compare-eax-and 0/imm32 - 8667 74/jump-if-= break/disp8 - 8668 $emit-cleanup-code-until-depth:reclaim-var-on-stack: - 8669 (emit-indent *(ebp+8) *Curr-block-depth) - 8670 (write-buffered *(ebp+8) "81 0/subop/add %esp ") - 8671 (print-int32-buffered *(ebp+8) %eax) - 8672 (write-buffered *(ebp+8) "/imm32\n") - 8673 } - 8674 $emit-cleanup-code-until-depth:continue: - 8675 # curr -= 8 - 8676 81 5/subop/subtract %esi 8/imm32 - 8677 e9/jump loop/disp32 - 8678 } - 8679 $emit-cleanup-code-until-depth:end: - 8680 # . restore registers - 8681 5e/pop-to-esi - 8682 5b/pop-to-ebx - 8683 5a/pop-to-edx - 8684 59/pop-to-ecx - 8685 58/pop-to-eax - 8686 # . epilogue - 8687 89/<- %esp 5/r32/ebp - 8688 5d/pop-to-ebp - 8689 c3/return - 8690 - 8691 # emit clean-up code for 'vars' until a given label is encountered - 8692 # doesn't actually modify 'vars' so we need traverse manually inside the stack - 8693 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack (handle var)), until-block-label: (addr array byte) - 8694 # . prologue - 8695 55/push-ebp - 8696 89/<- %ebp 4/r32/esp - 8697 # . save registers - 8698 50/push-eax - 8699 51/push-ecx - 8700 52/push-edx - 8701 53/push-ebx - 8702 # ecx = vars - 8703 8b/-> *(ebp+0xc) 1/r32/ecx - 8704 # var eax: int = vars->top - 8705 8b/-> *ecx 0/r32/eax - 8706 # var curr/edx: (addr handle var) = &vars->data[vars->top - 8] - 8707 8d/copy-address *(ecx+eax) 2/r32/edx # vars + 8 + vars->top - 8 - 8708 # var min/ecx: (addr handle var) = vars->data - 8709 81 0/subop/add %ecx 8/imm32 - 8710 { - 8711 $emit-cleanup-code-until-target:loop: - 8712 # if (curr < min) break - 8713 39/compare %edx 1/r32/ecx - 8714 0f 82/jump-if-addr< break/disp32 - 8715 # var v/ebx: (handle var) = lookup(*curr) - 8716 (lookup *edx *(edx+4)) # => eax - 8717 89/<- %ebx 0/r32/eax - 8718 # if (v->name == until-block-label) break - 8719 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax - 8720 (string-equal? %eax *(ebp+0x10)) # => eax - 8721 3d/compare-eax-and 0/imm32/false - 8722 0f 85/jump-if-!= break/disp32 - 8723 # if v is in a register - 8724 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register - 8725 { - 8726 0f 84/jump-if-= break/disp32 - 8727 { - 8728 $emit-cleanup-code-until-target:check-for-previous-spill: - 8729 (same-register-spilled-before? %ebx *(ebp+0xc) %edx) # => eax - 8730 3d/compare-eax-and 0/imm32/false - 8731 75/jump-if-!= break/disp8 - 8732 $emit-cleanup-code-until-target:reclaim-var-in-register: - 8733 (emit-indent *(ebp+8) *Curr-block-depth) - 8734 (write-buffered *(ebp+8) "8f 0/subop/pop %") - 8735 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 8736 (write-buffered *(ebp+8) %eax) - 8737 (write-buffered *(ebp+8) Newline) - 8738 } - 8739 eb/jump $emit-cleanup-code-until-target:continue/disp8 - 8740 } - 8741 # otherwise v is on the stack - 8742 { - 8743 75/jump-if-!= break/disp8 - 8744 $emit-cleanup-code-until-target:reclaim-var-on-stack: - 8745 (size-of %ebx) # => eax - 8746 # don't emit code for labels - 8747 3d/compare-eax-and 0/imm32 - 8748 74/jump-if-= break/disp8 - 8749 # - 8750 (emit-indent *(ebp+8) *Curr-block-depth) - 8751 (write-buffered *(ebp+8) "81 0/subop/add %esp ") - 8752 (print-int32-buffered *(ebp+8) %eax) - 8753 (write-buffered *(ebp+8) "/imm32\n") - 8754 } - 8755 $emit-cleanup-code-until-target:continue: - 8756 # curr -= 8 - 8757 81 5/subop/subtract %edx 8/imm32 - 8758 e9/jump loop/disp32 - 8759 } - 8760 $emit-cleanup-code-until-target:end: - 8761 # . restore registers - 8762 5b/pop-to-ebx - 8763 5a/pop-to-edx - 8764 59/pop-to-ecx - 8765 58/pop-to-eax - 8766 # . epilogue - 8767 89/<- %esp 5/r32/ebp - 8768 5d/pop-to-ebp - 8769 c3/return - 8770 - 8771 # is there already a var with the same block-depth and register as 'v' on the 'vars' stack? - 8772 # v is guaranteed not to be within vars - 8773 already-spilled-this-block?: # v: (addr var), vars: (addr stack (handle var)) -> result/eax: boolean - 8774 # . prologue - 8775 55/push-ebp - 8776 89/<- %ebp 4/r32/esp - 8777 # . save registers - 8778 51/push-ecx - 8779 52/push-edx - 8780 53/push-ebx - 8781 56/push-esi - 8782 57/push-edi - 8783 # ecx = vars - 8784 8b/-> *(ebp+0xc) 1/r32/ecx - 8785 # var eax: int = vars->top - 8786 8b/-> *ecx 0/r32/eax - 8787 # var min/ecx: (addr handle var) = vars->data - 8788 81 0/subop/add %ecx 8/imm32 - 8789 # var curr/edx: (addr handle var) = &vars->data[vars->top - 8] - 8790 81 5/subop/subtract %eax 8/imm32 - 8791 8d/copy-address *(ecx+eax) 2/r32/edx - 8792 # var depth/ebx: int = v->block-depth - 8793 8b/-> *(ebp+8) 3/r32/ebx - 8794 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth - 8795 # var needle/esi: (addr array byte) = v->register - 8796 8b/-> *(ebp+8) 6/r32/esi - 8797 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax - 8798 89/<- %esi 0/r32/eax - 8799 { - 8800 $already-spilled-this-block?:loop: - 8801 # if (curr < min) break - 8802 39/compare %edx 1/r32/ecx - 8803 0f 82/jump-if-addr< break/disp32 - 8804 # var cand/edi: (addr var) = lookup(*curr) - 8805 (lookup *edx *(edx+4)) # => eax - 8806 89/<- %edi 0/r32/eax - 8807 # if (cand->block-depth < depth) break - 8808 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth - 8809 0f 8c/jump-if-< break/disp32 - 8810 # var cand-reg/edi: (array array byte) = cand->reg - 8811 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax - 8812 89/<- %edi 0/r32/eax - 8813 # if (cand-reg == null) continue - 8814 { - 8815 $already-spilled-this-block?:check-reg: - 8816 81 7/subop/compare %edi 0/imm32 - 8817 0f 84/jump-if-= break/disp32 - 8818 # if (cand-reg == needle) return true - 8819 (string-equal? %esi %edi) # => eax - 8820 3d/compare-eax-and 0/imm32/false - 8821 74/jump-if-= break/disp8 - 8822 $already-spilled-this-block?:return-true: - 8823 b8/copy-to-eax 1/imm32/true - 8824 eb/jump $already-spilled-this-block?:end/disp8 - 8825 } - 8826 $already-spilled-this-block?:continue: - 8827 # curr -= 8 - 8828 81 5/subop/subtract %edx 8/imm32 - 8829 e9/jump loop/disp32 - 8830 } - 8831 # return false - 8832 b8/copy-to-eax 0/imm32/false - 8833 $already-spilled-this-block?:end: - 8834 # . restore registers - 8835 5f/pop-to-edi - 8836 5e/pop-to-esi - 8837 5b/pop-to-ebx - 8838 5a/pop-to-edx - 8839 59/pop-to-ecx - 8840 # . epilogue - 8841 89/<- %esp 5/r32/ebp - 8842 5d/pop-to-ebp - 8843 c3/return - 8844 - 8845 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? - 8846 # v is guaranteed to be within vars - 8847 # 'start' is provided as an optimization, a pointer within vars - 8848 # *start == v - 8849 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean - 8850 # . prologue - 8851 55/push-ebp - 8852 89/<- %ebp 4/r32/esp - 8853 # . save registers - 8854 51/push-ecx - 8855 52/push-edx - 8856 53/push-ebx - 8857 56/push-esi - 8858 57/push-edi - 8859 # ecx = v - 8860 8b/-> *(ebp+8) 1/r32/ecx - 8861 # var reg/edx: (addr array byte) = lookup(v->register) - 8862 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax - 8863 89/<- %edx 0/r32/eax - 8864 # var depth/ebx: int = v->block-depth - 8865 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth - 8866 # var min/ecx: (addr handle var) = vars->data - 8867 8b/-> *(ebp+0xc) 1/r32/ecx - 8868 81 0/subop/add %ecx 8/imm32 - 8869 # TODO: check that start >= min and start < &vars->data[top] - 8870 # TODO: check that *start == v - 8871 # var curr/esi: (addr handle var) = start - 8872 8b/-> *(ebp+0x10) 6/r32/esi - 8873 # curr -= 8 - 8874 81 5/subop/subtract %esi 8/imm32 - 8875 { - 8876 $same-register-spilled-before?:loop: - 8877 # if (curr < min) break - 8878 39/compare %esi 1/r32/ecx - 8879 0f 82/jump-if-addr< break/disp32 - 8880 # var x/eax: (addr var) = lookup(*curr) - 8881 (lookup *esi *(esi+4)) # => eax - 8882 # if (x->block-depth < depth) break - 8883 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth - 8884 0f 8c/jump-if-< break/disp32 - 8885 # if (x->register == 0) continue - 8886 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 8887 74/jump-if-= $same-register-spilled-before?:continue/disp8 - 8888 # if (x->register == reg) return true - 8889 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 8890 (string-equal? %eax %edx) # => eax - 8891 3d/compare-eax-and 0/imm32/false - 8892 b8/copy-to-eax 1/imm32/true - 8893 75/jump-if-!= $same-register-spilled-before?:end/disp8 - 8894 $same-register-spilled-before?:continue: - 8895 # curr -= 8 - 8896 81 5/subop/subtract %esi 8/imm32 - 8897 e9/jump loop/disp32 - 8898 } - 8899 $same-register-spilled-before?:false: - 8900 b8/copy-to-eax 0/imm32/false - 8901 $same-register-spilled-before?:end: - 8902 # . restore registers - 8903 5f/pop-to-edi - 8904 5e/pop-to-esi - 8905 5b/pop-to-ebx - 8906 5a/pop-to-edx - 8907 59/pop-to-ecx - 8908 # . epilogue - 8909 89/<- %esp 5/r32/ebp - 8910 5d/pop-to-ebp - 8911 c3/return - 8912 - 8913 # clean up global state for 'vars' until some block depth - 8914 clean-up-blocks: # vars: (addr stack (handle var)), until-block-depth: int - 8915 # . prologue - 8916 55/push-ebp - 8917 89/<- %ebp 4/r32/esp - 8918 # . save registers - 8919 50/push-eax - 8920 51/push-ecx - 8921 56/push-esi - 8922 # esi = vars - 8923 8b/-> *(ebp+8) 6/r32/esi - 8924 # ecx = until-block-depth - 8925 8b/-> *(ebp+0xc) 1/r32/ecx - 8926 { - 8927 $clean-up-blocks:reclaim-loop: - 8928 # if (vars->top <= 0) break - 8929 8b/-> *esi 0/r32/eax # Stack-top - 8930 3d/compare-eax-and 0/imm32 - 8931 7e/jump-if-<= break/disp8 - 8932 # var v/eax: (addr var) = lookup(vars[vars->top-8]) - 8933 (lookup *(esi+eax) *(esi+eax+4)) # vars + 8 + vars->top - 8 => eax - 8934 # if (v->block-depth < until-block-depth) break - 8935 39/compare *(eax+0x10) 1/r32/ecx # Var-block-depth - 8936 7c/jump-if-< break/disp8 - 8937 # if v is on the stack, update Curr-local-stack-offset - 8938 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 8939 { - 8940 75/jump-if-!= break/disp8 - 8941 $clean-up-blocks:reclaim-var-on-stack: - 8942 (size-of %eax) # => eax - 8943 01/add-to *Curr-local-stack-offset 0/r32/eax - 8944 } - 8945 (pop %esi) # => eax - 8946 (pop %esi) # => eax - 8947 e9/jump loop/disp32 - 8948 } - 8949 $clean-up-blocks:end: - 8950 # . restore registers - 8951 5e/pop-to-esi - 8952 59/pop-to-ecx - 8953 58/pop-to-eax - 8954 # . epilogue - 8955 89/<- %esp 5/r32/ebp - 8956 5d/pop-to-ebp - 8957 c3/return - 8958 - 8959 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) - 8960 # . prologue - 8961 55/push-ebp - 8962 89/<- %ebp 4/r32/esp - 8963 # . save registers - 8964 50/push-eax - 8965 51/push-ecx - 8966 52/push-edx - 8967 # eax = stmt - 8968 8b/-> *(ebp+0xc) 0/r32/eax - 8969 # var v/ecx: (addr var) - 8970 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax - 8971 89/<- %ecx 0/r32/eax - 8972 # v->block-depth = *Curr-block-depth - 8973 8b/-> *Curr-block-depth 0/r32/eax - 8974 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth - 8975 # var n/edx: int = size-of(stmt->var) - 8976 (size-of %ecx) # => eax - 8977 89/<- %edx 0/r32/eax - 8978 # *Curr-local-stack-offset -= n - 8979 29/subtract-from *Curr-local-stack-offset 2/r32/edx - 8980 # v->offset = *Curr-local-stack-offset - 8981 8b/-> *Curr-local-stack-offset 0/r32/eax - 8982 89/<- *(ecx+0x14) 0/r32/eax # Var-offset - 8983 # if v is an array, do something special - 8984 { - 8985 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax - 8986 (is-mu-array? %eax) # => eax - 8987 3d/compare-eax-and 0/imm32/false - 8988 0f 84/jump-if-= break/disp32 - 8989 # var array-size-without-size/edx: int = n-4 - 8990 81 5/subop/subtract %edx 4/imm32 - 8991 (emit-indent *(ebp+8) *Curr-block-depth) - 8992 (write-buffered *(ebp+8) "(push-n-zero-bytes ") - 8993 (print-int32-buffered *(ebp+8) %edx) - 8994 (write-buffered *(ebp+8) ")\n") - 8995 (emit-indent *(ebp+8) *Curr-block-depth) - 8996 (write-buffered *(ebp+8) "68/push ") - 8997 (print-int32-buffered *(ebp+8) %edx) - 8998 (write-buffered *(ebp+8) "/imm32\n") - 8999 eb/jump $emit-subx-var-def:end/disp8 - 9000 } - 9001 # while n > 0 - 9002 { - 9003 81 7/subop/compare %edx 0/imm32 - 9004 7e/jump-if-<= break/disp8 - 9005 (emit-indent *(ebp+8) *Curr-block-depth) - 9006 (write-buffered *(ebp+8) "68/push 0/imm32\n") - 9007 # n -= 4 - 9008 81 5/subop/subtract %edx 4/imm32 - 9009 # - 9010 eb/jump loop/disp8 - 9011 } - 9012 $emit-subx-var-def:end: - 9013 # . restore registers - 9014 5a/pop-to-edx - 9015 59/pop-to-ecx - 9016 58/pop-to-eax - 9017 # . epilogue - 9018 89/<- %esp 5/r32/ebp - 9019 5d/pop-to-ebp - 9020 c3/return - 9021 - 9022 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive) - 9023 # . prologue - 9024 55/push-ebp - 9025 89/<- %ebp 4/r32/esp - 9026 # . save registers - 9027 50/push-eax - 9028 51/push-ecx - 9029 # - some special-case primitives that don't actually use the 'primitives' data structure - 9030 # var op/ecx: (addr array byte) = lookup(stmt->operation) - 9031 8b/-> *(ebp+0xc) 1/r32/ecx - 9032 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax - 9033 89/<- %ecx 0/r32/eax - 9034 # array size - 9035 { - 9036 # if (!string-equal?(stmt->operation, "length")) break - 9037 (string-equal? %ecx "length") # => eax - 9038 3d/compare-eax-and 0/imm32 - 9039 0f 84/jump-if-= break/disp32 - 9040 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc)) - 9041 e9/jump $emit-subx-stmt:end/disp32 - 9042 } - 9043 # index into array - 9044 { - 9045 # if (!string-equal?(stmt->operation, "index")) break - 9046 (string-equal? %ecx "index") # => eax - 9047 3d/compare-eax-and 0/imm32 - 9048 0f 84/jump-if-= break/disp32 - 9049 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc)) - 9050 e9/jump $emit-subx-stmt:end/disp32 - 9051 } - 9052 # compute-offset for index into array - 9053 { - 9054 # if (!string-equal?(stmt->operation, "compute-offset")) break - 9055 (string-equal? %ecx "compute-offset") # => eax - 9056 3d/compare-eax-and 0/imm32 - 9057 0f 84/jump-if-= break/disp32 - 9058 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc)) - 9059 e9/jump $emit-subx-stmt:end/disp32 - 9060 } - 9061 # get field from record - 9062 { - 9063 # if (!string-equal?(stmt->operation, "get")) break - 9064 (string-equal? %ecx "get") # => eax - 9065 3d/compare-eax-and 0/imm32 - 9066 0f 84/jump-if-= break/disp32 - 9067 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) - 9068 e9/jump $emit-subx-stmt:end/disp32 - 9069 } - 9070 # - if stmt matches a primitive, emit it - 9071 { - 9072 $emit-subx-stmt:check-for-primitive: - 9073 # var curr/eax: (addr primitive) - 9074 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax - 9075 3d/compare-eax-and 0/imm32 - 9076 74/jump-if-= break/disp8 - 9077 $emit-subx-stmt:primitive: - 9078 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr - 9079 e9/jump $emit-subx-stmt:end/disp32 - 9080 } - 9081 # - otherwise emit a call - 9082 # TODO: type-checking - 9083 $emit-subx-stmt:call: - 9084 (emit-call *(ebp+8) *(ebp+0xc)) - 9085 $emit-subx-stmt:end: - 9086 # . restore registers - 9087 59/pop-to-ecx - 9088 58/pop-to-eax - 9089 # . epilogue - 9090 89/<- %esp 5/r32/ebp - 9091 5d/pop-to-ebp - 9092 c3/return - 9093 - 9094 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt) - 9095 # . prologue - 9096 55/push-ebp - 9097 89/<- %ebp 4/r32/esp - 9098 # . save registers - 9099 50/push-eax - 9100 51/push-ecx - 9101 52/push-edx - 9102 53/push-ebx - 9103 56/push-esi - 9104 # esi = stmt - 9105 8b/-> *(ebp+0xc) 6/r32/esi - 9106 # var base/ebx: (addr var) = stmt->inouts[0]->value - 9107 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9108 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9109 89/<- %ebx 0/r32/eax - 9110 # var elemsize/ecx: int = element-size(base) - 9111 (array-element-type-id %ebx) # => eax - 9112 (size-of-type-id %eax) # => eax - 9113 89/<- %ecx 0/r32/eax - 9114 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register - 9115 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9116 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9117 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9118 89/<- %edx 0/r32/eax - 9119 # if elemsize == 1 - 9120 { - 9121 81 7/subop/compare %ecx 1/imm32 - 9122 75/jump-if-!= break/disp8 - 9123 (emit-save-size-to *(ebp+8) %ebx %edx) - 9124 e9/jump $translate-mu-length-stmt:end/disp32 - 9125 } - 9126 # if elemsize is a power of 2 less than 256 + 8181 $emit-subx-stmt-list:check-for-block: + 8182 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag + 8183 75/jump-if-!= break/disp8 + 8184 $emit-subx-stmt-list:block: + 8185 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10)) + 8186 } + 8187 { + 8188 $emit-subx-stmt-list:check-for-stmt: + 8189 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag + 8190 0f 85/jump-if-!= break/disp32 + 8191 $emit-subx-stmt-list:stmt1: + 8192 { + 8193 (is-mu-branch? %ecx) # => eax + 8194 3d/compare-eax-and 0/imm32/false + 8195 0f 84/jump-if-= break/disp32 + 8196 $emit-subx-stmt-list:branch-stmt: + 8197 # if !var-seen? break + 8198 81 7/subop/compare %edx 0/imm32/false + 8199 0f 84/jump-if-= break/disp32 + 8200 $emit-subx-stmt-list:branch-stmt-and-var-seen: + 8201 +-- 27 lines: # unconditional loops ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8228 +-- 16 lines: # unconditional breaks --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8244 +-- 38 lines: # simple conditional branches without a target --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8282 +-- 19 lines: # conditional branches with an explicit target --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8301 } + 8302 $emit-subx-stmt-list:1-to-1: + 8303 (emit-subx-stmt *(ebp+8) %ecx Primitives) + 8304 e9/jump $emit-subx-stmt-list:continue/disp32 + 8305 } + 8306 { + 8307 $emit-subx-stmt-list:check-for-var-def: + 8308 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag + 8309 75/jump-if-!= break/disp8 + 8310 $emit-subx-stmt-list:var-def: + 8311 (emit-subx-var-def *(ebp+8) %ecx) + 8312 (push *(ebp+0x10) *(ecx+4)) # Vardef-var + 8313 (push *(ebp+0x10) *(ecx+8)) # Vardef-var + 8314 # var-seen? = true + 8315 ba/copy-to-edx 1/imm32/true + 8316 eb/jump $emit-subx-stmt-list:continue/disp8 + 8317 } + 8318 { + 8319 $emit-subx-stmt-list:check-for-reg-var-def: + 8320 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag + 8321 0f 85/jump-if-!= break/disp32 + 8322 $emit-subx-stmt-list:reg-var-def: + 8323 # TODO: ensure that there's exactly one output + 8324 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10)) + 8325 # emit the instruction as usual + 8326 (emit-subx-stmt *(ebp+8) %ecx Primitives) + 8327 # var-seen? = true + 8328 ba/copy-to-edx 1/imm32/true + 8329 eb/jump $emit-subx-stmt-list:continue/disp8 + 8330 } + 8331 $emit-subx-stmt-list:continue: + 8332 # TODO: raise an error on unrecognized Stmt-tag + 8333 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax + 8334 89/<- %esi 0/r32/eax + 8335 e9/jump loop/disp32 + 8336 } + 8337 $emit-subx-stmt-list:emit-cleanup: + 8338 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) + 8339 $emit-subx-stmt-list:clean-up: + 8340 (clean-up-blocks *(ebp+0x10) *Curr-block-depth) + 8341 $emit-subx-stmt-list:end: + 8342 # . restore registers + 8343 5e/pop-to-esi + 8344 5b/pop-to-ebx + 8345 5a/pop-to-edx + 8346 59/pop-to-ecx + 8347 58/pop-to-eax + 8348 # . epilogue + 8349 89/<- %esp 5/r32/ebp + 8350 5d/pop-to-ebp + 8351 c3/return + 8352 + 8353 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)) + 8354 # . prologue + 8355 55/push-ebp + 8356 89/<- %ebp 4/r32/esp + 8357 # . save registers + 8358 50/push-eax + 8359 51/push-ecx + 8360 # ecx = stmt + 8361 8b/-> *(ebp+0xc) 1/r32/ecx + 8362 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) + 8363 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax + 8364 # TODO: assert !sv->is-deref? + 8365 # var v/ecx: (addr var) = lookup(sv->value) + 8366 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 8367 89/<- %ecx 0/r32/eax + 8368 # v->block-depth = *Curr-block-depth + 8369 8b/-> *Curr-block-depth 0/r32/eax + 8370 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth + 8371 #? (write-buffered Stderr "var ") + 8372 #? (lookup *ecx *(ecx+4)) + 8373 #? (write-buffered Stderr %eax) + 8374 #? (write-buffered Stderr " at depth ") + 8375 #? (print-int32-buffered Stderr *(ecx+0x10)) + 8376 #? (write-buffered Stderr Newline) + 8377 #? (flush Stderr) + 8378 # ensure that v is in a register + 8379 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register + 8380 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 + 8381 # if !already-spilled-this-block?(reg, vars) emit code to spill reg + 8382 (already-spilled-this-block? %ecx *(ebp+0x10)) # => eax + 8383 3d/compare-eax-and 0/imm32/false + 8384 75/jump-if-!= $push-output-and-maybe-emit-spill:push/disp8 + 8385 # TODO: assert(size-of(output) == 4) + 8386 # *Curr-local-stack-offset -= 4 + 8387 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 + 8388 # emit spill + 8389 (emit-indent *(ebp+8) *Curr-block-depth) + 8390 (write-buffered *(ebp+8) "ff 6/subop/push %") + 8391 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax + 8392 (write-buffered *(ebp+8) %eax) + 8393 (write-buffered *(ebp+8) Newline) + 8394 $push-output-and-maybe-emit-spill:push: + 8395 8b/-> *(ebp+0xc) 1/r32/ecx + 8396 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax + 8397 # push(vars, sv->value) + 8398 (push *(ebp+0x10) *eax) # Stmt-var-value + 8399 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value + 8400 $push-output-and-maybe-emit-spill:end: + 8401 # . restore registers + 8402 59/pop-to-ecx + 8403 58/pop-to-eax + 8404 # . epilogue + 8405 89/<- %esp 5/r32/ebp + 8406 5d/pop-to-ebp + 8407 c3/return + 8408 + 8409 $push-output-and-maybe-emit-spill:abort: + 8410 # error("var '" var->name "' initialized from an instruction must live in a register\n") + 8411 (write-buffered Stderr "var '") + 8412 (write-buffered Stderr *eax) # Var-name + 8413 (write-buffered Stderr "' initialized from an instruction must live in a register\n") + 8414 (flush Stderr) + 8415 # . syscall(exit, 1) + 8416 bb/copy-to-ebx 1/imm32 + 8417 b8/copy-to-eax 1/imm32/exit + 8418 cd/syscall 0x80/imm8 + 8419 # never gets here + 8420 + 8421 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack (handle var)) + 8422 # . prologue + 8423 55/push-ebp + 8424 89/<- %ebp 4/r32/esp + 8425 # . save registers + 8426 50/push-eax + 8427 51/push-ecx + 8428 # ecx = stmt + 8429 8b/-> *(ebp+0xc) 1/r32/ecx + 8430 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name + 8431 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 8432 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 8433 (lookup *eax *(eax+4)) # Var-name Var-name => eax + 8434 # clean up until target block + 8435 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) + 8436 # emit jump to target block + 8437 (emit-indent *(ebp+8) *Curr-block-depth) + 8438 (write-buffered *(ebp+8) "e9/jump ") + 8439 (write-buffered *(ebp+8) %eax) + 8440 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax + 8441 (string-starts-with? %eax "break") + 8442 3d/compare-eax-and 0/imm32/false + 8443 { + 8444 74/jump-if-= break/disp8 + 8445 (write-buffered *(ebp+8) ":break/disp32\n") + 8446 } + 8447 3d/compare-eax-and 0/imm32/false # just in case the function call modified flags + 8448 { + 8449 75/jump-if-!= break/disp8 + 8450 (write-buffered *(ebp+8) ":loop/disp32\n") + 8451 } + 8452 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: + 8453 # . restore registers + 8454 59/pop-to-ecx + 8455 58/pop-to-eax + 8456 # . epilogue + 8457 89/<- %esp 5/r32/ebp + 8458 5d/pop-to-ebp + 8459 c3/return + 8460 + 8461 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean + 8462 # . prologue + 8463 55/push-ebp + 8464 89/<- %ebp 4/r32/esp + 8465 # . save registers + 8466 51/push-ecx + 8467 # ecx = lookup(stmt->operation) + 8468 8b/-> *(ebp+8) 1/r32/ecx + 8469 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax + 8470 89/<- %ecx 0/r32/eax + 8471 # if (stmt->operation starts with "loop") return true + 8472 (string-starts-with? %ecx "loop") # => eax + 8473 3d/compare-eax-and 0/imm32/false + 8474 75/jump-if-not-equal $is-mu-branch?:end/disp8 + 8475 # otherwise return (stmt->operation starts with "break") + 8476 (string-starts-with? %ecx "break") # => eax + 8477 $is-mu-branch?:end: + 8478 # . restore registers + 8479 59/pop-to-ecx + 8480 # . epilogue + 8481 89/<- %esp 5/r32/ebp + 8482 5d/pop-to-ebp + 8483 c3/return + 8484 + 8485 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) + 8486 # . prologue + 8487 55/push-ebp + 8488 89/<- %ebp 4/r32/esp + 8489 # . save registers + 8490 50/push-eax + 8491 # eax = stmt + 8492 8b/-> *(ebp+0xc) 0/r32/eax + 8493 # + 8494 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax + 8495 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) + 8496 (emit-indent *(ebp+8) *Curr-block-depth) + 8497 (lookup *eax *(eax+4)) # => eax + 8498 (write-buffered *(ebp+8) %eax) + 8499 (write-buffered *(ebp+8) " break/disp32\n") + 8500 $emit-reverse-break:end: + 8501 # . restore registers + 8502 58/pop-to-eax + 8503 # . epilogue + 8504 89/<- %esp 5/r32/ebp + 8505 5d/pop-to-ebp + 8506 c3/return + 8507 + 8508 == data + 8509 + 8510 # Table from Mu branch instructions to the reverse SubX opcodes for them. + 8511 Reverse-branch: # (table (handle array byte) (handle array byte)) + 8512 # a table is a stream + 8513 0x140/imm32/write + 8514 0/imm32/read + 8515 0x140/imm32/size + 8516 # data + 8517 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 + 8518 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 + 8519 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 + 8520 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 + 8521 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 + 8522 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 + 8523 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 + 8524 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 + 8525 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 + 8526 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 + 8527 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 + 8528 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 + 8529 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 + 8530 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 + 8531 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 + 8532 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 + 8533 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 + 8534 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 + 8535 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 + 8536 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 + 8537 + 8538 == code + 8539 + 8540 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack (handle var)), depth: int, label-suffix: (addr array byte) + 8541 # . prologue + 8542 55/push-ebp + 8543 89/<- %ebp 4/r32/esp + 8544 # . save registers + 8545 50/push-eax + 8546 51/push-ecx + 8547 52/push-edx + 8548 53/push-ebx + 8549 56/push-esi + 8550 # ecx = vars + 8551 8b/-> *(ebp+0xc) 1/r32/ecx + 8552 # var eax: int = vars->top + 8553 8b/-> *ecx 0/r32/eax + 8554 # var curr/esi: (addr handle var) = &vars->data[vars->top - 8] + 8555 8d/copy-address *(ecx+eax) 6/r32/esi # vars + 8 + vars->top - 8 + 8556 # var min/ecx: (addr handle var) = vars->data + 8557 81 0/subop/add %ecx 8/imm32 + 8558 # edx = depth + 8559 8b/-> *(ebp+0x10) 2/r32/edx + 8560 { + 8561 $emit-unconditional-jump-to-depth:loop: + 8562 # if (curr < min) break + 8563 39/compare %esi 1/r32/ecx + 8564 0f 82/jump-if-addr< break/disp32 + 8565 # var v/ebx: (addr var) = lookup(*curr) + 8566 (lookup *esi *(esi+4)) # => eax + 8567 89/<- %ebx 0/r32/eax + 8568 # if (v->block-depth < until-block-depth) break + 8569 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth + 8570 0f 8c/jump-if-< break/disp32 + 8571 { + 8572 $emit-unconditional-jump-to-depth:check: + 8573 # if v->block-depth != until-block-depth, continue + 8574 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth + 8575 0f 85/jump-if-!= break/disp32 + 8576 $emit-unconditional-jump-to-depth:depth-found: + 8577 # if v is not a literal, continue + 8578 (size-of %ebx) # => eax + 8579 3d/compare-eax-and 0/imm32 + 8580 0f 85/jump-if-!= break/disp32 + 8581 $emit-unconditional-jump-to-depth:label-found: + 8582 # emit unconditional jump, then return + 8583 (emit-indent *(ebp+8) *Curr-block-depth) + 8584 (write-buffered *(ebp+8) "e9/jump ") + 8585 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 8586 (write-buffered *(ebp+8) %eax) + 8587 (write-buffered *(ebp+8) ":") + 8588 (write-buffered *(ebp+8) *(ebp+0x14)) + 8589 (write-buffered *(ebp+8) "/disp32\n") + 8590 eb/jump $emit-unconditional-jump-to-depth:end/disp8 + 8591 } + 8592 # curr -= 8 + 8593 81 5/subop/subtract %esi 8/imm32 + 8594 e9/jump loop/disp32 + 8595 } + 8596 # TODO: error if no label at 'depth' was found + 8597 $emit-unconditional-jump-to-depth:end: + 8598 # . restore registers + 8599 5e/pop-to-esi + 8600 5b/pop-to-ebx + 8601 5a/pop-to-edx + 8602 59/pop-to-ecx + 8603 58/pop-to-eax + 8604 # . epilogue + 8605 89/<- %esp 5/r32/ebp + 8606 5d/pop-to-ebp + 8607 c3/return + 8608 + 8609 # emit clean-up code for 'vars' until some block depth + 8610 # doesn't actually modify 'vars' so we need traverse manually inside the stack + 8611 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack (handle var)), until-block-depth: int + 8612 # . prologue + 8613 55/push-ebp + 8614 89/<- %ebp 4/r32/esp + 8615 # . save registers + 8616 50/push-eax + 8617 51/push-ecx + 8618 52/push-edx + 8619 53/push-ebx + 8620 56/push-esi + 8621 #? (write-buffered Stderr "--- cleanup\n") + 8622 #? (flush Stderr) + 8623 # ecx = vars + 8624 8b/-> *(ebp+0xc) 1/r32/ecx + 8625 # var esi: int = vars->top + 8626 8b/-> *ecx 6/r32/esi + 8627 # var curr/esi: (addr handle var) = &vars->data[vars->top - 8] + 8628 8d/copy-address *(ecx+esi) 6/r32/esi # vars + 8 + vars->top - 8 + 8629 # var min/ecx: (addr handle var) = vars->data + 8630 81 0/subop/add %ecx 8/imm32 + 8631 # edx = until-block-depth + 8632 8b/-> *(ebp+0x10) 2/r32/edx + 8633 { + 8634 $emit-cleanup-code-until-depth:loop: + 8635 # if (curr < min) break + 8636 39/compare %esi 1/r32/ecx + 8637 0f 82/jump-if-addr< break/disp32 + 8638 # var v/ebx: (addr var) = lookup(*curr) + 8639 (lookup *esi *(esi+4)) # => eax + 8640 89/<- %ebx 0/r32/eax + 8641 #? (lookup *ebx *(ebx+4)) # Var-name + 8642 #? (write-buffered Stderr "var ") + 8643 #? (write-buffered Stderr %eax) + 8644 #? (write-buffered Stderr Newline) + 8645 #? (flush Stderr) + 8646 # if (v->block-depth < until-block-depth) break + 8647 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth + 8648 0f 8c/jump-if-< break/disp32 + 8649 # if v is in a register + 8650 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register + 8651 { + 8652 0f 84/jump-if-= break/disp32 + 8653 { + 8654 $emit-cleanup-code-until-depth:check-for-previous-spill: + 8655 (same-register-spilled-before? %ebx *(ebp+0xc) %esi) # => eax + 8656 3d/compare-eax-and 0/imm32/false + 8657 0f 85/jump-if-!= break/disp32 + 8658 $emit-cleanup-code-until-depth:reclaim-var-in-register: + 8659 (emit-indent *(ebp+8) *Curr-block-depth) + 8660 (write-buffered *(ebp+8) "8f 0/subop/pop %") + 8661 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 8662 (write-buffered *(ebp+8) %eax) + 8663 (write-buffered *(ebp+8) Newline) + 8664 } + 8665 eb/jump $emit-cleanup-code-until-depth:continue/disp8 + 8666 } + 8667 # otherwise v is on the stack + 8668 { + 8669 75/jump-if-!= break/disp8 + 8670 $emit-cleanup-code-until-depth:var-on-stack: + 8671 (size-of %ebx) # => eax + 8672 # don't emit code for labels + 8673 3d/compare-eax-and 0/imm32 + 8674 74/jump-if-= break/disp8 + 8675 $emit-cleanup-code-until-depth:reclaim-var-on-stack: + 8676 (emit-indent *(ebp+8) *Curr-block-depth) + 8677 (write-buffered *(ebp+8) "81 0/subop/add %esp ") + 8678 (print-int32-buffered *(ebp+8) %eax) + 8679 (write-buffered *(ebp+8) "/imm32\n") + 8680 } + 8681 $emit-cleanup-code-until-depth:continue: + 8682 # curr -= 8 + 8683 81 5/subop/subtract %esi 8/imm32 + 8684 e9/jump loop/disp32 + 8685 } + 8686 $emit-cleanup-code-until-depth:end: + 8687 # . restore registers + 8688 5e/pop-to-esi + 8689 5b/pop-to-ebx + 8690 5a/pop-to-edx + 8691 59/pop-to-ecx + 8692 58/pop-to-eax + 8693 # . epilogue + 8694 89/<- %esp 5/r32/ebp + 8695 5d/pop-to-ebp + 8696 c3/return + 8697 + 8698 # emit clean-up code for 'vars' until a given label is encountered + 8699 # doesn't actually modify 'vars' so we need traverse manually inside the stack + 8700 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack (handle var)), until-block-label: (addr array byte) + 8701 # . prologue + 8702 55/push-ebp + 8703 89/<- %ebp 4/r32/esp + 8704 # . save registers + 8705 50/push-eax + 8706 51/push-ecx + 8707 52/push-edx + 8708 53/push-ebx + 8709 # ecx = vars + 8710 8b/-> *(ebp+0xc) 1/r32/ecx + 8711 # var eax: int = vars->top + 8712 8b/-> *ecx 0/r32/eax + 8713 # var curr/edx: (addr handle var) = &vars->data[vars->top - 8] + 8714 8d/copy-address *(ecx+eax) 2/r32/edx # vars + 8 + vars->top - 8 + 8715 # var min/ecx: (addr handle var) = vars->data + 8716 81 0/subop/add %ecx 8/imm32 + 8717 { + 8718 $emit-cleanup-code-until-target:loop: + 8719 # if (curr < min) break + 8720 39/compare %edx 1/r32/ecx + 8721 0f 82/jump-if-addr< break/disp32 + 8722 # var v/ebx: (handle var) = lookup(*curr) + 8723 (lookup *edx *(edx+4)) # => eax + 8724 89/<- %ebx 0/r32/eax + 8725 # if (v->name == until-block-label) break + 8726 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax + 8727 (string-equal? %eax *(ebp+0x10)) # => eax + 8728 3d/compare-eax-and 0/imm32/false + 8729 0f 85/jump-if-!= break/disp32 + 8730 # if v is in a register + 8731 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register + 8732 { + 8733 0f 84/jump-if-= break/disp32 + 8734 { + 8735 $emit-cleanup-code-until-target:check-for-previous-spill: + 8736 (same-register-spilled-before? %ebx *(ebp+0xc) %edx) # => eax + 8737 3d/compare-eax-and 0/imm32/false + 8738 75/jump-if-!= break/disp8 + 8739 $emit-cleanup-code-until-target:reclaim-var-in-register: + 8740 (emit-indent *(ebp+8) *Curr-block-depth) + 8741 (write-buffered *(ebp+8) "8f 0/subop/pop %") + 8742 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 8743 (write-buffered *(ebp+8) %eax) + 8744 (write-buffered *(ebp+8) Newline) + 8745 } + 8746 eb/jump $emit-cleanup-code-until-target:continue/disp8 + 8747 } + 8748 # otherwise v is on the stack + 8749 { + 8750 75/jump-if-!= break/disp8 + 8751 $emit-cleanup-code-until-target:reclaim-var-on-stack: + 8752 (size-of %ebx) # => eax + 8753 # don't emit code for labels + 8754 3d/compare-eax-and 0/imm32 + 8755 74/jump-if-= break/disp8 + 8756 # + 8757 (emit-indent *(ebp+8) *Curr-block-depth) + 8758 (write-buffered *(ebp+8) "81 0/subop/add %esp ") + 8759 (print-int32-buffered *(ebp+8) %eax) + 8760 (write-buffered *(ebp+8) "/imm32\n") + 8761 } + 8762 $emit-cleanup-code-until-target:continue: + 8763 # curr -= 8 + 8764 81 5/subop/subtract %edx 8/imm32 + 8765 e9/jump loop/disp32 + 8766 } + 8767 $emit-cleanup-code-until-target:end: + 8768 # . restore registers + 8769 5b/pop-to-ebx + 8770 5a/pop-to-edx + 8771 59/pop-to-ecx + 8772 58/pop-to-eax + 8773 # . epilogue + 8774 89/<- %esp 5/r32/ebp + 8775 5d/pop-to-ebp + 8776 c3/return + 8777 + 8778 # is there already a var with the same block-depth and register as 'v' on the 'vars' stack? + 8779 # v is guaranteed not to be within vars + 8780 already-spilled-this-block?: # v: (addr var), vars: (addr stack (handle var)) -> result/eax: boolean + 8781 # . prologue + 8782 55/push-ebp + 8783 89/<- %ebp 4/r32/esp + 8784 # . save registers + 8785 51/push-ecx + 8786 52/push-edx + 8787 53/push-ebx + 8788 56/push-esi + 8789 57/push-edi + 8790 # ecx = vars + 8791 8b/-> *(ebp+0xc) 1/r32/ecx + 8792 # var eax: int = vars->top + 8793 8b/-> *ecx 0/r32/eax + 8794 # var min/ecx: (addr handle var) = vars->data + 8795 81 0/subop/add %ecx 8/imm32 + 8796 # var curr/edx: (addr handle var) = &vars->data[vars->top - 8] + 8797 81 5/subop/subtract %eax 8/imm32 + 8798 8d/copy-address *(ecx+eax) 2/r32/edx + 8799 # var depth/ebx: int = v->block-depth + 8800 8b/-> *(ebp+8) 3/r32/ebx + 8801 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth + 8802 # var needle/esi: (addr array byte) = v->register + 8803 8b/-> *(ebp+8) 6/r32/esi + 8804 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax + 8805 89/<- %esi 0/r32/eax + 8806 { + 8807 $already-spilled-this-block?:loop: + 8808 # if (curr < min) break + 8809 39/compare %edx 1/r32/ecx + 8810 0f 82/jump-if-addr< break/disp32 + 8811 # var cand/edi: (addr var) = lookup(*curr) + 8812 (lookup *edx *(edx+4)) # => eax + 8813 89/<- %edi 0/r32/eax + 8814 # if (cand->block-depth < depth) break + 8815 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth + 8816 0f 8c/jump-if-< break/disp32 + 8817 # var cand-reg/edi: (array array byte) = cand->reg + 8818 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax + 8819 89/<- %edi 0/r32/eax + 8820 # if (cand-reg == null) continue + 8821 { + 8822 $already-spilled-this-block?:check-reg: + 8823 81 7/subop/compare %edi 0/imm32 + 8824 0f 84/jump-if-= break/disp32 + 8825 # if (cand-reg == needle) return true + 8826 (string-equal? %esi %edi) # => eax + 8827 3d/compare-eax-and 0/imm32/false + 8828 74/jump-if-= break/disp8 + 8829 $already-spilled-this-block?:return-true: + 8830 b8/copy-to-eax 1/imm32/true + 8831 eb/jump $already-spilled-this-block?:end/disp8 + 8832 } + 8833 $already-spilled-this-block?:continue: + 8834 # curr -= 8 + 8835 81 5/subop/subtract %edx 8/imm32 + 8836 e9/jump loop/disp32 + 8837 } + 8838 # return false + 8839 b8/copy-to-eax 0/imm32/false + 8840 $already-spilled-this-block?:end: + 8841 # . restore registers + 8842 5f/pop-to-edi + 8843 5e/pop-to-esi + 8844 5b/pop-to-ebx + 8845 5a/pop-to-edx + 8846 59/pop-to-ecx + 8847 # . epilogue + 8848 89/<- %esp 5/r32/ebp + 8849 5d/pop-to-ebp + 8850 c3/return + 8851 + 8852 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? + 8853 # v is guaranteed to be within vars + 8854 # 'start' is provided as an optimization, a pointer within vars + 8855 # *start == v + 8856 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean + 8857 # . prologue + 8858 55/push-ebp + 8859 89/<- %ebp 4/r32/esp + 8860 # . save registers + 8861 51/push-ecx + 8862 52/push-edx + 8863 53/push-ebx + 8864 56/push-esi + 8865 57/push-edi + 8866 # ecx = v + 8867 8b/-> *(ebp+8) 1/r32/ecx + 8868 # var reg/edx: (addr array byte) = lookup(v->register) + 8869 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax + 8870 89/<- %edx 0/r32/eax + 8871 # var depth/ebx: int = v->block-depth + 8872 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth + 8873 # var min/ecx: (addr handle var) = vars->data + 8874 8b/-> *(ebp+0xc) 1/r32/ecx + 8875 81 0/subop/add %ecx 8/imm32 + 8876 # TODO: check that start >= min and start < &vars->data[top] + 8877 # TODO: check that *start == v + 8878 # var curr/esi: (addr handle var) = start + 8879 8b/-> *(ebp+0x10) 6/r32/esi + 8880 # curr -= 8 + 8881 81 5/subop/subtract %esi 8/imm32 + 8882 { + 8883 $same-register-spilled-before?:loop: + 8884 # if (curr < min) break + 8885 39/compare %esi 1/r32/ecx + 8886 0f 82/jump-if-addr< break/disp32 + 8887 # var x/eax: (addr var) = lookup(*curr) + 8888 (lookup *esi *(esi+4)) # => eax + 8889 # if (x->block-depth < depth) break + 8890 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth + 8891 0f 8c/jump-if-< break/disp32 + 8892 # if (x->register == 0) continue + 8893 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 8894 74/jump-if-= $same-register-spilled-before?:continue/disp8 + 8895 # if (x->register == reg) return true + 8896 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 8897 (string-equal? %eax %edx) # => eax + 8898 3d/compare-eax-and 0/imm32/false + 8899 b8/copy-to-eax 1/imm32/true + 8900 75/jump-if-!= $same-register-spilled-before?:end/disp8 + 8901 $same-register-spilled-before?:continue: + 8902 # curr -= 8 + 8903 81 5/subop/subtract %esi 8/imm32 + 8904 e9/jump loop/disp32 + 8905 } + 8906 $same-register-spilled-before?:false: + 8907 b8/copy-to-eax 0/imm32/false + 8908 $same-register-spilled-before?:end: + 8909 # . restore registers + 8910 5f/pop-to-edi + 8911 5e/pop-to-esi + 8912 5b/pop-to-ebx + 8913 5a/pop-to-edx + 8914 59/pop-to-ecx + 8915 # . epilogue + 8916 89/<- %esp 5/r32/ebp + 8917 5d/pop-to-ebp + 8918 c3/return + 8919 + 8920 # clean up global state for 'vars' until some block depth + 8921 clean-up-blocks: # vars: (addr stack (handle var)), until-block-depth: int + 8922 # . prologue + 8923 55/push-ebp + 8924 89/<- %ebp 4/r32/esp + 8925 # . save registers + 8926 50/push-eax + 8927 51/push-ecx + 8928 56/push-esi + 8929 # esi = vars + 8930 8b/-> *(ebp+8) 6/r32/esi + 8931 # ecx = until-block-depth + 8932 8b/-> *(ebp+0xc) 1/r32/ecx + 8933 { + 8934 $clean-up-blocks:reclaim-loop: + 8935 # if (vars->top <= 0) break + 8936 8b/-> *esi 0/r32/eax # Stack-top + 8937 3d/compare-eax-and 0/imm32 + 8938 7e/jump-if-<= break/disp8 + 8939 # var v/eax: (addr var) = lookup(vars[vars->top-8]) + 8940 (lookup *(esi+eax) *(esi+eax+4)) # vars + 8 + vars->top - 8 => eax + 8941 # if (v->block-depth < until-block-depth) break + 8942 39/compare *(eax+0x10) 1/r32/ecx # Var-block-depth + 8943 7c/jump-if-< break/disp8 + 8944 # if v is on the stack, update Curr-local-stack-offset + 8945 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 8946 { + 8947 75/jump-if-!= break/disp8 + 8948 $clean-up-blocks:reclaim-var-on-stack: + 8949 (size-of %eax) # => eax + 8950 01/add-to *Curr-local-stack-offset 0/r32/eax + 8951 } + 8952 (pop %esi) # => eax + 8953 (pop %esi) # => eax + 8954 e9/jump loop/disp32 + 8955 } + 8956 $clean-up-blocks:end: + 8957 # . restore registers + 8958 5e/pop-to-esi + 8959 59/pop-to-ecx + 8960 58/pop-to-eax + 8961 # . epilogue + 8962 89/<- %esp 5/r32/ebp + 8963 5d/pop-to-ebp + 8964 c3/return + 8965 + 8966 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) + 8967 # . prologue + 8968 55/push-ebp + 8969 89/<- %ebp 4/r32/esp + 8970 # . save registers + 8971 50/push-eax + 8972 51/push-ecx + 8973 52/push-edx + 8974 # eax = stmt + 8975 8b/-> *(ebp+0xc) 0/r32/eax + 8976 # var v/ecx: (addr var) + 8977 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax + 8978 89/<- %ecx 0/r32/eax + 8979 # v->block-depth = *Curr-block-depth + 8980 8b/-> *Curr-block-depth 0/r32/eax + 8981 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth + 8982 # var n/edx: int = size-of(stmt->var) + 8983 (size-of %ecx) # => eax + 8984 89/<- %edx 0/r32/eax + 8985 # *Curr-local-stack-offset -= n + 8986 29/subtract-from *Curr-local-stack-offset 2/r32/edx + 8987 # v->offset = *Curr-local-stack-offset + 8988 8b/-> *Curr-local-stack-offset 0/r32/eax + 8989 89/<- *(ecx+0x14) 0/r32/eax # Var-offset + 8990 # if v is an array, do something special + 8991 { + 8992 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax + 8993 (is-mu-array? %eax) # => eax + 8994 3d/compare-eax-and 0/imm32/false + 8995 0f 84/jump-if-= break/disp32 + 8996 # var array-size-without-size/edx: int = n-4 + 8997 81 5/subop/subtract %edx 4/imm32 + 8998 (emit-indent *(ebp+8) *Curr-block-depth) + 8999 (write-buffered *(ebp+8) "(push-n-zero-bytes ") + 9000 (print-int32-buffered *(ebp+8) %edx) + 9001 (write-buffered *(ebp+8) ")\n") + 9002 (emit-indent *(ebp+8) *Curr-block-depth) + 9003 (write-buffered *(ebp+8) "68/push ") + 9004 (print-int32-buffered *(ebp+8) %edx) + 9005 (write-buffered *(ebp+8) "/imm32\n") + 9006 eb/jump $emit-subx-var-def:end/disp8 + 9007 } + 9008 # while n > 0 + 9009 { + 9010 81 7/subop/compare %edx 0/imm32 + 9011 7e/jump-if-<= break/disp8 + 9012 (emit-indent *(ebp+8) *Curr-block-depth) + 9013 (write-buffered *(ebp+8) "68/push 0/imm32\n") + 9014 # n -= 4 + 9015 81 5/subop/subtract %edx 4/imm32 + 9016 # + 9017 eb/jump loop/disp8 + 9018 } + 9019 $emit-subx-var-def:end: + 9020 # . restore registers + 9021 5a/pop-to-edx + 9022 59/pop-to-ecx + 9023 58/pop-to-eax + 9024 # . epilogue + 9025 89/<- %esp 5/r32/ebp + 9026 5d/pop-to-ebp + 9027 c3/return + 9028 + 9029 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive) + 9030 # . prologue + 9031 55/push-ebp + 9032 89/<- %ebp 4/r32/esp + 9033 # . save registers + 9034 50/push-eax + 9035 51/push-ecx + 9036 # - some special-case primitives that don't actually use the 'primitives' data structure + 9037 # var op/ecx: (addr array byte) = lookup(stmt->operation) + 9038 8b/-> *(ebp+0xc) 1/r32/ecx + 9039 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax + 9040 89/<- %ecx 0/r32/eax + 9041 # array size + 9042 { + 9043 # if (!string-equal?(stmt->operation, "length")) break + 9044 (string-equal? %ecx "length") # => eax + 9045 3d/compare-eax-and 0/imm32 + 9046 0f 84/jump-if-= break/disp32 + 9047 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc)) + 9048 e9/jump $emit-subx-stmt:end/disp32 + 9049 } + 9050 # index into array + 9051 { + 9052 # if (!string-equal?(stmt->operation, "index")) break + 9053 (string-equal? %ecx "index") # => eax + 9054 3d/compare-eax-and 0/imm32 + 9055 0f 84/jump-if-= break/disp32 + 9056 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc)) + 9057 e9/jump $emit-subx-stmt:end/disp32 + 9058 } + 9059 # compute-offset for index into array + 9060 { + 9061 # if (!string-equal?(stmt->operation, "compute-offset")) break + 9062 (string-equal? %ecx "compute-offset") # => eax + 9063 3d/compare-eax-and 0/imm32 + 9064 0f 84/jump-if-= break/disp32 + 9065 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc)) + 9066 e9/jump $emit-subx-stmt:end/disp32 + 9067 } + 9068 # get field from record + 9069 { + 9070 # if (!string-equal?(stmt->operation, "get")) break + 9071 (string-equal? %ecx "get") # => eax + 9072 3d/compare-eax-and 0/imm32 + 9073 0f 84/jump-if-= break/disp32 + 9074 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) + 9075 e9/jump $emit-subx-stmt:end/disp32 + 9076 } + 9077 # - if stmt matches a primitive, emit it + 9078 { + 9079 $emit-subx-stmt:check-for-primitive: + 9080 # var curr/eax: (addr primitive) + 9081 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax + 9082 3d/compare-eax-and 0/imm32 + 9083 74/jump-if-= break/disp8 + 9084 $emit-subx-stmt:primitive: + 9085 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr + 9086 e9/jump $emit-subx-stmt:end/disp32 + 9087 } + 9088 # - otherwise emit a call + 9089 # TODO: type-checking + 9090 $emit-subx-stmt:call: + 9091 (emit-call *(ebp+8) *(ebp+0xc)) + 9092 $emit-subx-stmt:end: + 9093 # . restore registers + 9094 59/pop-to-ecx + 9095 58/pop-to-eax + 9096 # . epilogue + 9097 89/<- %esp 5/r32/ebp + 9098 5d/pop-to-ebp + 9099 c3/return + 9100 + 9101 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt) + 9102 # . prologue + 9103 55/push-ebp + 9104 89/<- %ebp 4/r32/esp + 9105 # . save registers + 9106 50/push-eax + 9107 51/push-ecx + 9108 52/push-edx + 9109 53/push-ebx + 9110 56/push-esi + 9111 # esi = stmt + 9112 8b/-> *(ebp+0xc) 6/r32/esi + 9113 # var base/ebx: (addr var) = stmt->inouts[0]->value + 9114 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9115 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9116 89/<- %ebx 0/r32/eax + 9117 # var elemsize/ecx: int = element-size(base) + 9118 (array-element-type-id %ebx) # => eax + 9119 (size-of-type-id %eax) # => eax + 9120 89/<- %ecx 0/r32/eax + 9121 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register + 9122 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9123 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9124 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9125 89/<- %edx 0/r32/eax + 9126 # if elemsize == 1 9127 { - 9128 (power-of-2? %ecx) # => eax - 9129 3d/compare-eax-and 0/imm32/false - 9130 74/jump-if-= break/disp8 - 9131 81 7/subop/compare %ecx 0xff/imm32 - 9132 7f/jump-if-> break/disp8 - 9133 (emit-save-size-to *(ebp+8) %ebx %edx) - 9134 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) - 9135 e9/jump $translate-mu-length-stmt:end/disp32 - 9136 } - 9137 # otherwise, the complex case - 9138 # . emit register spills - 9139 { - 9140 (string-equal? %edx "eax") # => eax - 9141 3d/compare-eax-and 0/imm32/false - 9142 75/break-if-!= break/disp8 - 9143 (emit-indent *(ebp+8) *Curr-block-depth) - 9144 (write-buffered *(ebp+8) "50/push-eax\n") - 9145 } + 9128 81 7/subop/compare %ecx 1/imm32 + 9129 75/jump-if-!= break/disp8 + 9130 (emit-save-size-to *(ebp+8) %ebx %edx) + 9131 e9/jump $translate-mu-length-stmt:end/disp32 + 9132 } + 9133 # if elemsize is a power of 2 less than 256 + 9134 { + 9135 (power-of-2? %ecx) # => eax + 9136 3d/compare-eax-and 0/imm32/false + 9137 74/jump-if-= break/disp8 + 9138 81 7/subop/compare %ecx 0xff/imm32 + 9139 7f/jump-if-> break/disp8 + 9140 (emit-save-size-to *(ebp+8) %ebx %edx) + 9141 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) + 9142 e9/jump $translate-mu-length-stmt:end/disp32 + 9143 } + 9144 # otherwise, the complex case + 9145 # . emit register spills 9146 { - 9147 (string-equal? %edx "ecx") # => eax + 9147 (string-equal? %edx "eax") # => eax 9148 3d/compare-eax-and 0/imm32/false 9149 75/break-if-!= break/disp8 - 9150 (emit-indent *(ebp+8) *Curr-block-depth) - 9151 (write-buffered *(ebp+8) "51/push-ecx\n") + 9150 (emit-indent *(ebp+8) *Curr-block-depth) + 9151 (write-buffered *(ebp+8) "50/push-eax\n") 9152 } 9153 { - 9154 (string-equal? %edx "edx") # => eax + 9154 (string-equal? %edx "ecx") # => eax 9155 3d/compare-eax-and 0/imm32/false 9156 75/break-if-!= break/disp8 - 9157 (emit-indent *(ebp+8) *Curr-block-depth) - 9158 (write-buffered *(ebp+8) "52/push-edx\n") + 9157 (emit-indent *(ebp+8) *Curr-block-depth) + 9158 (write-buffered *(ebp+8) "51/push-ecx\n") 9159 } - 9160 # . - 9161 (emit-save-size-to *(ebp+8) %ebx "eax") - 9162 (emit-indent *(ebp+8) *Curr-block-depth) - 9163 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") - 9164 (emit-indent *(ebp+8) *Curr-block-depth) - 9165 (write-buffered *(ebp+8) "b9/copy-to-ecx ") - 9166 (print-int32-buffered *(ebp+8) %ecx) - 9167 (write-buffered *(ebp+8) "/imm32\n") - 9168 (emit-indent *(ebp+8) *Curr-block-depth) - 9169 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") - 9170 { - 9171 (string-equal? %edx "eax") # => eax - 9172 3d/compare-eax-and 0/imm32/false - 9173 75/break-if-!= break/disp8 - 9174 (emit-indent *(ebp+8) *Curr-block-depth) - 9175 (write-buffered *(ebp+8) "89/<- %") - 9176 (write-buffered *(ebp+8) %edx) - 9177 (write-buffered *(ebp+8) " 0/r32/eax\n") - 9178 } - 9179 # . emit register restores - 9180 { - 9181 (string-equal? %edx "edx") # => eax - 9182 3d/compare-eax-and 0/imm32/false - 9183 75/break-if-!= break/disp8 - 9184 (emit-indent *(ebp+8) *Curr-block-depth) - 9185 (write-buffered *(ebp+8) "5a/pop-to-edx\n") - 9186 } + 9160 { + 9161 (string-equal? %edx "edx") # => eax + 9162 3d/compare-eax-and 0/imm32/false + 9163 75/break-if-!= break/disp8 + 9164 (emit-indent *(ebp+8) *Curr-block-depth) + 9165 (write-buffered *(ebp+8) "52/push-edx\n") + 9166 } + 9167 # . + 9168 (emit-save-size-to *(ebp+8) %ebx "eax") + 9169 (emit-indent *(ebp+8) *Curr-block-depth) + 9170 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") + 9171 (emit-indent *(ebp+8) *Curr-block-depth) + 9172 (write-buffered *(ebp+8) "b9/copy-to-ecx ") + 9173 (print-int32-buffered *(ebp+8) %ecx) + 9174 (write-buffered *(ebp+8) "/imm32\n") + 9175 (emit-indent *(ebp+8) *Curr-block-depth) + 9176 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") + 9177 { + 9178 (string-equal? %edx "eax") # => eax + 9179 3d/compare-eax-and 0/imm32/false + 9180 75/break-if-!= break/disp8 + 9181 (emit-indent *(ebp+8) *Curr-block-depth) + 9182 (write-buffered *(ebp+8) "89/<- %") + 9183 (write-buffered *(ebp+8) %edx) + 9184 (write-buffered *(ebp+8) " 0/r32/eax\n") + 9185 } + 9186 # . emit register restores 9187 { - 9188 (string-equal? %edx "ecx") # => eax + 9188 (string-equal? %edx "edx") # => eax 9189 3d/compare-eax-and 0/imm32/false 9190 75/break-if-!= break/disp8 - 9191 (emit-indent *(ebp+8) *Curr-block-depth) - 9192 (write-buffered *(ebp+8) "59/pop-to-ecx\n") + 9191 (emit-indent *(ebp+8) *Curr-block-depth) + 9192 (write-buffered *(ebp+8) "5a/pop-to-edx\n") 9193 } 9194 { - 9195 (string-equal? %edx "eax") # => eax + 9195 (string-equal? %edx "ecx") # => eax 9196 3d/compare-eax-and 0/imm32/false 9197 75/break-if-!= break/disp8 - 9198 (emit-indent *(ebp+8) *Curr-block-depth) - 9199 (write-buffered *(ebp+8) "58/pop-to-eax\n") + 9198 (emit-indent *(ebp+8) *Curr-block-depth) + 9199 (write-buffered *(ebp+8) "59/pop-to-ecx\n") 9200 } - 9201 $translate-mu-length-stmt:end: - 9202 # . restore registers - 9203 5e/pop-to-esi - 9204 5b/pop-to-ebx - 9205 5a/pop-to-edx - 9206 59/pop-to-ecx - 9207 58/pop-to-eax - 9208 # . epilogue - 9209 89/<- %esp 5/r32/ebp - 9210 5d/pop-to-ebp - 9211 c3/return - 9212 - 9213 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) - 9214 # . prologue - 9215 55/push-ebp - 9216 89/<- %ebp 4/r32/esp - 9217 # . save registers - 9218 50/push-eax - 9219 53/push-ebx - 9220 # ebx = base - 9221 8b/-> *(ebp+0xc) 3/r32/ebx - 9222 (emit-indent *(ebp+8) *Curr-block-depth) - 9223 (write-buffered *(ebp+8) "8b/-> *") - 9224 # if base is an (addr array ...) in a register - 9225 { - 9226 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register - 9227 74/jump-if-= break/disp8 - 9228 $emit-save-size-to:emit-base-from-register: - 9229 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 9230 (write-buffered *(ebp+8) %eax) - 9231 eb/jump $emit-save-size-to:emit-output/disp8 - 9232 } - 9233 # otherwise if base is an (array ...) on the stack - 9234 { - 9235 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset - 9236 74/jump-if-= break/disp8 - 9237 $emit-save-size-to:emit-base-from-stack: - 9238 (write-buffered *(ebp+8) "(ebp+") - 9239 (print-int32-buffered *(ebp+8) *(ebx+0x14)) # Var-offset - 9240 (write-buffered *(ebp+8) ")") - 9241 } - 9242 $emit-save-size-to:emit-output: - 9243 (write-buffered *(ebp+8) " ") - 9244 (get Registers *(ebp+0x10) 0xc "Registers") # => eax - 9245 (print-int32-buffered *(ebp+8) *eax) - 9246 (write-buffered *(ebp+8) "/r32\n") - 9247 $emit-save-size-to:end: - 9248 # . restore registers - 9249 5b/pop-to-ebx - 9250 58/pop-to-eax - 9251 # . epilogue - 9252 89/<- %esp 5/r32/ebp - 9253 5d/pop-to-ebp - 9254 c3/return - 9255 - 9256 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int - 9257 # . prologue - 9258 55/push-ebp - 9259 89/<- %ebp 4/r32/esp - 9260 # . save registers - 9261 50/push-eax - 9262 # - 9263 (emit-indent *(ebp+8) *Curr-block-depth) - 9264 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") - 9265 (write-buffered *(ebp+8) *(ebp+0xc)) - 9266 (write-buffered *(ebp+8) Space) - 9267 (num-shift-rights *(ebp+0x10)) # => eax - 9268 (print-int32-buffered *(ebp+8) %eax) - 9269 (write-buffered *(ebp+8) "/imm8\n") - 9270 $emit-divide-by-shift-right:end: - 9271 # . restore registers - 9272 58/pop-to-eax - 9273 # . epilogue - 9274 89/<- %esp 5/r32/ebp - 9275 5d/pop-to-ebp - 9276 c3/return - 9277 - 9278 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt) - 9279 # . prologue - 9280 55/push-ebp - 9281 89/<- %ebp 4/r32/esp - 9282 # . save registers - 9283 51/push-ecx - 9284 # ecx = stmt - 9285 8b/-> *(ebp+0xc) 1/r32/ecx - 9286 # var base/ecx: (addr var) = stmt->inouts[0] - 9287 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9288 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9289 89/<- %ecx 0/r32/eax - 9290 # if (var->register) do one thing - 9291 { - 9292 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register - 9293 74/jump-if-= break/disp8 - 9294 # TODO: ensure there's no dereference - 9295 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc)) - 9296 eb/jump $translate-mu-index-stmt:end/disp8 - 9297 } - 9298 # if (var->offset) do a different thing - 9299 { - 9300 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset - 9301 74/jump-if-= break/disp8 - 9302 # TODO: ensure there's no dereference - 9303 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc)) - 9304 eb/jump $translate-mu-index-stmt:end/disp8 - 9305 } - 9306 $translate-mu-index-stmt:end: - 9307 # . restore registers - 9308 59/pop-to-ecx - 9309 # . epilogue - 9310 89/<- %esp 5/r32/ebp - 9311 5d/pop-to-ebp - 9312 c3/return - 9313 - 9314 $translate-mu-index-stmt-with-array:error1: - 9315 (write-buffered Stderr "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") - 9316 (flush Stderr) - 9317 # . syscall(exit, 1) - 9318 bb/copy-to-ebx 1/imm32 - 9319 b8/copy-to-eax 1/imm32/exit - 9320 cd/syscall 0x80/imm8 - 9321 # never gets here - 9322 - 9323 $translate-mu-index-stmt-with-array:error2: - 9324 (write-buffered Stderr "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") - 9325 (flush Stderr) - 9326 # . syscall(exit, 1) - 9327 bb/copy-to-ebx 1/imm32 - 9328 b8/copy-to-eax 1/imm32/exit - 9329 cd/syscall 0x80/imm8 - 9330 # never gets here - 9331 - 9332 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt) - 9333 # . prologue - 9334 55/push-ebp - 9335 89/<- %ebp 4/r32/esp - 9336 # . save registers - 9337 50/push-eax - 9338 51/push-ecx - 9339 52/push-edx - 9340 53/push-ebx - 9341 # - 9342 (emit-indent *(ebp+8) *Curr-block-depth) - 9343 (write-buffered *(ebp+8) "8d/copy-address *(") - 9344 # TODO: ensure inouts[0] is in a register and not dereferenced - 9345 $translate-mu-index-stmt-with-array-in-register:emit-base: - 9346 # ecx = stmt - 9347 8b/-> *(ebp+0xc) 1/r32/ecx - 9348 # var base/ebx: (addr var) = inouts[0] - 9349 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9350 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9351 89/<- %ebx 0/r32/eax - 9352 # print base->register " + " - 9353 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax - 9354 (write-buffered *(ebp+8) %eax) - 9355 (write-buffered *(ebp+8) " + ") - 9356 # var index/edx: (addr var) = inouts[1] - 9357 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9358 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax - 9359 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9360 89/<- %edx 0/r32/eax - 9361 # if index->register - 9362 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register - 9363 { - 9364 0f 84/jump-if-= break/disp32 - 9365 $translate-mu-index-stmt-with-array-in-register:emit-register-index: - 9366 # if index is an int - 9367 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9368 (is-simple-mu-type? %eax 1) # int => eax - 9369 3d/compare-eax-and 0/imm32/false - 9370 { - 9371 0f 84/jump-if-= break/disp32 - 9372 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: - 9373 # print index->register "<<" log2(size-of(element(base->type))) " + 4) " - 9374 # . index->register "<<" - 9375 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 9376 (write-buffered *(ebp+8) %eax) - 9377 (write-buffered *(ebp+8) "<<") - 9378 # . log2(size-of(element(base->type))) - 9379 # TODO: ensure size is a power of 2 - 9380 (array-element-type-id %ebx) # => eax - 9381 (size-of-type-id %eax) # => eax - 9382 (num-shift-rights %eax) # => eax - 9383 (print-int32-buffered *(ebp+8) %eax) - 9384 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 - 9385 } - 9386 # if index->type is any other atom, abort - 9387 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9388 81 7/subop/compare *eax 0/imm32/false # Tree-is-atom - 9389 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 - 9390 # if index has type (offset ...) - 9391 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax - 9392 (is-simple-mu-type? %eax 7) # => eax - 9393 3d/compare-eax-and 0/imm32/false - 9394 { - 9395 0f 84/jump-if-= break/disp32 - 9396 # print index->register - 9397 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: - 9398 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 9399 (write-buffered *(ebp+8) %eax) - 9400 } - 9401 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: - 9402 (write-buffered *(ebp+8) " + 4) ") - 9403 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 - 9404 } - 9405 # otherwise if index is a literal - 9406 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9407 (is-simple-mu-type? %eax 0) # => eax - 9408 3d/compare-eax-and 0/imm32/false - 9409 { - 9410 0f 84/jump-if-= break/disp32 - 9411 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: - 9412 # var index-value/edx: int = parse-hex-int(index->name) - 9413 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 9414 (parse-hex-int %eax) # => eax - 9415 89/<- %edx 0/r32/eax - 9416 # offset = idx-value * size-of(element(base->type)) - 9417 (array-element-type-id %ebx) # => eax - 9418 (size-of-type-id %eax) # => eax - 9419 f7 4/subop/multiply-into-eax %edx # clobbers edx - 9420 # offset += 4 for array size - 9421 05/add-to-eax 4/imm32 - 9422 # TODO: check edx for overflow - 9423 # print offset - 9424 (print-int32-buffered *(ebp+8) %eax) - 9425 (write-buffered *(ebp+8) ") ") - 9426 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 - 9427 } - 9428 # otherwise abort - 9429 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 - 9430 $translate-mu-index-stmt-with-array-in-register:emit-output: - 9431 # outputs[0] "/r32" - 9432 8b/-> *(ebp+0xc) 1/r32/ecx - 9433 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9434 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9435 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9436 (get Registers %eax 0xc "Registers") # => eax: (addr int) - 9437 (print-int32-buffered *(ebp+8) *eax) - 9438 (write-buffered *(ebp+8) "/r32\n") - 9439 $translate-mu-index-stmt-with-array-in-register:end: - 9440 # . restore registers - 9441 5b/pop-to-ebx - 9442 5a/pop-to-edx - 9443 59/pop-to-ecx - 9444 58/pop-to-eax - 9445 # . epilogue - 9446 89/<- %esp 5/r32/ebp - 9447 5d/pop-to-ebp - 9448 c3/return - 9449 - 9450 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt) - 9451 # . prologue - 9452 55/push-ebp - 9453 89/<- %ebp 4/r32/esp - 9454 # . save registers - 9455 50/push-eax - 9456 51/push-ecx - 9457 52/push-edx - 9458 53/push-ebx - 9459 # - 9460 (emit-indent *(ebp+8) *Curr-block-depth) - 9461 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") - 9462 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) - 9463 8b/-> *(ebp+0xc) 0/r32/eax - 9464 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9465 89/<- %edx 0/r32/eax - 9466 # var base/ecx: (addr var) = lookup(curr->value) - 9467 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9468 89/<- %ecx 0/r32/eax - 9469 # var curr2/eax: (addr stmt-var) = lookup(curr->next) - 9470 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax - 9471 # var index/edx: (handle var) = curr2->value - 9472 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9473 89/<- %edx 0/r32/eax - 9474 # if index->register - 9475 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register - 9476 { - 9477 0f 84/jump-if-= break/disp32 - 9478 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: - 9479 # if index is an int - 9480 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9481 (is-simple-mu-type? %eax 1) # int => eax - 9482 3d/compare-eax-and 0/imm32/false - 9483 { - 9484 0f 84/jump-if-= break/disp32 - 9485 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: - 9486 # print index->register "<<" log2(size-of(element-type(base))) " + " base->offset+4 - 9487 # . inouts[1]->register "<<" - 9488 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 9489 (write-buffered *(ebp+8) %eax) - 9490 (write-buffered *(ebp+8) "<<") - 9491 # . log2(size-of(element(base))) - 9492 # TODO: ensure size is a power of 2 - 9493 (array-element-type-id %ecx) # => eax - 9494 (size-of-type-id %eax) # => eax - 9495 (num-shift-rights %eax) # => eax - 9496 (print-int32-buffered *(ebp+8) %eax) - 9497 # - 9498 (write-buffered *(ebp+8) " + ") - 9499 # - 9500 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset - 9501 05/add-to-eax 4/imm32 # for array length - 9502 (print-int32-buffered *(ebp+8) %eax) - 9503 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 - 9504 } - 9505 # if index->type is any other atom, abort - 9506 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9507 81 7/subop/compare *eax 0/imm32/false # Tree-is-atom - 9508 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 - 9509 # if index has type (offset ...) - 9510 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax - 9511 (is-simple-mu-type? %eax 7) # => eax - 9512 3d/compare-eax-and 0/imm32/false - 9513 { - 9514 0f 84/jump-if-= break/disp32 - 9515 # print index->register - 9516 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: - 9517 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax - 9518 (write-buffered *(ebp+8) %eax) - 9519 } - 9520 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: - 9521 (write-buffered *(ebp+8) ") ") - 9522 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 - 9523 } - 9524 # otherwise if index is a literal - 9525 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax - 9526 (is-simple-mu-type? %eax 0) # => eax - 9527 3d/compare-eax-and 0/imm32/false - 9528 { - 9529 0f 84/jump-if-= break/disp32 - 9530 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: - 9531 # var idx-value/edx: int = parse-hex-int(index->name) - 9532 (lookup *edx *(edx+4)) # Var-name Var-name => eax - 9533 (parse-hex-int %eax) # Var-name => eax - 9534 89/<- %edx 0/r32/eax - 9535 # offset = idx-value * size-of(element-type(base->type)) - 9536 (array-element-type-id %ecx) # => eax - 9537 (size-of-type-id %eax) # => eax - 9538 f7 4/subop/multiply-into-eax %edx # clobbers edx - 9539 # offset += base->offset - 9540 03/add *(ecx+0x14) 0/r32/eax # Var-offset - 9541 # offset += 4 for array size - 9542 05/add-to-eax 4/imm32 - 9543 # TODO: check edx for overflow - 9544 # print offset - 9545 (print-int32-buffered *(ebp+8) %eax) - 9546 (write-buffered *(ebp+8) ") ") - 9547 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 - 9548 } - 9549 # otherwise abort - 9550 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 - 9551 $translate-mu-index-stmt-with-array-on-stack:emit-output: - 9552 # outputs[0] "/r32" - 9553 8b/-> *(ebp+0xc) 0/r32/eax - 9554 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9555 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9556 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9557 (get Registers %eax 0xc "Registers") # => eax: (addr int) - 9558 (print-int32-buffered *(ebp+8) *eax) - 9559 (write-buffered *(ebp+8) "/r32\n") - 9560 $translate-mu-index-stmt-with-array-on-stack:end: - 9561 # . restore registers - 9562 5b/pop-to-ebx - 9563 5a/pop-to-edx - 9564 59/pop-to-ecx - 9565 58/pop-to-eax - 9566 # . epilogue - 9567 89/<- %esp 5/r32/ebp - 9568 5d/pop-to-ebp - 9569 c3/return - 9570 - 9571 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt) - 9572 # . prologue - 9573 55/push-ebp - 9574 89/<- %ebp 4/r32/esp - 9575 # . save registers - 9576 50/push-eax - 9577 51/push-ecx - 9578 52/push-edx - 9579 53/push-ebx - 9580 # - 9581 (emit-indent *(ebp+8) *Curr-block-depth) - 9582 (write-buffered *(ebp+8) "69/multiply") - 9583 # ecx = stmt - 9584 8b/-> *(ebp+0xc) 1/r32/ecx - 9585 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] - 9586 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9587 89/<- %ebx 0/r32/eax - 9588 $translate-mu-compute-index-stmt:emit-index: - 9589 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax - 9590 (emit-subx-var-as-rm32 *(ebp+8) %eax) - 9591 (write-buffered *(ebp+8) Space) - 9592 $translate-mu-compute-index-stmt:emit-elem-size: - 9593 # var base/ebx: (addr var) - 9594 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax - 9595 89/<- %ebx 0/r32/eax - 9596 # print size-of(element(base->type)) - 9597 (array-element-type-id %ebx) # => eax - 9598 (size-of-type-id %eax) # => eax - 9599 (print-int32-buffered *(ebp+8) %eax) - 9600 (write-buffered *(ebp+8) "/imm32 ") - 9601 $translate-mu-compute-index-stmt:emit-output: - 9602 # outputs[0] "/r32" - 9603 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9604 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9605 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9606 (get Registers %eax 0xc "Registers") # => eax: (addr int) - 9607 (print-int32-buffered *(ebp+8) *eax) - 9608 (write-buffered *(ebp+8) "/r32\n") - 9609 $translate-mu-compute-index-stmt:end: - 9610 # . restore registers - 9611 5b/pop-to-ebx - 9612 5a/pop-to-edx - 9613 59/pop-to-ecx - 9614 58/pop-to-eax - 9615 # . epilogue - 9616 89/<- %esp 5/r32/ebp - 9617 5d/pop-to-ebp - 9618 c3/return - 9619 - 9620 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) - 9621 # . prologue - 9622 55/push-ebp - 9623 89/<- %ebp 4/r32/esp - 9624 # . save registers - 9625 50/push-eax - 9626 51/push-ecx - 9627 52/push-edx - 9628 # - 9629 (emit-indent *(ebp+8) *Curr-block-depth) - 9630 (write-buffered *(ebp+8) "8d/copy-address ") - 9631 # ecx = stmt - 9632 8b/-> *(ebp+0xc) 1/r32/ecx - 9633 # var offset/edx: int = get offset of stmt - 9634 (mu-get-offset %ecx) # => eax - 9635 89/<- %edx 0/r32/eax - 9636 # var base/eax: (addr var) = stmt->inouts->value - 9637 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9638 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9639 # if base is in a register - 9640 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register - 9641 { - 9642 0f 84/jump-if-= break/disp32 - 9643 $translate-mu-get-stmt:emit-register-input: - 9644 # emit "*(" base->register " + " offset ") " - 9645 (write-buffered *(ebp+8) "*(") - 9646 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9647 (write-buffered *(ebp+8) %eax) - 9648 (write-buffered *(ebp+8) " + ") - 9649 (print-int32-buffered *(ebp+8) %edx) - 9650 (write-buffered *(ebp+8) ") ") - 9651 e9/jump $translate-mu-get-stmt:emit-output/disp32 - 9652 } - 9653 # otherwise base is on the stack - 9654 { - 9655 $translate-mu-get-stmt:emit-stack-input: - 9656 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " - 9657 (write-buffered *(ebp+8) "*(ebp+") - 9658 03/add *(eax+0x14) 2/r32/edx # Var-offset - 9659 (print-int32-buffered *(ebp+8) %edx) - 9660 (write-buffered *(ebp+8) ") ") - 9661 eb/jump $translate-mu-get-stmt:emit-output/disp8 - 9662 } - 9663 $translate-mu-get-stmt:emit-output: - 9664 # var output/eax: (addr var) = stmt->outputs->value - 9665 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax - 9666 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9667 # emit offset->register "/r32" - 9668 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax - 9669 (get Registers %eax 0xc "Registers") # => eax: (addr int) - 9670 (print-int32-buffered *(ebp+8) *eax) - 9671 (write-buffered *(ebp+8) "/r32\n") - 9672 $translate-mu-get-stmt:end: - 9673 # . restore registers - 9674 5a/pop-to-edx - 9675 59/pop-to-ecx - 9676 58/pop-to-eax - 9677 # . epilogue - 9678 89/<- %esp 5/r32/ebp - 9679 5d/pop-to-ebp - 9680 c3/return - 9681 - 9682 array-element-type-id: # v: (addr var) -> result/eax: type-id - 9683 # precondition: n is positive - 9684 # . prologue - 9685 55/push-ebp - 9686 89/<- %ebp 4/r32/esp - 9687 # - 9688 8b/-> *(ebp+8) 0/r32/eax - 9689 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax - 9690 # TODO: ensure type->left is 'addr' - 9691 (lookup *(eax+0xc) *(eax+0x10)) # Tree-right Tree-right => eax - 9692 # TODO: ensure that type->right is non-null - 9693 # TODO: ensure that type->right->left is 'array' - 9694 (lookup *(eax+0xc) *(eax+0x10)) # Tree-right Tree-right => eax - 9695 # TODO: ensure that type->right->right is non-null - 9696 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax - 9697 8b/-> *(eax+4) 0/r32/eax # Tree-value - 9698 $array-element-type-id:end: - 9699 # . epilogue - 9700 89/<- %esp 5/r32/ebp - 9701 5d/pop-to-ebp - 9702 c3/return - 9703 - 9704 power-of-2?: # n: int -> result/eax: boolean - 9705 # precondition: n is positive - 9706 # . prologue - 9707 55/push-ebp - 9708 89/<- %ebp 4/r32/esp - 9709 # eax = n - 9710 8b/-> *(ebp+8) 0/r32/eax - 9711 # if (n < 0) abort - 9712 3d/compare-eax-with 0/imm32 - 9713 0f 8c/jump-if-< $power-of-2?:abort/disp32 - 9714 # var tmp/eax: int = n-1 - 9715 48/decrement-eax - 9716 # var tmp2/eax: int = n & tmp - 9717 23/and-> *(ebp+8) 0/r32/eax - 9718 # return (tmp2 == 0) - 9719 3d/compare-eax-and 0/imm32 - 9720 0f 94/set-byte-if-= %al - 9721 81 4/subop/and %eax 0xff/imm32 - 9722 $power-of-2?:end: - 9723 # . epilogue - 9724 89/<- %esp 5/r32/ebp - 9725 5d/pop-to-ebp - 9726 c3/return - 9727 - 9728 $power-of-2?:abort: - 9729 (write-buffered Stderr "power-of-2?: negative number\n") - 9730 (flush Stderr) - 9731 # . syscall(exit, 1) - 9732 bb/copy-to-ebx 1/imm32 - 9733 b8/copy-to-eax 1/imm32/exit - 9734 cd/syscall 0x80/imm8 - 9735 # never gets here - 9736 - 9737 num-shift-rights: # n: int -> result/eax: int - 9738 # precondition: n is a positive power of 2 - 9739 # . prologue - 9740 55/push-ebp - 9741 89/<- %ebp 4/r32/esp - 9742 # . save registers - 9743 51/push-ecx - 9744 # var curr/ecx: int = n - 9745 8b/-> *(ebp+8) 1/r32/ecx - 9746 # result = 0 - 9747 b8/copy-to-eax 0/imm32 - 9748 { - 9749 # if (curr <= 1) break - 9750 81 7/subop/compare %ecx 1/imm32 - 9751 7e/jump-if-<= break/disp8 - 9752 40/increment-eax - 9753 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 - 9754 eb/jump loop/disp8 - 9755 } - 9756 $num-shift-rights:end: - 9757 # . restore registers - 9758 59/pop-to-ecx - 9759 # . epilogue - 9760 89/<- %esp 5/r32/ebp - 9761 5d/pop-to-ebp - 9762 c3/return - 9763 - 9764 mu-get-offset: # stmt: (addr stmt) -> result/eax: int - 9765 # . prologue - 9766 55/push-ebp - 9767 89/<- %ebp 4/r32/esp - 9768 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next - 9769 8b/-> *(ebp+8) 0/r32/eax - 9770 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax - 9771 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax - 9772 # var output-var/eax: (addr var) = second-inout->value - 9773 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax - 9774 #? (write-buffered Stderr "mu-get-offset: ") - 9775 #? (print-int32-buffered Stderr %eax) - 9776 #? (write-buffered Stderr " name: ") - 9777 #? 50/push-eax - 9778 #? (lookup *eax *(eax+4)) # Var-name - 9779 #? (write-buffered Stderr %eax) - 9780 #? 58/pop-to-eax - 9781 #? (write-buffered Stderr Newline) - 9782 #? (flush Stderr) - 9783 # return output-var->stack-offset - 9784 8b/-> *(eax+0x14) 0/r32/eax # Var-offset - 9785 #? (write-buffered Stderr "=> ") - 9786 #? (print-int32-buffered Stderr %eax) - 9787 #? (write-buffered Stderr Newline) - 9788 #? (flush Stderr) - 9789 $emit-get-offset:end: - 9790 # . epilogue - 9791 89/<- %esp 5/r32/ebp - 9792 5d/pop-to-ebp - 9793 c3/return - 9794 - 9795 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack (handle var)) - 9796 # . prologue - 9797 55/push-ebp - 9798 89/<- %ebp 4/r32/esp - 9799 # . save registers - 9800 50/push-eax - 9801 51/push-ecx - 9802 56/push-esi - 9803 # esi = block - 9804 8b/-> *(ebp+0xc) 6/r32/esi - 9805 # block->var->block-depth = *Curr-block-depth - 9806 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax - 9807 8b/-> *Curr-block-depth 1/r32/ecx - 9808 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth - 9809 # var stmts/eax: (addr list stmt) = lookup(block->statements) - 9810 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax - 9811 # - 9812 { - 9813 $emit-subx-block:check-empty: - 9814 3d/compare-eax-and 0/imm32 - 9815 0f 84/jump-if-= break/disp32 - 9816 (emit-indent *(ebp+8) *Curr-block-depth) - 9817 (write-buffered *(ebp+8) "{\n") - 9818 # var v/ecx: (addr var) = lookup(block->var) - 9819 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax - 9820 89/<- %ecx 0/r32/eax - 9821 # - 9822 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax - 9823 (write-buffered *(ebp+8) %eax) - 9824 (write-buffered *(ebp+8) ":loop:\n") - 9825 ff 0/subop/increment *Curr-block-depth - 9826 (push *(ebp+0x10) *(esi+0xc)) # Block-var - 9827 (push *(ebp+0x10) *(esi+0x10)) # Block-var - 9828 # emit block->statements - 9829 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax - 9830 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10)) - 9831 (pop *(ebp+0x10)) # => eax - 9832 (pop *(ebp+0x10)) # => eax - 9833 ff 1/subop/decrement *Curr-block-depth - 9834 (emit-indent *(ebp+8) *Curr-block-depth) - 9835 (write-buffered *(ebp+8) "}\n") - 9836 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax - 9837 (write-buffered *(ebp+8) %eax) - 9838 (write-buffered *(ebp+8) ":break:\n") - 9839 } - 9840 $emit-subx-block:end: - 9841 # . restore registers - 9842 5e/pop-to-esi - 9843 59/pop-to-ecx - 9844 58/pop-to-eax - 9845 # . epilogue - 9846 89/<- %esp 5/r32/ebp - 9847 5d/pop-to-ebp - 9848 c3/return - 9849 - 9850 # Primitives supported - 9851 # See mu_instructions for a summary of this linked-list data structure. - 9852 # - 9853 # For each operation, put variants with hard-coded registers before flexible ones. - 9854 # - 9855 # Unfortunately, our restrictions on addresses require that various fields in - 9856 # primitives be handles, which complicates these definitions. - 9857 # - we need to insert dummy fields all over the place for fake alloc-ids - 9858 # - we can't use our syntax sugar of quoted literals for string fields + 9201 { + 9202 (string-equal? %edx "eax") # => eax + 9203 3d/compare-eax-and 0/imm32/false + 9204 75/break-if-!= break/disp8 + 9205 (emit-indent *(ebp+8) *Curr-block-depth) + 9206 (write-buffered *(ebp+8) "58/pop-to-eax\n") + 9207 } + 9208 $translate-mu-length-stmt:end: + 9209 # . restore registers + 9210 5e/pop-to-esi + 9211 5b/pop-to-ebx + 9212 5a/pop-to-edx + 9213 59/pop-to-ecx + 9214 58/pop-to-eax + 9215 # . epilogue + 9216 89/<- %esp 5/r32/ebp + 9217 5d/pop-to-ebp + 9218 c3/return + 9219 + 9220 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) + 9221 # . prologue + 9222 55/push-ebp + 9223 89/<- %ebp 4/r32/esp + 9224 # . save registers + 9225 50/push-eax + 9226 53/push-ebx + 9227 # ebx = base + 9228 8b/-> *(ebp+0xc) 3/r32/ebx + 9229 (emit-indent *(ebp+8) *Curr-block-depth) + 9230 (write-buffered *(ebp+8) "8b/-> *") + 9231 # if base is an (addr array ...) in a register + 9232 { + 9233 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register + 9234 74/jump-if-= break/disp8 + 9235 $emit-save-size-to:emit-base-from-register: + 9236 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 9237 (write-buffered *(ebp+8) %eax) + 9238 eb/jump $emit-save-size-to:emit-output/disp8 + 9239 } + 9240 # otherwise if base is an (array ...) on the stack + 9241 { + 9242 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset + 9243 74/jump-if-= break/disp8 + 9244 $emit-save-size-to:emit-base-from-stack: + 9245 (write-buffered *(ebp+8) "(ebp+") + 9246 (print-int32-buffered *(ebp+8) *(ebx+0x14)) # Var-offset + 9247 (write-buffered *(ebp+8) ")") + 9248 } + 9249 $emit-save-size-to:emit-output: + 9250 (write-buffered *(ebp+8) " ") + 9251 (get Registers *(ebp+0x10) 0xc "Registers") # => eax + 9252 (print-int32-buffered *(ebp+8) *eax) + 9253 (write-buffered *(ebp+8) "/r32\n") + 9254 $emit-save-size-to:end: + 9255 # . restore registers + 9256 5b/pop-to-ebx + 9257 58/pop-to-eax + 9258 # . epilogue + 9259 89/<- %esp 5/r32/ebp + 9260 5d/pop-to-ebp + 9261 c3/return + 9262 + 9263 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int + 9264 # . prologue + 9265 55/push-ebp + 9266 89/<- %ebp 4/r32/esp + 9267 # . save registers + 9268 50/push-eax + 9269 # + 9270 (emit-indent *(ebp+8) *Curr-block-depth) + 9271 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") + 9272 (write-buffered *(ebp+8) *(ebp+0xc)) + 9273 (write-buffered *(ebp+8) Space) + 9274 (num-shift-rights *(ebp+0x10)) # => eax + 9275 (print-int32-buffered *(ebp+8) %eax) + 9276 (write-buffered *(ebp+8) "/imm8\n") + 9277 $emit-divide-by-shift-right:end: + 9278 # . restore registers + 9279 58/pop-to-eax + 9280 # . epilogue + 9281 89/<- %esp 5/r32/ebp + 9282 5d/pop-to-ebp + 9283 c3/return + 9284 + 9285 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt) + 9286 # . prologue + 9287 55/push-ebp + 9288 89/<- %ebp 4/r32/esp + 9289 # . save registers + 9290 51/push-ecx + 9291 # ecx = stmt + 9292 8b/-> *(ebp+0xc) 1/r32/ecx + 9293 # var base/ecx: (addr var) = stmt->inouts[0] + 9294 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9295 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9296 89/<- %ecx 0/r32/eax + 9297 # if (var->register) do one thing + 9298 { + 9299 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register + 9300 74/jump-if-= break/disp8 + 9301 # TODO: ensure there's no dereference + 9302 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc)) + 9303 eb/jump $translate-mu-index-stmt:end/disp8 + 9304 } + 9305 # if (var->offset) do a different thing + 9306 { + 9307 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset + 9308 74/jump-if-= break/disp8 + 9309 # TODO: ensure there's no dereference + 9310 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc)) + 9311 eb/jump $translate-mu-index-stmt:end/disp8 + 9312 } + 9313 $translate-mu-index-stmt:end: + 9314 # . restore registers + 9315 59/pop-to-ecx + 9316 # . epilogue + 9317 89/<- %esp 5/r32/ebp + 9318 5d/pop-to-ebp + 9319 c3/return + 9320 + 9321 $translate-mu-index-stmt-with-array:error1: + 9322 (write-buffered Stderr "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") + 9323 (flush Stderr) + 9324 # . syscall(exit, 1) + 9325 bb/copy-to-ebx 1/imm32 + 9326 b8/copy-to-eax 1/imm32/exit + 9327 cd/syscall 0x80/imm8 + 9328 # never gets here + 9329 + 9330 $translate-mu-index-stmt-with-array:error2: + 9331 (write-buffered Stderr "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") + 9332 (flush Stderr) + 9333 # . syscall(exit, 1) + 9334 bb/copy-to-ebx 1/imm32 + 9335 b8/copy-to-eax 1/imm32/exit + 9336 cd/syscall 0x80/imm8 + 9337 # never gets here + 9338 + 9339 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt) + 9340 # . prologue + 9341 55/push-ebp + 9342 89/<- %ebp 4/r32/esp + 9343 # . save registers + 9344 50/push-eax + 9345 51/push-ecx + 9346 52/push-edx + 9347 53/push-ebx + 9348 # + 9349 (emit-indent *(ebp+8) *Curr-block-depth) + 9350 (write-buffered *(ebp+8) "8d/copy-address *(") + 9351 # TODO: ensure inouts[0] is in a register and not dereferenced + 9352 $translate-mu-index-stmt-with-array-in-register:emit-base: + 9353 # ecx = stmt + 9354 8b/-> *(ebp+0xc) 1/r32/ecx + 9355 # var base/ebx: (addr var) = inouts[0] + 9356 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9357 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9358 89/<- %ebx 0/r32/eax + 9359 # print base->register " + " + 9360 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax + 9361 (write-buffered *(ebp+8) %eax) + 9362 (write-buffered *(ebp+8) " + ") + 9363 # var index/edx: (addr var) = inouts[1] + 9364 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9365 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + 9366 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9367 89/<- %edx 0/r32/eax + 9368 # if index->register + 9369 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register + 9370 { + 9371 0f 84/jump-if-= break/disp32 + 9372 $translate-mu-index-stmt-with-array-in-register:emit-register-index: + 9373 # if index is an int + 9374 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9375 (is-simple-mu-type? %eax 1) # int => eax + 9376 3d/compare-eax-and 0/imm32/false + 9377 { + 9378 0f 84/jump-if-= break/disp32 + 9379 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: + 9380 # print index->register "<<" log2(size-of(element(base->type))) " + 4) " + 9381 # . index->register "<<" + 9382 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 9383 (write-buffered *(ebp+8) %eax) + 9384 (write-buffered *(ebp+8) "<<") + 9385 # . log2(size-of(element(base->type))) + 9386 # TODO: ensure size is a power of 2 + 9387 (array-element-type-id %ebx) # => eax + 9388 (size-of-type-id %eax) # => eax + 9389 (num-shift-rights %eax) # => eax + 9390 (print-int32-buffered *(ebp+8) %eax) + 9391 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 + 9392 } + 9393 # if index->type is any other atom, abort + 9394 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9395 81 7/subop/compare *eax 0/imm32/false # Tree-is-atom + 9396 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 + 9397 # if index has type (offset ...) + 9398 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax + 9399 (is-simple-mu-type? %eax 7) # => eax + 9400 3d/compare-eax-and 0/imm32/false + 9401 { + 9402 0f 84/jump-if-= break/disp32 + 9403 # print index->register + 9404 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: + 9405 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 9406 (write-buffered *(ebp+8) %eax) + 9407 } + 9408 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: + 9409 (write-buffered *(ebp+8) " + 4) ") + 9410 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 + 9411 } + 9412 # otherwise if index is a literal + 9413 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9414 (is-simple-mu-type? %eax 0) # => eax + 9415 3d/compare-eax-and 0/imm32/false + 9416 { + 9417 0f 84/jump-if-= break/disp32 + 9418 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: + 9419 # var index-value/edx: int = parse-hex-int(index->name) + 9420 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 9421 (parse-hex-int %eax) # => eax + 9422 89/<- %edx 0/r32/eax + 9423 # offset = idx-value * size-of(element(base->type)) + 9424 (array-element-type-id %ebx) # => eax + 9425 (size-of-type-id %eax) # => eax + 9426 f7 4/subop/multiply-into-eax %edx # clobbers edx + 9427 # offset += 4 for array size + 9428 05/add-to-eax 4/imm32 + 9429 # TODO: check edx for overflow + 9430 # print offset + 9431 (print-int32-buffered *(ebp+8) %eax) + 9432 (write-buffered *(ebp+8) ") ") + 9433 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 + 9434 } + 9435 # otherwise abort + 9436 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 + 9437 $translate-mu-index-stmt-with-array-in-register:emit-output: + 9438 # outputs[0] "/r32" + 9439 8b/-> *(ebp+0xc) 1/r32/ecx + 9440 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9441 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9442 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9443 (get Registers %eax 0xc "Registers") # => eax: (addr int) + 9444 (print-int32-buffered *(ebp+8) *eax) + 9445 (write-buffered *(ebp+8) "/r32\n") + 9446 $translate-mu-index-stmt-with-array-in-register:end: + 9447 # . restore registers + 9448 5b/pop-to-ebx + 9449 5a/pop-to-edx + 9450 59/pop-to-ecx + 9451 58/pop-to-eax + 9452 # . epilogue + 9453 89/<- %esp 5/r32/ebp + 9454 5d/pop-to-ebp + 9455 c3/return + 9456 + 9457 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt) + 9458 # . prologue + 9459 55/push-ebp + 9460 89/<- %ebp 4/r32/esp + 9461 # . save registers + 9462 50/push-eax + 9463 51/push-ecx + 9464 52/push-edx + 9465 53/push-ebx + 9466 # + 9467 (emit-indent *(ebp+8) *Curr-block-depth) + 9468 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") + 9469 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) + 9470 8b/-> *(ebp+0xc) 0/r32/eax + 9471 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9472 89/<- %edx 0/r32/eax + 9473 # var base/ecx: (addr var) = lookup(curr->value) + 9474 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9475 89/<- %ecx 0/r32/eax + 9476 # var curr2/eax: (addr stmt-var) = lookup(curr->next) + 9477 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax + 9478 # var index/edx: (handle var) = curr2->value + 9479 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9480 89/<- %edx 0/r32/eax + 9481 # if index->register + 9482 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register + 9483 { + 9484 0f 84/jump-if-= break/disp32 + 9485 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: + 9486 # if index is an int + 9487 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9488 (is-simple-mu-type? %eax 1) # int => eax + 9489 3d/compare-eax-and 0/imm32/false + 9490 { + 9491 0f 84/jump-if-= break/disp32 + 9492 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: + 9493 # print index->register "<<" log2(size-of(element-type(base))) " + " base->offset+4 + 9494 # . inouts[1]->register "<<" + 9495 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 9496 (write-buffered *(ebp+8) %eax) + 9497 (write-buffered *(ebp+8) "<<") + 9498 # . log2(size-of(element(base))) + 9499 # TODO: ensure size is a power of 2 + 9500 (array-element-type-id %ecx) # => eax + 9501 (size-of-type-id %eax) # => eax + 9502 (num-shift-rights %eax) # => eax + 9503 (print-int32-buffered *(ebp+8) %eax) + 9504 # + 9505 (write-buffered *(ebp+8) " + ") + 9506 # + 9507 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset + 9508 05/add-to-eax 4/imm32 # for array length + 9509 (print-int32-buffered *(ebp+8) %eax) + 9510 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 + 9511 } + 9512 # if index->type is any other atom, abort + 9513 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9514 81 7/subop/compare *eax 0/imm32/false # Tree-is-atom + 9515 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 + 9516 # if index has type (offset ...) + 9517 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax + 9518 (is-simple-mu-type? %eax 7) # => eax + 9519 3d/compare-eax-and 0/imm32/false + 9520 { + 9521 0f 84/jump-if-= break/disp32 + 9522 # print index->register + 9523 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: + 9524 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax + 9525 (write-buffered *(ebp+8) %eax) + 9526 } + 9527 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: + 9528 (write-buffered *(ebp+8) ") ") + 9529 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 + 9530 } + 9531 # otherwise if index is a literal + 9532 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax + 9533 (is-simple-mu-type? %eax 0) # => eax + 9534 3d/compare-eax-and 0/imm32/false + 9535 { + 9536 0f 84/jump-if-= break/disp32 + 9537 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: + 9538 # var idx-value/edx: int = parse-hex-int(index->name) + 9539 (lookup *edx *(edx+4)) # Var-name Var-name => eax + 9540 (parse-hex-int %eax) # Var-name => eax + 9541 89/<- %edx 0/r32/eax + 9542 # offset = idx-value * size-of(element-type(base->type)) + 9543 (array-element-type-id %ecx) # => eax + 9544 (size-of-type-id %eax) # => eax + 9545 f7 4/subop/multiply-into-eax %edx # clobbers edx + 9546 # offset += base->offset + 9547 03/add *(ecx+0x14) 0/r32/eax # Var-offset + 9548 # offset += 4 for array size + 9549 05/add-to-eax 4/imm32 + 9550 # TODO: check edx for overflow + 9551 # print offset + 9552 (print-int32-buffered *(ebp+8) %eax) + 9553 (write-buffered *(ebp+8) ") ") + 9554 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 + 9555 } + 9556 # otherwise abort + 9557 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 + 9558 $translate-mu-index-stmt-with-array-on-stack:emit-output: + 9559 # outputs[0] "/r32" + 9560 8b/-> *(ebp+0xc) 0/r32/eax + 9561 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9562 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9563 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9564 (get Registers %eax 0xc "Registers") # => eax: (addr int) + 9565 (print-int32-buffered *(ebp+8) *eax) + 9566 (write-buffered *(ebp+8) "/r32\n") + 9567 $translate-mu-index-stmt-with-array-on-stack:end: + 9568 # . restore registers + 9569 5b/pop-to-ebx + 9570 5a/pop-to-edx + 9571 59/pop-to-ecx + 9572 58/pop-to-eax + 9573 # . epilogue + 9574 89/<- %esp 5/r32/ebp + 9575 5d/pop-to-ebp + 9576 c3/return + 9577 + 9578 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt) + 9579 # . prologue + 9580 55/push-ebp + 9581 89/<- %ebp 4/r32/esp + 9582 # . save registers + 9583 50/push-eax + 9584 51/push-ecx + 9585 52/push-edx + 9586 53/push-ebx + 9587 # + 9588 (emit-indent *(ebp+8) *Curr-block-depth) + 9589 (write-buffered *(ebp+8) "69/multiply") + 9590 # ecx = stmt + 9591 8b/-> *(ebp+0xc) 1/r32/ecx + 9592 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] + 9593 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9594 89/<- %ebx 0/r32/eax + 9595 $translate-mu-compute-index-stmt:emit-index: + 9596 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax + 9597 (emit-subx-var-as-rm32 *(ebp+8) %eax) + 9598 (write-buffered *(ebp+8) Space) + 9599 $translate-mu-compute-index-stmt:emit-elem-size: + 9600 # var base/ebx: (addr var) + 9601 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax + 9602 89/<- %ebx 0/r32/eax + 9603 # print size-of(element(base->type)) + 9604 (array-element-type-id %ebx) # => eax + 9605 (size-of-type-id %eax) # => eax + 9606 (print-int32-buffered *(ebp+8) %eax) + 9607 (write-buffered *(ebp+8) "/imm32 ") + 9608 $translate-mu-compute-index-stmt:emit-output: + 9609 # outputs[0] "/r32" + 9610 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9611 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9612 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9613 (get Registers %eax 0xc "Registers") # => eax: (addr int) + 9614 (print-int32-buffered *(ebp+8) *eax) + 9615 (write-buffered *(ebp+8) "/r32\n") + 9616 $translate-mu-compute-index-stmt:end: + 9617 # . restore registers + 9618 5b/pop-to-ebx + 9619 5a/pop-to-edx + 9620 59/pop-to-ecx + 9621 58/pop-to-eax + 9622 # . epilogue + 9623 89/<- %esp 5/r32/ebp + 9624 5d/pop-to-ebp + 9625 c3/return + 9626 + 9627 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) + 9628 # . prologue + 9629 55/push-ebp + 9630 89/<- %ebp 4/r32/esp + 9631 # . save registers + 9632 50/push-eax + 9633 51/push-ecx + 9634 52/push-edx + 9635 # + 9636 (emit-indent *(ebp+8) *Curr-block-depth) + 9637 (write-buffered *(ebp+8) "8d/copy-address ") + 9638 # ecx = stmt + 9639 8b/-> *(ebp+0xc) 1/r32/ecx + 9640 # var offset/edx: int = get offset of stmt + 9641 (mu-get-offset %ecx) # => eax + 9642 89/<- %edx 0/r32/eax + 9643 # var base/eax: (addr var) = stmt->inouts->value + 9644 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9645 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9646 # if base is in a register + 9647 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register + 9648 { + 9649 0f 84/jump-if-= break/disp32 + 9650 $translate-mu-get-stmt:emit-register-input: + 9651 # emit "*(" base->register " + " offset ") " + 9652 (write-buffered *(ebp+8) "*(") + 9653 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9654 (write-buffered *(ebp+8) %eax) + 9655 (write-buffered *(ebp+8) " + ") + 9656 (print-int32-buffered *(ebp+8) %edx) + 9657 (write-buffered *(ebp+8) ") ") + 9658 e9/jump $translate-mu-get-stmt:emit-output/disp32 + 9659 } + 9660 # otherwise base is on the stack + 9661 { + 9662 $translate-mu-get-stmt:emit-stack-input: + 9663 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " + 9664 (write-buffered *(ebp+8) "*(ebp+") + 9665 03/add *(eax+0x14) 2/r32/edx # Var-offset + 9666 (print-int32-buffered *(ebp+8) %edx) + 9667 (write-buffered *(ebp+8) ") ") + 9668 eb/jump $translate-mu-get-stmt:emit-output/disp8 + 9669 } + 9670 $translate-mu-get-stmt:emit-output: + 9671 # var output/eax: (addr var) = stmt->outputs->value + 9672 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax + 9673 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9674 # emit offset->register "/r32" + 9675 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax + 9676 (get Registers %eax 0xc "Registers") # => eax: (addr int) + 9677 (print-int32-buffered *(ebp+8) *eax) + 9678 (write-buffered *(ebp+8) "/r32\n") + 9679 $translate-mu-get-stmt:end: + 9680 # . restore registers + 9681 5a/pop-to-edx + 9682 59/pop-to-ecx + 9683 58/pop-to-eax + 9684 # . epilogue + 9685 89/<- %esp 5/r32/ebp + 9686 5d/pop-to-ebp + 9687 c3/return + 9688 + 9689 array-element-type-id: # v: (addr var) -> result/eax: type-id + 9690 # precondition: n is positive + 9691 # . prologue + 9692 55/push-ebp + 9693 89/<- %ebp 4/r32/esp + 9694 # + 9695 8b/-> *(ebp+8) 0/r32/eax + 9696 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax + 9697 # TODO: ensure type->left is 'addr' + 9698 (lookup *(eax+0xc) *(eax+0x10)) # Tree-right Tree-right => eax + 9699 # TODO: ensure that type->right is non-null + 9700 # TODO: ensure that type->right->left is 'array' + 9701 (lookup *(eax+0xc) *(eax+0x10)) # Tree-right Tree-right => eax + 9702 # TODO: ensure that type->right->right is non-null + 9703 (lookup *(eax+4) *(eax+8)) # Tree-left Tree-left => eax + 9704 8b/-> *(eax+4) 0/r32/eax # Tree-value + 9705 $array-element-type-id:end: + 9706 # . epilogue + 9707 89/<- %esp 5/r32/ebp + 9708 5d/pop-to-ebp + 9709 c3/return + 9710 + 9711 power-of-2?: # n: int -> result/eax: boolean + 9712 # precondition: n is positive + 9713 # . prologue + 9714 55/push-ebp + 9715 89/<- %ebp 4/r32/esp + 9716 # eax = n + 9717 8b/-> *(ebp+8) 0/r32/eax + 9718 # if (n < 0) abort + 9719 3d/compare-eax-with 0/imm32 + 9720 0f 8c/jump-if-< $power-of-2?:abort/disp32 + 9721 # var tmp/eax: int = n-1 + 9722 48/decrement-eax + 9723 # var tmp2/eax: int = n & tmp + 9724 23/and-> *(ebp+8) 0/r32/eax + 9725 # return (tmp2 == 0) + 9726 3d/compare-eax-and 0/imm32 + 9727 0f 94/set-byte-if-= %al + 9728 81 4/subop/and %eax 0xff/imm32 + 9729 $power-of-2?:end: + 9730 # . epilogue + 9731 89/<- %esp 5/r32/ebp + 9732 5d/pop-to-ebp + 9733 c3/return + 9734 + 9735 $power-of-2?:abort: + 9736 (write-buffered Stderr "power-of-2?: negative number\n") + 9737 (flush Stderr) + 9738 # . syscall(exit, 1) + 9739 bb/copy-to-ebx 1/imm32 + 9740 b8/copy-to-eax 1/imm32/exit + 9741 cd/syscall 0x80/imm8 + 9742 # never gets here + 9743 + 9744 num-shift-rights: # n: int -> result/eax: int + 9745 # precondition: n is a positive power of 2 + 9746 # . prologue + 9747 55/push-ebp + 9748 89/<- %ebp 4/r32/esp + 9749 # . save registers + 9750 51/push-ecx + 9751 # var curr/ecx: int = n + 9752 8b/-> *(ebp+8) 1/r32/ecx + 9753 # result = 0 + 9754 b8/copy-to-eax 0/imm32 + 9755 { + 9756 # if (curr <= 1) break + 9757 81 7/subop/compare %ecx 1/imm32 + 9758 7e/jump-if-<= break/disp8 + 9759 40/increment-eax + 9760 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 + 9761 eb/jump loop/disp8 + 9762 } + 9763 $num-shift-rights:end: + 9764 # . restore registers + 9765 59/pop-to-ecx + 9766 # . epilogue + 9767 89/<- %esp 5/r32/ebp + 9768 5d/pop-to-ebp + 9769 c3/return + 9770 + 9771 mu-get-offset: # stmt: (addr stmt) -> result/eax: int + 9772 # . prologue + 9773 55/push-ebp + 9774 89/<- %ebp 4/r32/esp + 9775 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next + 9776 8b/-> *(ebp+8) 0/r32/eax + 9777 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax + 9778 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + 9779 # var output-var/eax: (addr var) = second-inout->value + 9780 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax + 9781 #? (write-buffered Stderr "mu-get-offset: ") + 9782 #? (print-int32-buffered Stderr %eax) + 9783 #? (write-buffered Stderr " name: ") + 9784 #? 50/push-eax + 9785 #? (lookup *eax *(eax+4)) # Var-name + 9786 #? (write-buffered Stderr %eax) + 9787 #? 58/pop-to-eax + 9788 #? (write-buffered Stderr Newline) + 9789 #? (flush Stderr) + 9790 # return output-var->stack-offset + 9791 8b/-> *(eax+0x14) 0/r32/eax # Var-offset + 9792 #? (write-buffered Stderr "=> ") + 9793 #? (print-int32-buffered Stderr %eax) + 9794 #? (write-buffered Stderr Newline) + 9795 #? (flush Stderr) + 9796 $emit-get-offset:end: + 9797 # . epilogue + 9798 89/<- %esp 5/r32/ebp + 9799 5d/pop-to-ebp + 9800 c3/return + 9801 + 9802 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack (handle var)) + 9803 # . prologue + 9804 55/push-ebp + 9805 89/<- %ebp 4/r32/esp + 9806 # . save registers + 9807 50/push-eax + 9808 51/push-ecx + 9809 56/push-esi + 9810 # esi = block + 9811 8b/-> *(ebp+0xc) 6/r32/esi + 9812 # block->var->block-depth = *Curr-block-depth + 9813 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax + 9814 8b/-> *Curr-block-depth 1/r32/ecx + 9815 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth + 9816 # var stmts/eax: (addr list stmt) = lookup(block->statements) + 9817 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax + 9818 # + 9819 { + 9820 $emit-subx-block:check-empty: + 9821 3d/compare-eax-and 0/imm32 + 9822 0f 84/jump-if-= break/disp32 + 9823 (emit-indent *(ebp+8) *Curr-block-depth) + 9824 (write-buffered *(ebp+8) "{\n") + 9825 # var v/ecx: (addr var) = lookup(block->var) + 9826 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax + 9827 89/<- %ecx 0/r32/eax + 9828 # + 9829 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax + 9830 (write-buffered *(ebp+8) %eax) + 9831 (write-buffered *(ebp+8) ":loop:\n") + 9832 ff 0/subop/increment *Curr-block-depth + 9833 (push *(ebp+0x10) *(esi+0xc)) # Block-var + 9834 (push *(ebp+0x10) *(esi+0x10)) # Block-var + 9835 # emit block->statements + 9836 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax + 9837 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10)) + 9838 (pop *(ebp+0x10)) # => eax + 9839 (pop *(ebp+0x10)) # => eax + 9840 ff 1/subop/decrement *Curr-block-depth + 9841 (emit-indent *(ebp+8) *Curr-block-depth) + 9842 (write-buffered *(ebp+8) "}\n") + 9843 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax + 9844 (write-buffered *(ebp+8) %eax) + 9845 (write-buffered *(ebp+8) ":break:\n") + 9846 } + 9847 $emit-subx-block:end: + 9848 # . restore registers + 9849 5e/pop-to-esi + 9850 59/pop-to-ecx + 9851 58/pop-to-eax + 9852 # . epilogue + 9853 89/<- %esp 5/r32/ebp + 9854 5d/pop-to-ebp + 9855 c3/return + 9856 + 9857 # Primitives supported + 9858 # See mu_instructions for a summary of this linked-list data structure. 9859 # - 9860 # Fake alloc-ids are needed because our type definitions up top require - 9861 # handles but it's clearer to statically allocate these long-lived objects. - 9862 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. - 9863 # - 9864 # Every 'object' below starts with a fake alloc-id. It may also contain other - 9865 # fake alloc-ids for various handle fields. + 9860 # For each operation, put variants with hard-coded registers before flexible ones. + 9861 # + 9862 # Unfortunately, our restrictions on addresses require that various fields in + 9863 # primitives be handles, which complicates these definitions. + 9864 # - we need to insert dummy fields all over the place for fake alloc-ids + 9865 # - we can't use our syntax sugar of quoted literals for string fields 9866 # - 9867 # I think of objects starting with a fake alloc-id as having type 'payload'. - 9868 # It's not really intended to be created dynamically; for that use `allocate` - 9869 # as usual. + 9867 # Fake alloc-ids are needed because our type definitions up top require + 9868 # handles but it's clearer to statically allocate these long-lived objects. + 9869 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. 9870 # - 9871 # Idea for a notation to simplify such definitions: - 9872 # _Primitive-increment-eax: # (payload primitive) - 9873 # 0x11/alloc-id:fake:payload - 9874 # 0x11 @(0x11 "increment") # name - 9875 # 0 0 # inouts - 9876 # 0x11 @(0x11/payload - 9877 # 0x11 @(0x11/payload # List-value - 9878 # 0 0 # Var-name - 9879 # 0x11 @(0x11 # Var-type - 9880 # 1/is-atom - 9881 # 1/value 0/unused # Tree-left - 9882 # 0 0 # Tree-right - 9883 # ) - 9884 # 1 # block-depth - 9885 # 0 # stack-offset - 9886 # 0x11 @(0x11 "eax") # Var-register - 9887 # ) - 9888 # 0 0) # List-next - 9889 # ... - 9890 # _Primitive-increment-ecx/imm32/next - 9891 # ... - 9892 # Awfully complex and non-obvious. But also clearly signals there's something - 9893 # to learn here, so may be worth trying. - 9894 # - 9895 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " - 9896 # - 9897 # For now we'll continue to just use comments and manually ensure they stay up - 9898 # to date. - 9899 == data - 9900 Primitives: # (addr primitive) - 9901 # - increment/decrement - 9902 _Primitive-increment-eax: # (addr primitive) - 9903 # var/eax <- increment => 40/increment-eax - 9904 0x11/imm32/alloc-id:fake - 9905 _string-increment/imm32/name - 9906 0/imm32/no-inouts - 9907 0/imm32/no-inouts - 9908 0x11/imm32/alloc-id:fake - 9909 Single-int-var-in-eax/imm32/outputs - 9910 0x11/imm32/alloc-id:fake - 9911 _string_40_increment_eax/imm32/subx-name - 9912 0/imm32/no-rm32 - 9913 0/imm32/no-r32 - 9914 0/imm32/no-imm32 - 9915 0/imm32/no-disp32 - 9916 0/imm32/output-is-write-only + 9871 # Every 'object' below starts with a fake alloc-id. It may also contain other + 9872 # fake alloc-ids for various handle fields. + 9873 # + 9874 # I think of objects starting with a fake alloc-id as having type 'payload'. + 9875 # It's not really intended to be created dynamically; for that use `allocate` + 9876 # as usual. + 9877 # + 9878 # Idea for a notation to simplify such definitions: + 9879 # _Primitive-increment-eax: # (payload primitive) + 9880 # 0x11/alloc-id:fake:payload + 9881 # 0x11 @(0x11 "increment") # name + 9882 # 0 0 # inouts + 9883 # 0x11 @(0x11/payload + 9884 # 0x11 @(0x11/payload # List-value + 9885 # 0 0 # Var-name + 9886 # 0x11 @(0x11 # Var-type + 9887 # 1/is-atom + 9888 # 1/value 0/unused # Tree-left + 9889 # 0 0 # Tree-right + 9890 # ) + 9891 # 1 # block-depth + 9892 # 0 # stack-offset + 9893 # 0x11 @(0x11 "eax") # Var-register + 9894 # ) + 9895 # 0 0) # List-next + 9896 # ... + 9897 # _Primitive-increment-ecx/imm32/next + 9898 # ... + 9899 # Awfully complex and non-obvious. But also clearly signals there's something + 9900 # to learn here, so may be worth trying. + 9901 # + 9902 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " + 9903 # + 9904 # For now we'll continue to just use comments and manually ensure they stay up + 9905 # to date. + 9906 == data + 9907 Primitives: # (addr primitive) + 9908 # - increment/decrement + 9909 _Primitive-increment-eax: # (addr primitive) + 9910 # var/eax <- increment => 40/increment-eax + 9911 0x11/imm32/alloc-id:fake + 9912 _string-increment/imm32/name + 9913 0/imm32/no-inouts + 9914 0/imm32/no-inouts + 9915 0x11/imm32/alloc-id:fake + 9916 Single-int-var-in-eax/imm32/outputs 9917 0x11/imm32/alloc-id:fake - 9918 _Primitive-increment-ecx/imm32/next - 9919 _Primitive-increment-ecx: # (payload primitive) - 9920 0x11/imm32/alloc-id:fake:payload - 9921 # var/ecx <- increment => 41/increment-ecx - 9922 0x11/imm32/alloc-id:fake - 9923 _string-increment/imm32/name - 9924 0/imm32/no-inouts - 9925 0/imm32/no-inouts - 9926 0x11/imm32/alloc-id:fake - 9927 Single-int-var-in-ecx/imm32/outputs - 9928 0x11/imm32/alloc-id:fake - 9929 _string_41_increment_ecx/imm32/subx-name - 9930 0/imm32/no-rm32 - 9931 0/imm32/no-r32 - 9932 0/imm32/no-imm32 - 9933 0/imm32/no-disp32 - 9934 0/imm32/output-is-write-only + 9918 _string_40_increment_eax/imm32/subx-name + 9919 0/imm32/no-rm32 + 9920 0/imm32/no-r32 + 9921 0/imm32/no-imm32 + 9922 0/imm32/no-disp32 + 9923 0/imm32/output-is-write-only + 9924 0x11/imm32/alloc-id:fake + 9925 _Primitive-increment-ecx/imm32/next + 9926 _Primitive-increment-ecx: # (payload primitive) + 9927 0x11/imm32/alloc-id:fake:payload + 9928 # var/ecx <- increment => 41/increment-ecx + 9929 0x11/imm32/alloc-id:fake + 9930 _string-increment/imm32/name + 9931 0/imm32/no-inouts + 9932 0/imm32/no-inouts + 9933 0x11/imm32/alloc-id:fake + 9934 Single-int-var-in-ecx/imm32/outputs 9935 0x11/imm32/alloc-id:fake - 9936 _Primitive-increment-edx/imm32/next - 9937 _Primitive-increment-edx: # (payload primitive) - 9938 0x11/imm32/alloc-id:fake:payload - 9939 # var/edx <- increment => 42/increment-edx - 9940 0x11/imm32/alloc-id:fake - 9941 _string-increment/imm32/name - 9942 0/imm32/no-inouts - 9943 0/imm32/no-inouts - 9944 0x11/imm32/alloc-id:fake - 9945 Single-int-var-in-edx/imm32/outputs - 9946 0x11/imm32/alloc-id:fake - 9947 _string_42_increment_edx/imm32/subx-name - 9948 0/imm32/no-rm32 - 9949 0/imm32/no-r32 - 9950 0/imm32/no-imm32 - 9951 0/imm32/no-disp32 - 9952 0/imm32/output-is-write-only + 9936 _string_41_increment_ecx/imm32/subx-name + 9937 0/imm32/no-rm32 + 9938 0/imm32/no-r32 + 9939 0/imm32/no-imm32 + 9940 0/imm32/no-disp32 + 9941 0/imm32/output-is-write-only + 9942 0x11/imm32/alloc-id:fake + 9943 _Primitive-increment-edx/imm32/next + 9944 _Primitive-increment-edx: # (payload primitive) + 9945 0x11/imm32/alloc-id:fake:payload + 9946 # var/edx <- increment => 42/increment-edx + 9947 0x11/imm32/alloc-id:fake + 9948 _string-increment/imm32/name + 9949 0/imm32/no-inouts + 9950 0/imm32/no-inouts + 9951 0x11/imm32/alloc-id:fake + 9952 Single-int-var-in-edx/imm32/outputs 9953 0x11/imm32/alloc-id:fake - 9954 _Primitive-increment-ebx/imm32/next - 9955 _Primitive-increment-ebx: # (payload primitive) - 9956 0x11/imm32/alloc-id:fake:payload - 9957 # var/ebx <- increment => 43/increment-ebx - 9958 0x11/imm32/alloc-id:fake - 9959 _string-increment/imm32/name - 9960 0/imm32/no-inouts - 9961 0/imm32/no-inouts - 9962 0x11/imm32/alloc-id:fake - 9963 Single-int-var-in-ebx/imm32/outputs - 9964 0x11/imm32/alloc-id:fake - 9965 _string_43_increment_ebx/imm32/subx-name - 9966 0/imm32/no-rm32 - 9967 0/imm32/no-r32 - 9968 0/imm32/no-imm32 - 9969 0/imm32/no-disp32 - 9970 0/imm32/output-is-write-only + 9954 _string_42_increment_edx/imm32/subx-name + 9955 0/imm32/no-rm32 + 9956 0/imm32/no-r32 + 9957 0/imm32/no-imm32 + 9958 0/imm32/no-disp32 + 9959 0/imm32/output-is-write-only + 9960 0x11/imm32/alloc-id:fake + 9961 _Primitive-increment-ebx/imm32/next + 9962 _Primitive-increment-ebx: # (payload primitive) + 9963 0x11/imm32/alloc-id:fake:payload + 9964 # var/ebx <- increment => 43/increment-ebx + 9965 0x11/imm32/alloc-id:fake + 9966 _string-increment/imm32/name + 9967 0/imm32/no-inouts + 9968 0/imm32/no-inouts + 9969 0x11/imm32/alloc-id:fake + 9970 Single-int-var-in-ebx/imm32/outputs 9971 0x11/imm32/alloc-id:fake - 9972 _Primitive-increment-esi/imm32/next - 9973 _Primitive-increment-esi: # (payload primitive) - 9974 0x11/imm32/alloc-id:fake:payload - 9975 # var/esi <- increment => 46/increment-esi - 9976 0x11/imm32/alloc-id:fake - 9977 _string-increment/imm32/name - 9978 0/imm32/no-inouts - 9979 0/imm32/no-inouts - 9980 0x11/imm32/alloc-id:fake - 9981 Single-int-var-in-esi/imm32/outputs - 9982 0x11/imm32/alloc-id:fake - 9983 _string_46_increment_esi/imm32/subx-name - 9984 0/imm32/no-rm32 - 9985 0/imm32/no-r32 - 9986 0/imm32/no-imm32 - 9987 0/imm32/no-disp32 - 9988 0/imm32/output-is-write-only + 9972 _string_43_increment_ebx/imm32/subx-name + 9973 0/imm32/no-rm32 + 9974 0/imm32/no-r32 + 9975 0/imm32/no-imm32 + 9976 0/imm32/no-disp32 + 9977 0/imm32/output-is-write-only + 9978 0x11/imm32/alloc-id:fake + 9979 _Primitive-increment-esi/imm32/next + 9980 _Primitive-increment-esi: # (payload primitive) + 9981 0x11/imm32/alloc-id:fake:payload + 9982 # var/esi <- increment => 46/increment-esi + 9983 0x11/imm32/alloc-id:fake + 9984 _string-increment/imm32/name + 9985 0/imm32/no-inouts + 9986 0/imm32/no-inouts + 9987 0x11/imm32/alloc-id:fake + 9988 Single-int-var-in-esi/imm32/outputs 9989 0x11/imm32/alloc-id:fake - 9990 _Primitive-increment-edi/imm32/next - 9991 _Primitive-increment-edi: # (payload primitive) - 9992 0x11/imm32/alloc-id:fake:payload - 9993 # var/edi <- increment => 47/increment-edi - 9994 0x11/imm32/alloc-id:fake - 9995 _string-increment/imm32/name - 9996 0/imm32/no-inouts - 9997 0/imm32/no-inouts - 9998 0x11/imm32/alloc-id:fake - 9999 Single-int-var-in-edi/imm32/outputs -10000 0x11/imm32/alloc-id:fake -10001 _string_47_increment_edi/imm32/subx-name -10002 0/imm32/no-rm32 -10003 0/imm32/no-r32 -10004 0/imm32/no-imm32 -10005 0/imm32/no-disp32 -10006 0/imm32/output-is-write-only + 9990 _string_46_increment_esi/imm32/subx-name + 9991 0/imm32/no-rm32 + 9992 0/imm32/no-r32 + 9993 0/imm32/no-imm32 + 9994 0/imm32/no-disp32 + 9995 0/imm32/output-is-write-only + 9996 0x11/imm32/alloc-id:fake + 9997 _Primitive-increment-edi/imm32/next + 9998 _Primitive-increment-edi: # (payload primitive) + 9999 0x11/imm32/alloc-id:fake:payload +10000 # var/edi <- increment => 47/increment-edi +10001 0x11/imm32/alloc-id:fake +10002 _string-increment/imm32/name +10003 0/imm32/no-inouts +10004 0/imm32/no-inouts +10005 0x11/imm32/alloc-id:fake +10006 Single-int-var-in-edi/imm32/outputs 10007 0x11/imm32/alloc-id:fake -10008 _Primitive-decrement-eax/imm32/next -10009 _Primitive-decrement-eax: # (payload primitive) -10010 0x11/imm32/alloc-id:fake:payload -10011 # var/eax <- decrement => 48/decrement-eax -10012 0x11/imm32/alloc-id:fake -10013 _string-decrement/imm32/name -10014 0/imm32/no-inouts -10015 0/imm32/no-inouts -10016 0x11/imm32/alloc-id:fake -10017 Single-int-var-in-eax/imm32/outputs -10018 0x11/imm32/alloc-id:fake -10019 _string_48_decrement_eax/imm32/subx-name -10020 0/imm32/no-rm32 -10021 0/imm32/no-r32 -10022 0/imm32/no-imm32 -10023 0/imm32/no-disp32 -10024 0/imm32/output-is-write-only +10008 _string_47_increment_edi/imm32/subx-name +10009 0/imm32/no-rm32 +10010 0/imm32/no-r32 +10011 0/imm32/no-imm32 +10012 0/imm32/no-disp32 +10013 0/imm32/output-is-write-only +10014 0x11/imm32/alloc-id:fake +10015 _Primitive-decrement-eax/imm32/next +10016 _Primitive-decrement-eax: # (payload primitive) +10017 0x11/imm32/alloc-id:fake:payload +10018 # var/eax <- decrement => 48/decrement-eax +10019 0x11/imm32/alloc-id:fake +10020 _string-decrement/imm32/name +10021 0/imm32/no-inouts +10022 0/imm32/no-inouts +10023 0x11/imm32/alloc-id:fake +10024 Single-int-var-in-eax/imm32/outputs 10025 0x11/imm32/alloc-id:fake -10026 _Primitive-decrement-ecx/imm32/next -10027 _Primitive-decrement-ecx: # (payload primitive) -10028 0x11/imm32/alloc-id:fake:payload -10029 # var/ecx <- decrement => 49/decrement-ecx -10030 0x11/imm32/alloc-id:fake -10031 _string-decrement/imm32/name -10032 0/imm32/no-inouts -10033 0/imm32/no-inouts -10034 0x11/imm32/alloc-id:fake -10035 Single-int-var-in-ecx/imm32/outputs -10036 0x11/imm32/alloc-id:fake -10037 _string_49_decrement_ecx/imm32/subx-name -10038 0/imm32/no-rm32 -10039 0/imm32/no-r32 -10040 0/imm32/no-imm32 -10041 0/imm32/no-disp32 -10042 0/imm32/output-is-write-only +10026 _string_48_decrement_eax/imm32/subx-name +10027 0/imm32/no-rm32 +10028 0/imm32/no-r32 +10029 0/imm32/no-imm32 +10030 0/imm32/no-disp32 +10031 0/imm32/output-is-write-only +10032 0x11/imm32/alloc-id:fake +10033 _Primitive-decrement-ecx/imm32/next +10034 _Primitive-decrement-ecx: # (payload primitive) +10035 0x11/imm32/alloc-id:fake:payload +10036 # var/ecx <- decrement => 49/decrement-ecx +10037 0x11/imm32/alloc-id:fake +10038 _string-decrement/imm32/name +10039 0/imm32/no-inouts +10040 0/imm32/no-inouts +10041 0x11/imm32/alloc-id:fake +10042 Single-int-var-in-ecx/imm32/outputs 10043 0x11/imm32/alloc-id:fake -10044 _Primitive-decrement-edx/imm32/next -10045 _Primitive-decrement-edx: # (payload primitive) -10046 0x11/imm32/alloc-id:fake:payload -10047 # var/edx <- decrement => 4a/decrement-edx -10048 0x11/imm32/alloc-id:fake -10049 _string-decrement/imm32/name -10050 0/imm32/no-inouts -10051 0/imm32/no-inouts -10052 0x11/imm32/alloc-id:fake -10053 Single-int-var-in-edx/imm32/outputs -10054 0x11/imm32/alloc-id:fake -10055 _string_4a_decrement_edx/imm32/subx-name -10056 0/imm32/no-rm32 -10057 0/imm32/no-r32 -10058 0/imm32/no-imm32 -10059 0/imm32/no-disp32 -10060 0/imm32/output-is-write-only +10044 _string_49_decrement_ecx/imm32/subx-name +10045 0/imm32/no-rm32 +10046 0/imm32/no-r32 +10047 0/imm32/no-imm32 +10048 0/imm32/no-disp32 +10049 0/imm32/output-is-write-only +10050 0x11/imm32/alloc-id:fake +10051 _Primitive-decrement-edx/imm32/next +10052 _Primitive-decrement-edx: # (payload primitive) +10053 0x11/imm32/alloc-id:fake:payload +10054 # var/edx <- decrement => 4a/decrement-edx +10055 0x11/imm32/alloc-id:fake +10056 _string-decrement/imm32/name +10057 0/imm32/no-inouts +10058 0/imm32/no-inouts +10059 0x11/imm32/alloc-id:fake +10060 Single-int-var-in-edx/imm32/outputs 10061 0x11/imm32/alloc-id:fake -10062 _Primitive-decrement-ebx/imm32/next -10063 _Primitive-decrement-ebx: # (payload primitive) -10064 0x11/imm32/alloc-id:fake:payload -10065 # var/ebx <- decrement => 4b/decrement-ebx -10066 0x11/imm32/alloc-id:fake -10067 _string-decrement/imm32/name -10068 0/imm32/no-inouts -10069 0/imm32/no-inouts -10070 0x11/imm32/alloc-id:fake -10071 Single-int-var-in-ebx/imm32/outputs -10072 0x11/imm32/alloc-id:fake -10073 _string_4b_decrement_ebx/imm32/subx-name -10074 0/imm32/no-rm32 -10075 0/imm32/no-r32 -10076 0/imm32/no-imm32 -10077 0/imm32/no-disp32 -10078 0/imm32/output-is-write-only +10062 _string_4a_decrement_edx/imm32/subx-name +10063 0/imm32/no-rm32 +10064 0/imm32/no-r32 +10065 0/imm32/no-imm32 +10066 0/imm32/no-disp32 +10067 0/imm32/output-is-write-only +10068 0x11/imm32/alloc-id:fake +10069 _Primitive-decrement-ebx/imm32/next +10070 _Primitive-decrement-ebx: # (payload primitive) +10071 0x11/imm32/alloc-id:fake:payload +10072 # var/ebx <- decrement => 4b/decrement-ebx +10073 0x11/imm32/alloc-id:fake +10074 _string-decrement/imm32/name +10075 0/imm32/no-inouts +10076 0/imm32/no-inouts +10077 0x11/imm32/alloc-id:fake +10078 Single-int-var-in-ebx/imm32/outputs 10079 0x11/imm32/alloc-id:fake -10080 _Primitive-decrement-esi/imm32/next -10081 _Primitive-decrement-esi: # (payload primitive) -10082 0x11/imm32/alloc-id:fake:payload -10083 # var/esi <- decrement => 4e/decrement-esi -10084 0x11/imm32/alloc-id:fake -10085 _string-decrement/imm32/name -10086 0/imm32/no-inouts -10087 0/imm32/no-inouts -10088 0x11/imm32/alloc-id:fake -10089 Single-int-var-in-esi/imm32/outputs -10090 0x11/imm32/alloc-id:fake -10091 _string_4e_decrement_esi/imm32/subx-name -10092 0/imm32/no-rm32 -10093 0/imm32/no-r32 -10094 0/imm32/no-imm32 -10095 0/imm32/no-disp32 -10096 0/imm32/output-is-write-only +10080 _string_4b_decrement_ebx/imm32/subx-name +10081 0/imm32/no-rm32 +10082 0/imm32/no-r32 +10083 0/imm32/no-imm32 +10084 0/imm32/no-disp32 +10085 0/imm32/output-is-write-only +10086 0x11/imm32/alloc-id:fake +10087 _Primitive-decrement-esi/imm32/next +10088 _Primitive-decrement-esi: # (payload primitive) +10089 0x11/imm32/alloc-id:fake:payload +10090 # var/esi <- decrement => 4e/decrement-esi +10091 0x11/imm32/alloc-id:fake +10092 _string-decrement/imm32/name +10093 0/imm32/no-inouts +10094 0/imm32/no-inouts +10095 0x11/imm32/alloc-id:fake +10096 Single-int-var-in-esi/imm32/outputs 10097 0x11/imm32/alloc-id:fake -10098 _Primitive-decrement-edi/imm32/next -10099 _Primitive-decrement-edi: # (payload primitive) -10100 0x11/imm32/alloc-id:fake:payload -10101 # var/edi <- decrement => 4f/decrement-edi -10102 0x11/imm32/alloc-id:fake -10103 _string-decrement/imm32/name -10104 0/imm32/no-inouts -10105 0/imm32/no-inouts -10106 0x11/imm32/alloc-id:fake -10107 Single-int-var-in-edi/imm32/outputs -10108 0x11/imm32/alloc-id:fake -10109 _string_4f_decrement_edi/imm32/subx-name -10110 0/imm32/no-rm32 -10111 0/imm32/no-r32 -10112 0/imm32/no-imm32 -10113 0/imm32/no-disp32 -10114 0/imm32/output-is-write-only +10098 _string_4e_decrement_esi/imm32/subx-name +10099 0/imm32/no-rm32 +10100 0/imm32/no-r32 +10101 0/imm32/no-imm32 +10102 0/imm32/no-disp32 +10103 0/imm32/output-is-write-only +10104 0x11/imm32/alloc-id:fake +10105 _Primitive-decrement-edi/imm32/next +10106 _Primitive-decrement-edi: # (payload primitive) +10107 0x11/imm32/alloc-id:fake:payload +10108 # var/edi <- decrement => 4f/decrement-edi +10109 0x11/imm32/alloc-id:fake +10110 _string-decrement/imm32/name +10111 0/imm32/no-inouts +10112 0/imm32/no-inouts +10113 0x11/imm32/alloc-id:fake +10114 Single-int-var-in-edi/imm32/outputs 10115 0x11/imm32/alloc-id:fake -10116 _Primitive-increment-mem/imm32/next -10117 _Primitive-increment-mem: # (payload primitive) -10118 0x11/imm32/alloc-id:fake:payload -10119 # increment var => ff 0/subop/increment *(ebp+__) -10120 0x11/imm32/alloc-id:fake -10121 _string-increment/imm32/name +10116 _string_4f_decrement_edi/imm32/subx-name +10117 0/imm32/no-rm32 +10118 0/imm32/no-r32 +10119 0/imm32/no-imm32 +10120 0/imm32/no-disp32 +10121 0/imm32/output-is-write-only 10122 0x11/imm32/alloc-id:fake -10123 Single-int-var-in-mem/imm32/inouts -10124 0/imm32/no-outputs -10125 0/imm32/no-outputs -10126 0x11/imm32/alloc-id:fake -10127 _string_ff_subop_increment/imm32/subx-name -10128 1/imm32/rm32-is-first-inout -10129 0/imm32/no-r32 -10130 0/imm32/no-imm32 -10131 0/imm32/no-disp32 -10132 0/imm32/output-is-write-only +10123 _Primitive-increment-mem/imm32/next +10124 _Primitive-increment-mem: # (payload primitive) +10125 0x11/imm32/alloc-id:fake:payload +10126 # increment var => ff 0/subop/increment *(ebp+__) +10127 0x11/imm32/alloc-id:fake +10128 _string-increment/imm32/name +10129 0x11/imm32/alloc-id:fake +10130 Single-int-var-in-mem/imm32/inouts +10131 0/imm32/no-outputs +10132 0/imm32/no-outputs 10133 0x11/imm32/alloc-id:fake -10134 _Primitive-increment-reg/imm32/next -10135 _Primitive-increment-reg: # (payload primitive) -10136 0x11/imm32/alloc-id:fake:payload -10137 # var/reg <- increment => ff 0/subop/increment %__ -10138 0x11/imm32/alloc-id:fake -10139 _string-increment/imm32/name -10140 0/imm32/no-inouts -10141 0/imm32/no-inouts -10142 0x11/imm32/alloc-id:fake -10143 Single-int-var-in-some-register/imm32/outputs -10144 0x11/imm32/alloc-id:fake -10145 _string_ff_subop_increment/imm32/subx-name -10146 3/imm32/rm32-is-first-output -10147 0/imm32/no-r32 -10148 0/imm32/no-imm32 -10149 0/imm32/no-disp32 -10150 0/imm32/output-is-write-only +10134 _string_ff_subop_increment/imm32/subx-name +10135 1/imm32/rm32-is-first-inout +10136 0/imm32/no-r32 +10137 0/imm32/no-imm32 +10138 0/imm32/no-disp32 +10139 0/imm32/output-is-write-only +10140 0x11/imm32/alloc-id:fake +10141 _Primitive-increment-reg/imm32/next +10142 _Primitive-increment-reg: # (payload primitive) +10143 0x11/imm32/alloc-id:fake:payload +10144 # var/reg <- increment => ff 0/subop/increment %__ +10145 0x11/imm32/alloc-id:fake +10146 _string-increment/imm32/name +10147 0/imm32/no-inouts +10148 0/imm32/no-inouts +10149 0x11/imm32/alloc-id:fake +10150 Single-int-var-in-some-register/imm32/outputs 10151 0x11/imm32/alloc-id:fake -10152 _Primitive-decrement-mem/imm32/next -10153 _Primitive-decrement-mem: # (payload primitive) -10154 0x11/imm32/alloc-id:fake:payload -10155 # decrement var => ff 1/subop/decrement *(ebp+__) -10156 0x11/imm32/alloc-id:fake -10157 _string-decrement/imm32/name +10152 _string_ff_subop_increment/imm32/subx-name +10153 3/imm32/rm32-is-first-output +10154 0/imm32/no-r32 +10155 0/imm32/no-imm32 +10156 0/imm32/no-disp32 +10157 0/imm32/output-is-write-only 10158 0x11/imm32/alloc-id:fake -10159 Single-int-var-in-mem/imm32/inouts -10160 0/imm32/no-outputs -10161 0/imm32/no-outputs -10162 0x11/imm32/alloc-id:fake -10163 _string_ff_subop_decrement/imm32/subx-name -10164 1/imm32/rm32-is-first-inout -10165 0/imm32/no-r32 -10166 0/imm32/no-imm32 -10167 0/imm32/no-disp32 -10168 0/imm32/output-is-write-only +10159 _Primitive-decrement-mem/imm32/next +10160 _Primitive-decrement-mem: # (payload primitive) +10161 0x11/imm32/alloc-id:fake:payload +10162 # decrement var => ff 1/subop/decrement *(ebp+__) +10163 0x11/imm32/alloc-id:fake +10164 _string-decrement/imm32/name +10165 0x11/imm32/alloc-id:fake +10166 Single-int-var-in-mem/imm32/inouts +10167 0/imm32/no-outputs +10168 0/imm32/no-outputs 10169 0x11/imm32/alloc-id:fake -10170 _Primitive-decrement-reg/imm32/next -10171 _Primitive-decrement-reg: # (payload primitive) -10172 0x11/imm32/alloc-id:fake:payload -10173 # var/reg <- decrement => ff 1/subop/decrement %__ -10174 0x11/imm32/alloc-id:fake -10175 _string-decrement/imm32/name -10176 0/imm32/no-inouts -10177 0/imm32/no-inouts -10178 0x11/imm32/alloc-id:fake -10179 Single-int-var-in-some-register/imm32/outputs -10180 0x11/imm32/alloc-id:fake -10181 _string_ff_subop_decrement/imm32/subx-name -10182 3/imm32/rm32-is-first-output -10183 0/imm32/no-r32 -10184 0/imm32/no-imm32 -10185 0/imm32/no-disp32 -10186 0/imm32/output-is-write-only +10170 _string_ff_subop_decrement/imm32/subx-name +10171 1/imm32/rm32-is-first-inout +10172 0/imm32/no-r32 +10173 0/imm32/no-imm32 +10174 0/imm32/no-disp32 +10175 0/imm32/output-is-write-only +10176 0x11/imm32/alloc-id:fake +10177 _Primitive-decrement-reg/imm32/next +10178 _Primitive-decrement-reg: # (payload primitive) +10179 0x11/imm32/alloc-id:fake:payload +10180 # var/reg <- decrement => ff 1/subop/decrement %__ +10181 0x11/imm32/alloc-id:fake +10182 _string-decrement/imm32/name +10183 0/imm32/no-inouts +10184 0/imm32/no-inouts +10185 0x11/imm32/alloc-id:fake +10186 Single-int-var-in-some-register/imm32/outputs 10187 0x11/imm32/alloc-id:fake -10188 _Primitive-add-to-eax/imm32/next -10189 # - add -10190 _Primitive-add-to-eax: # (payload primitive) -10191 0x11/imm32/alloc-id:fake:payload -10192 # var/eax <- add lit => 05/add-to-eax lit/imm32 -10193 0x11/imm32/alloc-id:fake -10194 _string-add/imm32/name -10195 0x11/imm32/alloc-id:fake -10196 Single-lit-var/imm32/inouts -10197 0x11/imm32/alloc-id:fake -10198 Single-int-var-in-eax/imm32/outputs -10199 0x11/imm32/alloc-id:fake -10200 _string_05_add_to_eax/imm32/subx-name -10201 0/imm32/no-rm32 -10202 0/imm32/no-r32 -10203 1/imm32/imm32-is-first-inout -10204 0/imm32/no-disp32 -10205 0/imm32/output-is-write-only +10188 _string_ff_subop_decrement/imm32/subx-name +10189 3/imm32/rm32-is-first-output +10190 0/imm32/no-r32 +10191 0/imm32/no-imm32 +10192 0/imm32/no-disp32 +10193 0/imm32/output-is-write-only +10194 0x11/imm32/alloc-id:fake +10195 _Primitive-add-to-eax/imm32/next +10196 # - add +10197 _Primitive-add-to-eax: # (payload primitive) +10198 0x11/imm32/alloc-id:fake:payload +10199 # var/eax <- add lit => 05/add-to-eax lit/imm32 +10200 0x11/imm32/alloc-id:fake +10201 _string-add/imm32/name +10202 0x11/imm32/alloc-id:fake +10203 Single-lit-var/imm32/inouts +10204 0x11/imm32/alloc-id:fake +10205 Single-int-var-in-eax/imm32/outputs 10206 0x11/imm32/alloc-id:fake -10207 _Primitive-add-reg-to-reg/imm32/next -10208 _Primitive-add-reg-to-reg: # (payload primitive) -10209 0x11/imm32/alloc-id:fake:payload -10210 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 -10211 0x11/imm32/alloc-id:fake -10212 _string-add/imm32/name +10207 _string_05_add_to_eax/imm32/subx-name +10208 0/imm32/no-rm32 +10209 0/imm32/no-r32 +10210 1/imm32/imm32-is-first-inout +10211 0/imm32/no-disp32 +10212 0/imm32/output-is-write-only 10213 0x11/imm32/alloc-id:fake -10214 Single-int-var-in-some-register/imm32/inouts -10215 0x11/imm32/alloc-id:fake -10216 Single-int-var-in-some-register/imm32/outputs -10217 0x11/imm32/alloc-id:fake -10218 _string_01_add_to/imm32/subx-name -10219 3/imm32/rm32-is-first-output -10220 1/imm32/r32-is-first-inout -10221 0/imm32/no-imm32 -10222 0/imm32/no-disp32 -10223 0/imm32/output-is-write-only +10214 _Primitive-add-reg-to-reg/imm32/next +10215 _Primitive-add-reg-to-reg: # (payload primitive) +10216 0x11/imm32/alloc-id:fake:payload +10217 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 +10218 0x11/imm32/alloc-id:fake +10219 _string-add/imm32/name +10220 0x11/imm32/alloc-id:fake +10221 Single-int-var-in-some-register/imm32/inouts +10222 0x11/imm32/alloc-id:fake +10223 Single-int-var-in-some-register/imm32/outputs 10224 0x11/imm32/alloc-id:fake -10225 _Primitive-add-reg-to-mem/imm32/next -10226 _Primitive-add-reg-to-mem: # (payload primitive) -10227 0x11/imm32/alloc-id:fake:payload -10228 # add-to var1 var2/reg => 01/add-to var1 var2/r32 -10229 0x11/imm32/alloc-id:fake -10230 _string-add-to/imm32/name +10225 _string_01_add_to/imm32/subx-name +10226 3/imm32/rm32-is-first-output +10227 1/imm32/r32-is-first-inout +10228 0/imm32/no-imm32 +10229 0/imm32/no-disp32 +10230 0/imm32/output-is-write-only 10231 0x11/imm32/alloc-id:fake -10232 Two-args-int-stack-int-reg/imm32/inouts -10233 0/imm32/no-outputs -10234 0/imm32/no-outputs -10235 0x11/imm32/alloc-id:fake -10236 _string_01_add_to/imm32/subx-name -10237 1/imm32/rm32-is-first-inout -10238 2/imm32/r32-is-second-inout -10239 0/imm32/no-imm32 -10240 0/imm32/no-disp32 -10241 0/imm32/output-is-write-only +10232 _Primitive-add-reg-to-mem/imm32/next +10233 _Primitive-add-reg-to-mem: # (payload primitive) +10234 0x11/imm32/alloc-id:fake:payload +10235 # add-to var1 var2/reg => 01/add-to var1 var2/r32 +10236 0x11/imm32/alloc-id:fake +10237 _string-add-to/imm32/name +10238 0x11/imm32/alloc-id:fake +10239 Two-args-int-stack-int-reg/imm32/inouts +10240 0/imm32/no-outputs +10241 0/imm32/no-outputs 10242 0x11/imm32/alloc-id:fake -10243 _Primitive-add-mem-to-reg/imm32/next -10244 _Primitive-add-mem-to-reg: # (payload primitive) -10245 0x11/imm32/alloc-id:fake:payload -10246 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 -10247 0x11/imm32/alloc-id:fake -10248 _string-add/imm32/name +10243 _string_01_add_to/imm32/subx-name +10244 1/imm32/rm32-is-first-inout +10245 2/imm32/r32-is-second-inout +10246 0/imm32/no-imm32 +10247 0/imm32/no-disp32 +10248 0/imm32/output-is-write-only 10249 0x11/imm32/alloc-id:fake -10250 Single-int-var-in-mem/imm32/inouts -10251 0x11/imm32/alloc-id:fake -10252 Single-int-var-in-some-register/imm32/outputs -10253 0x11/imm32/alloc-id:fake -10254 _string_03_add/imm32/subx-name -10255 1/imm32/rm32-is-first-inout -10256 3/imm32/r32-is-first-output -10257 0/imm32/no-imm32 -10258 0/imm32/no-disp32 -10259 0/imm32/output-is-write-only +10250 _Primitive-add-mem-to-reg/imm32/next +10251 _Primitive-add-mem-to-reg: # (payload primitive) +10252 0x11/imm32/alloc-id:fake:payload +10253 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 +10254 0x11/imm32/alloc-id:fake +10255 _string-add/imm32/name +10256 0x11/imm32/alloc-id:fake +10257 Single-int-var-in-mem/imm32/inouts +10258 0x11/imm32/alloc-id:fake +10259 Single-int-var-in-some-register/imm32/outputs 10260 0x11/imm32/alloc-id:fake -10261 _Primitive-add-lit-to-reg/imm32/next -10262 _Primitive-add-lit-to-reg: # (payload primitive) -10263 0x11/imm32/alloc-id:fake:payload -10264 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 -10265 0x11/imm32/alloc-id:fake -10266 _string-add/imm32/name +10261 _string_03_add/imm32/subx-name +10262 1/imm32/rm32-is-first-inout +10263 3/imm32/r32-is-first-output +10264 0/imm32/no-imm32 +10265 0/imm32/no-disp32 +10266 0/imm32/output-is-write-only 10267 0x11/imm32/alloc-id:fake -10268 Single-lit-var/imm32/inouts -10269 0x11/imm32/alloc-id:fake -10270 Single-int-var-in-some-register/imm32/outputs -10271 0x11/imm32/alloc-id:fake -10272 _string_81_subop_add/imm32/subx-name -10273 3/imm32/rm32-is-first-output -10274 0/imm32/no-r32 -10275 1/imm32/imm32-is-first-inout -10276 0/imm32/no-disp32 -10277 0/imm32/output-is-write-only +10268 _Primitive-add-lit-to-reg/imm32/next +10269 _Primitive-add-lit-to-reg: # (payload primitive) +10270 0x11/imm32/alloc-id:fake:payload +10271 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 +10272 0x11/imm32/alloc-id:fake +10273 _string-add/imm32/name +10274 0x11/imm32/alloc-id:fake +10275 Single-lit-var/imm32/inouts +10276 0x11/imm32/alloc-id:fake +10277 Single-int-var-in-some-register/imm32/outputs 10278 0x11/imm32/alloc-id:fake -10279 _Primitive-add-lit-to-mem/imm32/next -10280 _Primitive-add-lit-to-mem: # (payload primitive) -10281 0x11/imm32/alloc-id:fake:payload -10282 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 -10283 0x11/imm32/alloc-id:fake -10284 _string-add-to/imm32/name +10279 _string_81_subop_add/imm32/subx-name +10280 3/imm32/rm32-is-first-output +10281 0/imm32/no-r32 +10282 1/imm32/imm32-is-first-inout +10283 0/imm32/no-disp32 +10284 0/imm32/output-is-write-only 10285 0x11/imm32/alloc-id:fake -10286 Int-var-and-literal/imm32/inouts -10287 0/imm32/no-outputs -10288 0/imm32/no-outputs -10289 0x11/imm32/alloc-id:fake -10290 _string_81_subop_add/imm32/subx-name -10291 1/imm32/rm32-is-first-inout -10292 0/imm32/no-r32 -10293 2/imm32/imm32-is-second-inout -10294 0/imm32/no-disp32 -10295 0/imm32/output-is-write-only +10286 _Primitive-add-lit-to-mem/imm32/next +10287 _Primitive-add-lit-to-mem: # (payload primitive) +10288 0x11/imm32/alloc-id:fake:payload +10289 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 +10290 0x11/imm32/alloc-id:fake +10291 _string-add-to/imm32/name +10292 0x11/imm32/alloc-id:fake +10293 Int-var-and-literal/imm32/inouts +10294 0/imm32/no-outputs +10295 0/imm32/no-outputs 10296 0x11/imm32/alloc-id:fake -10297 _Primitive-subtract-from-eax/imm32/next -10298 # - subtract -10299 _Primitive-subtract-from-eax: # (payload primitive) -10300 0x11/imm32/alloc-id:fake:payload -10301 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 -10302 0x11/imm32/alloc-id:fake -10303 _string-subtract/imm32/name -10304 0x11/imm32/alloc-id:fake -10305 Single-lit-var/imm32/inouts -10306 0x11/imm32/alloc-id:fake -10307 Single-int-var-in-eax/imm32/outputs -10308 0x11/imm32/alloc-id:fake -10309 _string_2d_subtract_from_eax/imm32/subx-name -10310 0/imm32/no-rm32 -10311 0/imm32/no-r32 -10312 1/imm32/imm32-is-first-inout -10313 0/imm32/no-disp32 -10314 0/imm32/output-is-write-only +10297 _string_81_subop_add/imm32/subx-name +10298 1/imm32/rm32-is-first-inout +10299 0/imm32/no-r32 +10300 2/imm32/imm32-is-second-inout +10301 0/imm32/no-disp32 +10302 0/imm32/output-is-write-only +10303 0x11/imm32/alloc-id:fake +10304 _Primitive-subtract-from-eax/imm32/next +10305 # - subtract +10306 _Primitive-subtract-from-eax: # (payload primitive) +10307 0x11/imm32/alloc-id:fake:payload +10308 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 +10309 0x11/imm32/alloc-id:fake +10310 _string-subtract/imm32/name +10311 0x11/imm32/alloc-id:fake +10312 Single-lit-var/imm32/inouts +10313 0x11/imm32/alloc-id:fake +10314 Single-int-var-in-eax/imm32/outputs 10315 0x11/imm32/alloc-id:fake -10316 _Primitive-subtract-reg-from-reg/imm32/next -10317 _Primitive-subtract-reg-from-reg: # (payload primitive) -10318 0x11/imm32/alloc-id:fake:payload -10319 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 -10320 0x11/imm32/alloc-id:fake -10321 _string-subtract/imm32/name +10316 _string_2d_subtract_from_eax/imm32/subx-name +10317 0/imm32/no-rm32 +10318 0/imm32/no-r32 +10319 1/imm32/imm32-is-first-inout +10320 0/imm32/no-disp32 +10321 0/imm32/output-is-write-only 10322 0x11/imm32/alloc-id:fake -10323 Single-int-var-in-some-register/imm32/inouts -10324 0x11/imm32/alloc-id:fake -10325 Single-int-var-in-some-register/imm32/outputs -10326 0x11/imm32/alloc-id:fake -10327 _string_29_subtract_from/imm32/subx-name -10328 3/imm32/rm32-is-first-output -10329 1/imm32/r32-is-first-inout -10330 0/imm32/no-imm32 -10331 0/imm32/no-disp32 -10332 0/imm32/output-is-write-only +10323 _Primitive-subtract-reg-from-reg/imm32/next +10324 _Primitive-subtract-reg-from-reg: # (payload primitive) +10325 0x11/imm32/alloc-id:fake:payload +10326 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 +10327 0x11/imm32/alloc-id:fake +10328 _string-subtract/imm32/name +10329 0x11/imm32/alloc-id:fake +10330 Single-int-var-in-some-register/imm32/inouts +10331 0x11/imm32/alloc-id:fake +10332 Single-int-var-in-some-register/imm32/outputs 10333 0x11/imm32/alloc-id:fake -10334 _Primitive-subtract-reg-from-mem/imm32/next -10335 _Primitive-subtract-reg-from-mem: # (payload primitive) -10336 0x11/imm32/alloc-id:fake:payload -10337 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 -10338 0x11/imm32/alloc-id:fake -10339 _string-subtract-from/imm32/name +10334 _string_29_subtract_from/imm32/subx-name +10335 3/imm32/rm32-is-first-output +10336 1/imm32/r32-is-first-inout +10337 0/imm32/no-imm32 +10338 0/imm32/no-disp32 +10339 0/imm32/output-is-write-only 10340 0x11/imm32/alloc-id:fake -10341 Two-args-int-stack-int-reg/imm32/inouts -10342 0/imm32/no-outputs -10343 0/imm32/no-outputs -10344 0x11/imm32/alloc-id:fake -10345 _string_29_subtract_from/imm32/subx-name -10346 1/imm32/rm32-is-first-inout -10347 2/imm32/r32-is-second-inout -10348 0/imm32/no-imm32 -10349 0/imm32/no-disp32 -10350 0/imm32/output-is-write-only +10341 _Primitive-subtract-reg-from-mem/imm32/next +10342 _Primitive-subtract-reg-from-mem: # (payload primitive) +10343 0x11/imm32/alloc-id:fake:payload +10344 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 +10345 0x11/imm32/alloc-id:fake +10346 _string-subtract-from/imm32/name +10347 0x11/imm32/alloc-id:fake +10348 Two-args-int-stack-int-reg/imm32/inouts +10349 0/imm32/no-outputs +10350 0/imm32/no-outputs 10351 0x11/imm32/alloc-id:fake -10352 _Primitive-subtract-mem-from-reg/imm32/next -10353 _Primitive-subtract-mem-from-reg: # (payload primitive) -10354 0x11/imm32/alloc-id:fake:payload -10355 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 -10356 0x11/imm32/alloc-id:fake -10357 _string-subtract/imm32/name +10352 _string_29_subtract_from/imm32/subx-name +10353 1/imm32/rm32-is-first-inout +10354 2/imm32/r32-is-second-inout +10355 0/imm32/no-imm32 +10356 0/imm32/no-disp32 +10357 0/imm32/output-is-write-only 10358 0x11/imm32/alloc-id:fake -10359 Single-int-var-in-mem/imm32/inouts -10360 0x11/imm32/alloc-id:fake -10361 Single-int-var-in-some-register/imm32/outputs -10362 0x11/imm32/alloc-id:fake -10363 _string_2b_subtract/imm32/subx-name -10364 1/imm32/rm32-is-first-inout -10365 3/imm32/r32-is-first-output -10366 0/imm32/no-imm32 -10367 0/imm32/no-disp32 -10368 0/imm32/output-is-write-only +10359 _Primitive-subtract-mem-from-reg/imm32/next +10360 _Primitive-subtract-mem-from-reg: # (payload primitive) +10361 0x11/imm32/alloc-id:fake:payload +10362 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 +10363 0x11/imm32/alloc-id:fake +10364 _string-subtract/imm32/name +10365 0x11/imm32/alloc-id:fake +10366 Single-int-var-in-mem/imm32/inouts +10367 0x11/imm32/alloc-id:fake +10368 Single-int-var-in-some-register/imm32/outputs 10369 0x11/imm32/alloc-id:fake -10370 _Primitive-subtract-lit-from-reg/imm32/next -10371 _Primitive-subtract-lit-from-reg: # (payload primitive) -10372 0x11/imm32/alloc-id:fake:payload -10373 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 -10374 0x11/imm32/alloc-id:fake -10375 _string-subtract/imm32/name +10370 _string_2b_subtract/imm32/subx-name +10371 1/imm32/rm32-is-first-inout +10372 3/imm32/r32-is-first-output +10373 0/imm32/no-imm32 +10374 0/imm32/no-disp32 +10375 0/imm32/output-is-write-only 10376 0x11/imm32/alloc-id:fake -10377 Single-lit-var/imm32/inouts -10378 0x11/imm32/alloc-id:fake -10379 Single-int-var-in-some-register/imm32/outputs -10380 0x11/imm32/alloc-id:fake -10381 _string_81_subop_subtract/imm32/subx-name -10382 3/imm32/rm32-is-first-output -10383 0/imm32/no-r32 -10384 1/imm32/imm32-is-first-inout -10385 0/imm32/no-disp32 -10386 0/imm32/output-is-write-only +10377 _Primitive-subtract-lit-from-reg/imm32/next +10378 _Primitive-subtract-lit-from-reg: # (payload primitive) +10379 0x11/imm32/alloc-id:fake:payload +10380 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 +10381 0x11/imm32/alloc-id:fake +10382 _string-subtract/imm32/name +10383 0x11/imm32/alloc-id:fake +10384 Single-lit-var/imm32/inouts +10385 0x11/imm32/alloc-id:fake +10386 Single-int-var-in-some-register/imm32/outputs 10387 0x11/imm32/alloc-id:fake -10388 _Primitive-subtract-lit-from-mem/imm32/next -10389 _Primitive-subtract-lit-from-mem: # (payload primitive) -10390 0x11/imm32/alloc-id:fake:payload -10391 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 -10392 0x11/imm32/alloc-id:fake -10393 _string-subtract-from/imm32/name +10388 _string_81_subop_subtract/imm32/subx-name +10389 3/imm32/rm32-is-first-output +10390 0/imm32/no-r32 +10391 1/imm32/imm32-is-first-inout +10392 0/imm32/no-disp32 +10393 0/imm32/output-is-write-only 10394 0x11/imm32/alloc-id:fake -10395 Int-var-and-literal/imm32/inouts -10396 0/imm32/no-outputs -10397 0/imm32/no-outputs -10398 0x11/imm32/alloc-id:fake -10399 _string_81_subop_subtract/imm32/subx-name -10400 1/imm32/rm32-is-first-inout -10401 0/imm32/no-r32 -10402 2/imm32/imm32-is-first-inout -10403 0/imm32/no-disp32 -10404 0/imm32/output-is-write-only +10395 _Primitive-subtract-lit-from-mem/imm32/next +10396 _Primitive-subtract-lit-from-mem: # (payload primitive) +10397 0x11/imm32/alloc-id:fake:payload +10398 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 +10399 0x11/imm32/alloc-id:fake +10400 _string-subtract-from/imm32/name +10401 0x11/imm32/alloc-id:fake +10402 Int-var-and-literal/imm32/inouts +10403 0/imm32/no-outputs +10404 0/imm32/no-outputs 10405 0x11/imm32/alloc-id:fake -10406 _Primitive-and-with-eax/imm32/next -10407 # - and -10408 _Primitive-and-with-eax: # (payload primitive) -10409 0x11/imm32/alloc-id:fake:payload -10410 # var/eax <- and lit => 25/and-with-eax lit/imm32 -10411 0x11/imm32/alloc-id:fake -10412 _string-and/imm32/name -10413 0x11/imm32/alloc-id:fake -10414 Single-lit-var/imm32/inouts -10415 0x11/imm32/alloc-id:fake -10416 Single-int-var-in-eax/imm32/outputs -10417 0x11/imm32/alloc-id:fake -10418 _string_25_and_with_eax/imm32/subx-name -10419 0/imm32/no-rm32 -10420 0/imm32/no-r32 -10421 1/imm32/imm32-is-first-inout -10422 0/imm32/no-disp32 -10423 0/imm32/output-is-write-only +10406 _string_81_subop_subtract/imm32/subx-name +10407 1/imm32/rm32-is-first-inout +10408 0/imm32/no-r32 +10409 2/imm32/imm32-is-first-inout +10410 0/imm32/no-disp32 +10411 0/imm32/output-is-write-only +10412 0x11/imm32/alloc-id:fake +10413 _Primitive-and-with-eax/imm32/next +10414 # - and +10415 _Primitive-and-with-eax: # (payload primitive) +10416 0x11/imm32/alloc-id:fake:payload +10417 # var/eax <- and lit => 25/and-with-eax lit/imm32 +10418 0x11/imm32/alloc-id:fake +10419 _string-and/imm32/name +10420 0x11/imm32/alloc-id:fake +10421 Single-lit-var/imm32/inouts +10422 0x11/imm32/alloc-id:fake +10423 Single-int-var-in-eax/imm32/outputs 10424 0x11/imm32/alloc-id:fake -10425 _Primitive-and-reg-with-reg/imm32/next -10426 _Primitive-and-reg-with-reg: # (payload primitive) -10427 0x11/imm32/alloc-id:fake:payload -10428 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 -10429 0x11/imm32/alloc-id:fake -10430 _string-and/imm32/name +10425 _string_25_and_with_eax/imm32/subx-name +10426 0/imm32/no-rm32 +10427 0/imm32/no-r32 +10428 1/imm32/imm32-is-first-inout +10429 0/imm32/no-disp32 +10430 0/imm32/output-is-write-only 10431 0x11/imm32/alloc-id:fake -10432 Single-int-var-in-some-register/imm32/inouts -10433 0x11/imm32/alloc-id:fake -10434 Single-int-var-in-some-register/imm32/outputs -10435 0x11/imm32/alloc-id:fake -10436 _string_21_and_with/imm32/subx-name -10437 3/imm32/rm32-is-first-output -10438 1/imm32/r32-is-first-inout -10439 0/imm32/no-imm32 -10440 0/imm32/no-disp32 -10441 0/imm32/output-is-write-only +10432 _Primitive-and-reg-with-reg/imm32/next +10433 _Primitive-and-reg-with-reg: # (payload primitive) +10434 0x11/imm32/alloc-id:fake:payload +10435 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 +10436 0x11/imm32/alloc-id:fake +10437 _string-and/imm32/name +10438 0x11/imm32/alloc-id:fake +10439 Single-int-var-in-some-register/imm32/inouts +10440 0x11/imm32/alloc-id:fake +10441 Single-int-var-in-some-register/imm32/outputs 10442 0x11/imm32/alloc-id:fake -10443 _Primitive-and-reg-with-mem/imm32/next -10444 _Primitive-and-reg-with-mem: # (payload primitive) -10445 0x11/imm32/alloc-id:fake:payload -10446 # and-with var1 var2/reg => 21/and-with var1 var2/r32 -10447 0x11/imm32/alloc-id:fake -10448 _string-and-with/imm32/name +10443 _string_21_and_with/imm32/subx-name +10444 3/imm32/rm32-is-first-output +10445 1/imm32/r32-is-first-inout +10446 0/imm32/no-imm32 +10447 0/imm32/no-disp32 +10448 0/imm32/output-is-write-only 10449 0x11/imm32/alloc-id:fake -10450 Two-args-int-stack-int-reg/imm32/inouts -10451 0/imm32/no-outputs -10452 0/imm32/no-outputs -10453 0x11/imm32/alloc-id:fake -10454 _string_21_and_with/imm32/subx-name -10455 1/imm32/rm32-is-first-inout -10456 2/imm32/r32-is-second-inout -10457 0/imm32/no-imm32 -10458 0/imm32/no-disp32 -10459 0/imm32/output-is-write-only +10450 _Primitive-and-reg-with-mem/imm32/next +10451 _Primitive-and-reg-with-mem: # (payload primitive) +10452 0x11/imm32/alloc-id:fake:payload +10453 # and-with var1 var2/reg => 21/and-with var1 var2/r32 +10454 0x11/imm32/alloc-id:fake +10455 _string-and-with/imm32/name +10456 0x11/imm32/alloc-id:fake +10457 Two-args-int-stack-int-reg/imm32/inouts +10458 0/imm32/no-outputs +10459 0/imm32/no-outputs 10460 0x11/imm32/alloc-id:fake -10461 _Primitive-and-mem-with-reg/imm32/next -10462 _Primitive-and-mem-with-reg: # (payload primitive) -10463 0x11/imm32/alloc-id:fake:payload -10464 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 -10465 0x11/imm32/alloc-id:fake -10466 _string-and/imm32/name +10461 _string_21_and_with/imm32/subx-name +10462 1/imm32/rm32-is-first-inout +10463 2/imm32/r32-is-second-inout +10464 0/imm32/no-imm32 +10465 0/imm32/no-disp32 +10466 0/imm32/output-is-write-only 10467 0x11/imm32/alloc-id:fake -10468 Single-int-var-in-mem/imm32/inouts -10469 0x11/imm32/alloc-id:fake -10470 Single-int-var-in-some-register/imm32/outputs -10471 0x11/imm32/alloc-id:fake -10472 _string_23_and/imm32/subx-name -10473 1/imm32/rm32-is-first-inout -10474 3/imm32/r32-is-first-output -10475 0/imm32/no-imm32 -10476 0/imm32/no-disp32 -10477 0/imm32/output-is-write-only +10468 _Primitive-and-mem-with-reg/imm32/next +10469 _Primitive-and-mem-with-reg: # (payload primitive) +10470 0x11/imm32/alloc-id:fake:payload +10471 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 +10472 0x11/imm32/alloc-id:fake +10473 _string-and/imm32/name +10474 0x11/imm32/alloc-id:fake +10475 Single-int-var-in-mem/imm32/inouts +10476 0x11/imm32/alloc-id:fake +10477 Single-int-var-in-some-register/imm32/outputs 10478 0x11/imm32/alloc-id:fake -10479 _Primitive-and-lit-with-reg/imm32/next -10480 _Primitive-and-lit-with-reg: # (payload primitive) -10481 0x11/imm32/alloc-id:fake:payload -10482 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 -10483 0x11/imm32/alloc-id:fake -10484 _string-and/imm32/name +10479 _string_23_and/imm32/subx-name +10480 1/imm32/rm32-is-first-inout +10481 3/imm32/r32-is-first-output +10482 0/imm32/no-imm32 +10483 0/imm32/no-disp32 +10484 0/imm32/output-is-write-only 10485 0x11/imm32/alloc-id:fake -10486 Single-lit-var/imm32/inouts -10487 0x11/imm32/alloc-id:fake -10488 Single-int-var-in-some-register/imm32/outputs -10489 0x11/imm32/alloc-id:fake -10490 _string_81_subop_and/imm32/subx-name -10491 3/imm32/rm32-is-first-output -10492 0/imm32/no-r32 -10493 1/imm32/imm32-is-first-inout -10494 0/imm32/no-disp32 -10495 0/imm32/output-is-write-only +10486 _Primitive-and-lit-with-reg/imm32/next +10487 _Primitive-and-lit-with-reg: # (payload primitive) +10488 0x11/imm32/alloc-id:fake:payload +10489 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 +10490 0x11/imm32/alloc-id:fake +10491 _string-and/imm32/name +10492 0x11/imm32/alloc-id:fake +10493 Single-lit-var/imm32/inouts +10494 0x11/imm32/alloc-id:fake +10495 Single-int-var-in-some-register/imm32/outputs 10496 0x11/imm32/alloc-id:fake -10497 _Primitive-and-lit-with-mem/imm32/next -10498 _Primitive-and-lit-with-mem: # (payload primitive) -10499 0x11/imm32/alloc-id:fake:payload -10500 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 -10501 0x11/imm32/alloc-id:fake -10502 _string-and-with/imm32/name +10497 _string_81_subop_and/imm32/subx-name +10498 3/imm32/rm32-is-first-output +10499 0/imm32/no-r32 +10500 1/imm32/imm32-is-first-inout +10501 0/imm32/no-disp32 +10502 0/imm32/output-is-write-only 10503 0x11/imm32/alloc-id:fake -10504 Int-var-and-literal/imm32/inouts -10505 0/imm32/no-outputs -10506 0/imm32/no-outputs -10507 0x11/imm32/alloc-id:fake -10508 _string_81_subop_and/imm32/subx-name -10509 1/imm32/rm32-is-first-inout -10510 0/imm32/no-r32 -10511 2/imm32/imm32-is-first-inout -10512 0/imm32/no-disp32 -10513 0/imm32/output-is-write-only +10504 _Primitive-and-lit-with-mem/imm32/next +10505 _Primitive-and-lit-with-mem: # (payload primitive) +10506 0x11/imm32/alloc-id:fake:payload +10507 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 +10508 0x11/imm32/alloc-id:fake +10509 _string-and-with/imm32/name +10510 0x11/imm32/alloc-id:fake +10511 Int-var-and-literal/imm32/inouts +10512 0/imm32/no-outputs +10513 0/imm32/no-outputs 10514 0x11/imm32/alloc-id:fake -10515 _Primitive-or-with-eax/imm32/next -10516 # - or -10517 _Primitive-or-with-eax: # (payload primitive) -10518 0x11/imm32/alloc-id:fake:payload -10519 # var/eax <- or lit => 0d/or-with-eax lit/imm32 -10520 0x11/imm32/alloc-id:fake -10521 _string-or/imm32/name -10522 0x11/imm32/alloc-id:fake -10523 Single-lit-var/imm32/inouts -10524 0x11/imm32/alloc-id:fake -10525 Single-int-var-in-eax/imm32/outputs -10526 0x11/imm32/alloc-id:fake -10527 _string_0d_or_with_eax/imm32/subx-name -10528 0/imm32/no-rm32 -10529 0/imm32/no-r32 -10530 1/imm32/imm32-is-first-inout -10531 0/imm32/no-disp32 -10532 0/imm32/output-is-write-only +10515 _string_81_subop_and/imm32/subx-name +10516 1/imm32/rm32-is-first-inout +10517 0/imm32/no-r32 +10518 2/imm32/imm32-is-first-inout +10519 0/imm32/no-disp32 +10520 0/imm32/output-is-write-only +10521 0x11/imm32/alloc-id:fake +10522 _Primitive-or-with-eax/imm32/next +10523 # - or +10524 _Primitive-or-with-eax: # (payload primitive) +10525 0x11/imm32/alloc-id:fake:payload +10526 # var/eax <- or lit => 0d/or-with-eax lit/imm32 +10527 0x11/imm32/alloc-id:fake +10528 _string-or/imm32/name +10529 0x11/imm32/alloc-id:fake +10530 Single-lit-var/imm32/inouts +10531 0x11/imm32/alloc-id:fake +10532 Single-int-var-in-eax/imm32/outputs 10533 0x11/imm32/alloc-id:fake -10534 _Primitive-or-reg-with-reg/imm32/next -10535 _Primitive-or-reg-with-reg: # (payload primitive) -10536 0x11/imm32/alloc-id:fake:payload -10537 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 -10538 0x11/imm32/alloc-id:fake -10539 _string-or/imm32/name +10534 _string_0d_or_with_eax/imm32/subx-name +10535 0/imm32/no-rm32 +10536 0/imm32/no-r32 +10537 1/imm32/imm32-is-first-inout +10538 0/imm32/no-disp32 +10539 0/imm32/output-is-write-only 10540 0x11/imm32/alloc-id:fake -10541 Single-int-var-in-some-register/imm32/inouts -10542 0x11/imm32/alloc-id:fake -10543 Single-int-var-in-some-register/imm32/outputs -10544 0x11/imm32/alloc-id:fake -10545 _string_09_or_with/imm32/subx-name -10546 3/imm32/rm32-is-first-output -10547 1/imm32/r32-is-first-inout -10548 0/imm32/no-imm32 -10549 0/imm32/no-disp32 -10550 0/imm32/output-is-write-only +10541 _Primitive-or-reg-with-reg/imm32/next +10542 _Primitive-or-reg-with-reg: # (payload primitive) +10543 0x11/imm32/alloc-id:fake:payload +10544 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 +10545 0x11/imm32/alloc-id:fake +10546 _string-or/imm32/name +10547 0x11/imm32/alloc-id:fake +10548 Single-int-var-in-some-register/imm32/inouts +10549 0x11/imm32/alloc-id:fake +10550 Single-int-var-in-some-register/imm32/outputs 10551 0x11/imm32/alloc-id:fake -10552 _Primitive-or-reg-with-mem/imm32/next -10553 _Primitive-or-reg-with-mem: # (payload primitive) -10554 0x11/imm32/alloc-id:fake:payload -10555 # or-with var1 var2/reg => 09/or-with var1 var2/r32 -10556 0x11/imm32/alloc-id:fake -10557 _string-or-with/imm32/name +10552 _string_09_or_with/imm32/subx-name +10553 3/imm32/rm32-is-first-output +10554 1/imm32/r32-is-first-inout +10555 0/imm32/no-imm32 +10556 0/imm32/no-disp32 +10557 0/imm32/output-is-write-only 10558 0x11/imm32/alloc-id:fake -10559 Two-args-int-stack-int-reg/imm32/inouts -10560 0/imm32/no-outputs -10561 0/imm32/no-outputs -10562 0x11/imm32/alloc-id:fake -10563 _string_09_or_with/imm32/subx-name -10564 1/imm32/rm32-is-first-inout -10565 2/imm32/r32-is-second-inout -10566 0/imm32/no-imm32 -10567 0/imm32/no-disp32 -10568 0/imm32/output-is-write-only +10559 _Primitive-or-reg-with-mem/imm32/next +10560 _Primitive-or-reg-with-mem: # (payload primitive) +10561 0x11/imm32/alloc-id:fake:payload +10562 # or-with var1 var2/reg => 09/or-with var1 var2/r32 +10563 0x11/imm32/alloc-id:fake +10564 _string-or-with/imm32/name +10565 0x11/imm32/alloc-id:fake +10566 Two-args-int-stack-int-reg/imm32/inouts +10567 0/imm32/no-outputs +10568 0/imm32/no-outputs 10569 0x11/imm32/alloc-id:fake -10570 _Primitive-or-mem-with-reg/imm32/next -10571 _Primitive-or-mem-with-reg: # (payload primitive) -10572 0x11/imm32/alloc-id:fake:payload -10573 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 -10574 0x11/imm32/alloc-id:fake -10575 _string-or/imm32/name +10570 _string_09_or_with/imm32/subx-name +10571 1/imm32/rm32-is-first-inout +10572 2/imm32/r32-is-second-inout +10573 0/imm32/no-imm32 +10574 0/imm32/no-disp32 +10575 0/imm32/output-is-write-only 10576 0x11/imm32/alloc-id:fake -10577 Single-int-var-in-mem/imm32/inouts -10578 0x11/imm32/alloc-id:fake -10579 Single-int-var-in-some-register/imm32/outputs -10580 0x11/imm32/alloc-id:fake -10581 _string_0b_or/imm32/subx-name -10582 1/imm32/rm32-is-first-inout -10583 3/imm32/r32-is-first-output -10584 0/imm32/no-imm32 -10585 0/imm32/no-disp32 -10586 0/imm32/output-is-write-only +10577 _Primitive-or-mem-with-reg/imm32/next +10578 _Primitive-or-mem-with-reg: # (payload primitive) +10579 0x11/imm32/alloc-id:fake:payload +10580 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 +10581 0x11/imm32/alloc-id:fake +10582 _string-or/imm32/name +10583 0x11/imm32/alloc-id:fake +10584 Single-int-var-in-mem/imm32/inouts +10585 0x11/imm32/alloc-id:fake +10586 Single-int-var-in-some-register/imm32/outputs 10587 0x11/imm32/alloc-id:fake -10588 _Primitive-or-lit-with-reg/imm32/next -10589 _Primitive-or-lit-with-reg: # (payload primitive) -10590 0x11/imm32/alloc-id:fake:payload -10591 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 -10592 0x11/imm32/alloc-id:fake -10593 _string-or/imm32/name +10588 _string_0b_or/imm32/subx-name +10589 1/imm32/rm32-is-first-inout +10590 3/imm32/r32-is-first-output +10591 0/imm32/no-imm32 +10592 0/imm32/no-disp32 +10593 0/imm32/output-is-write-only 10594 0x11/imm32/alloc-id:fake -10595 Single-lit-var/imm32/inouts -10596 0x11/imm32/alloc-id:fake -10597 Single-int-var-in-some-register/imm32/outputs -10598 0x11/imm32/alloc-id:fake -10599 _string_81_subop_or/imm32/subx-name -10600 3/imm32/rm32-is-first-output -10601 0/imm32/no-r32 -10602 1/imm32/imm32-is-first-inout -10603 0/imm32/no-disp32 -10604 0/imm32/output-is-write-only +10595 _Primitive-or-lit-with-reg/imm32/next +10596 _Primitive-or-lit-with-reg: # (payload primitive) +10597 0x11/imm32/alloc-id:fake:payload +10598 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 +10599 0x11/imm32/alloc-id:fake +10600 _string-or/imm32/name +10601 0x11/imm32/alloc-id:fake +10602 Single-lit-var/imm32/inouts +10603 0x11/imm32/alloc-id:fake +10604 Single-int-var-in-some-register/imm32/outputs 10605 0x11/imm32/alloc-id:fake -10606 _Primitive-or-lit-with-mem/imm32/next -10607 _Primitive-or-lit-with-mem: # (payload primitive) -10608 0x11/imm32/alloc-id:fake:payload -10609 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 -10610 0x11/imm32/alloc-id:fake -10611 _string-or-with/imm32/name +10606 _string_81_subop_or/imm32/subx-name +10607 3/imm32/rm32-is-first-output +10608 0/imm32/no-r32 +10609 1/imm32/imm32-is-first-inout +10610 0/imm32/no-disp32 +10611 0/imm32/output-is-write-only 10612 0x11/imm32/alloc-id:fake -10613 Int-var-and-literal/imm32/inouts -10614 0/imm32/no-outputs -10615 0/imm32/no-outputs -10616 0x11/imm32/alloc-id:fake -10617 _string_81_subop_or/imm32/subx-name -10618 1/imm32/rm32-is-first-inout -10619 0/imm32/no-r32 -10620 2/imm32/imm32-is-second-inout -10621 0/imm32/no-disp32 -10622 0/imm32/output-is-write-only +10613 _Primitive-or-lit-with-mem/imm32/next +10614 _Primitive-or-lit-with-mem: # (payload primitive) +10615 0x11/imm32/alloc-id:fake:payload +10616 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 +10617 0x11/imm32/alloc-id:fake +10618 _string-or-with/imm32/name +10619 0x11/imm32/alloc-id:fake +10620 Int-var-and-literal/imm32/inouts +10621 0/imm32/no-outputs +10622 0/imm32/no-outputs 10623 0x11/imm32/alloc-id:fake -10624 _Primitive-xor-with-eax/imm32/next -10625 # - xor -10626 _Primitive-xor-with-eax: # (payload primitive) -10627 0x11/imm32/alloc-id:fake:payload -10628 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 -10629 0x11/imm32/alloc-id:fake -10630 _string-xor/imm32/name -10631 0x11/imm32/alloc-id:fake -10632 Single-lit-var/imm32/inouts -10633 0x11/imm32/alloc-id:fake -10634 Single-int-var-in-eax/imm32/outputs -10635 0x11/imm32/alloc-id:fake -10636 _string_35_xor_with_eax/imm32/subx-name -10637 0/imm32/no-rm32 -10638 0/imm32/no-r32 -10639 1/imm32/imm32-is-first-inout -10640 0/imm32/no-disp32 -10641 0/imm32/output-is-write-only +10624 _string_81_subop_or/imm32/subx-name +10625 1/imm32/rm32-is-first-inout +10626 0/imm32/no-r32 +10627 2/imm32/imm32-is-second-inout +10628 0/imm32/no-disp32 +10629 0/imm32/output-is-write-only +10630 0x11/imm32/alloc-id:fake +10631 _Primitive-xor-with-eax/imm32/next +10632 # - xor +10633 _Primitive-xor-with-eax: # (payload primitive) +10634 0x11/imm32/alloc-id:fake:payload +10635 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 +10636 0x11/imm32/alloc-id:fake +10637 _string-xor/imm32/name +10638 0x11/imm32/alloc-id:fake +10639 Single-lit-var/imm32/inouts +10640 0x11/imm32/alloc-id:fake +10641 Single-int-var-in-eax/imm32/outputs 10642 0x11/imm32/alloc-id:fake -10643 _Primitive-xor-reg-with-reg/imm32/next -10644 _Primitive-xor-reg-with-reg: # (payload primitive) -10645 0x11/imm32/alloc-id:fake:payload -10646 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 -10647 0x11/imm32/alloc-id:fake -10648 _string-xor/imm32/name +10643 _string_35_xor_with_eax/imm32/subx-name +10644 0/imm32/no-rm32 +10645 0/imm32/no-r32 +10646 1/imm32/imm32-is-first-inout +10647 0/imm32/no-disp32 +10648 0/imm32/output-is-write-only 10649 0x11/imm32/alloc-id:fake -10650 Single-int-var-in-some-register/imm32/inouts -10651 0x11/imm32/alloc-id:fake -10652 Single-int-var-in-some-register/imm32/outputs -10653 0x11/imm32/alloc-id:fake -10654 _string_31_xor_with/imm32/subx-name -10655 3/imm32/rm32-is-first-output -10656 1/imm32/r32-is-first-inout -10657 0/imm32/no-imm32 -10658 0/imm32/no-disp32 -10659 0/imm32/output-is-write-only +10650 _Primitive-xor-reg-with-reg/imm32/next +10651 _Primitive-xor-reg-with-reg: # (payload primitive) +10652 0x11/imm32/alloc-id:fake:payload +10653 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 +10654 0x11/imm32/alloc-id:fake +10655 _string-xor/imm32/name +10656 0x11/imm32/alloc-id:fake +10657 Single-int-var-in-some-register/imm32/inouts +10658 0x11/imm32/alloc-id:fake +10659 Single-int-var-in-some-register/imm32/outputs 10660 0x11/imm32/alloc-id:fake -10661 _Primitive-xor-reg-with-mem/imm32/next -10662 _Primitive-xor-reg-with-mem: # (payload primitive) -10663 0x11/imm32/alloc-id:fake:payload -10664 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 -10665 0x11/imm32/alloc-id:fake -10666 _string-xor-with/imm32/name +10661 _string_31_xor_with/imm32/subx-name +10662 3/imm32/rm32-is-first-output +10663 1/imm32/r32-is-first-inout +10664 0/imm32/no-imm32 +10665 0/imm32/no-disp32 +10666 0/imm32/output-is-write-only 10667 0x11/imm32/alloc-id:fake -10668 Two-args-int-stack-int-reg/imm32/inouts -10669 0/imm32/no-outputs -10670 0/imm32/no-outputs -10671 0x11/imm32/alloc-id:fake -10672 _string_31_xor_with/imm32/subx-name -10673 1/imm32/rm32-is-first-inout -10674 2/imm32/r32-is-second-inout -10675 0/imm32/no-imm32 -10676 0/imm32/no-disp32 -10677 0/imm32/output-is-write-only +10668 _Primitive-xor-reg-with-mem/imm32/next +10669 _Primitive-xor-reg-with-mem: # (payload primitive) +10670 0x11/imm32/alloc-id:fake:payload +10671 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 +10672 0x11/imm32/alloc-id:fake +10673 _string-xor-with/imm32/name +10674 0x11/imm32/alloc-id:fake +10675 Two-args-int-stack-int-reg/imm32/inouts +10676 0/imm32/no-outputs +10677 0/imm32/no-outputs 10678 0x11/imm32/alloc-id:fake -10679 _Primitive-xor-mem-with-reg/imm32/next -10680 _Primitive-xor-mem-with-reg: # (payload primitive) -10681 0x11/imm32/alloc-id:fake:payload -10682 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 -10683 0x11/imm32/alloc-id:fake -10684 _string-xor/imm32/name +10679 _string_31_xor_with/imm32/subx-name +10680 1/imm32/rm32-is-first-inout +10681 2/imm32/r32-is-second-inout +10682 0/imm32/no-imm32 +10683 0/imm32/no-disp32 +10684 0/imm32/output-is-write-only 10685 0x11/imm32/alloc-id:fake -10686 Single-int-var-in-mem/imm32/inouts -10687 0x11/imm32/alloc-id:fake -10688 Single-int-var-in-some-register/imm32/outputs -10689 0x11/imm32/alloc-id:fake -10690 _string_33_xor/imm32/subx-name -10691 1/imm32/rm32-is-first-inout -10692 3/imm32/r32-is-first-output -10693 0/imm32/no-imm32 -10694 0/imm32/no-disp32 -10695 0/imm32/output-is-write-only +10686 _Primitive-xor-mem-with-reg/imm32/next +10687 _Primitive-xor-mem-with-reg: # (payload primitive) +10688 0x11/imm32/alloc-id:fake:payload +10689 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 +10690 0x11/imm32/alloc-id:fake +10691 _string-xor/imm32/name +10692 0x11/imm32/alloc-id:fake +10693 Single-int-var-in-mem/imm32/inouts +10694 0x11/imm32/alloc-id:fake +10695 Single-int-var-in-some-register/imm32/outputs 10696 0x11/imm32/alloc-id:fake -10697 _Primitive-xor-lit-with-reg/imm32/next -10698 _Primitive-xor-lit-with-reg: # (payload primitive) -10699 0x11/imm32/alloc-id:fake:payload -10700 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 -10701 0x11/imm32/alloc-id:fake -10702 _string-xor/imm32/name +10697 _string_33_xor/imm32/subx-name +10698 1/imm32/rm32-is-first-inout +10699 3/imm32/r32-is-first-output +10700 0/imm32/no-imm32 +10701 0/imm32/no-disp32 +10702 0/imm32/output-is-write-only 10703 0x11/imm32/alloc-id:fake -10704 Single-lit-var/imm32/inouts -10705 0x11/imm32/alloc-id:fake -10706 Single-int-var-in-some-register/imm32/outputs -10707 0x11/imm32/alloc-id:fake -10708 _string_81_subop_xor/imm32/subx-name -10709 3/imm32/rm32-is-first-output -10710 0/imm32/no-r32 -10711 1/imm32/imm32-is-first-inout -10712 0/imm32/no-disp32 -10713 0/imm32/output-is-write-only +10704 _Primitive-xor-lit-with-reg/imm32/next +10705 _Primitive-xor-lit-with-reg: # (payload primitive) +10706 0x11/imm32/alloc-id:fake:payload +10707 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 +10708 0x11/imm32/alloc-id:fake +10709 _string-xor/imm32/name +10710 0x11/imm32/alloc-id:fake +10711 Single-lit-var/imm32/inouts +10712 0x11/imm32/alloc-id:fake +10713 Single-int-var-in-some-register/imm32/outputs 10714 0x11/imm32/alloc-id:fake -10715 _Primitive-xor-lit-with-mem/imm32/next -10716 _Primitive-xor-lit-with-mem: # (payload primitive) -10717 0x11/imm32/alloc-id:fake:payload -10718 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 -10719 0x11/imm32/alloc-id:fake -10720 _string-xor-with/imm32/name +10715 _string_81_subop_xor/imm32/subx-name +10716 3/imm32/rm32-is-first-output +10717 0/imm32/no-r32 +10718 1/imm32/imm32-is-first-inout +10719 0/imm32/no-disp32 +10720 0/imm32/output-is-write-only 10721 0x11/imm32/alloc-id:fake -10722 Int-var-and-literal/imm32/inouts -10723 0/imm32/no-outputs -10724 0/imm32/no-outputs -10725 0x11/imm32/alloc-id:fake -10726 _string_81_subop_xor/imm32/subx-name -10727 1/imm32/rm32-is-first-inout -10728 0/imm32/no-r32 -10729 2/imm32/imm32-is-first-inout -10730 0/imm32/no-disp32 -10731 0/imm32/output-is-write-only +10722 _Primitive-xor-lit-with-mem/imm32/next +10723 _Primitive-xor-lit-with-mem: # (payload primitive) +10724 0x11/imm32/alloc-id:fake:payload +10725 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 +10726 0x11/imm32/alloc-id:fake +10727 _string-xor-with/imm32/name +10728 0x11/imm32/alloc-id:fake +10729 Int-var-and-literal/imm32/inouts +10730 0/imm32/no-outputs +10731 0/imm32/no-outputs 10732 0x11/imm32/alloc-id:fake -10733 _Primitive-copy-to-eax/imm32/next -10734 # - copy -10735 _Primitive-copy-to-eax: # (payload primitive) -10736 0x11/imm32/alloc-id:fake:payload -10737 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 -10738 0x11/imm32/alloc-id:fake -10739 _string-copy/imm32/name -10740 0x11/imm32/alloc-id:fake -10741 Single-lit-var/imm32/inouts -10742 0x11/imm32/alloc-id:fake -10743 Single-int-var-in-eax/imm32/outputs -10744 0x11/imm32/alloc-id:fake -10745 _string_b8_copy_to_eax/imm32/subx-name -10746 0/imm32/no-rm32 -10747 0/imm32/no-r32 -10748 1/imm32/imm32-is-first-inout -10749 0/imm32/no-disp32 -10750 1/imm32/output-is-write-only +10733 _string_81_subop_xor/imm32/subx-name +10734 1/imm32/rm32-is-first-inout +10735 0/imm32/no-r32 +10736 2/imm32/imm32-is-first-inout +10737 0/imm32/no-disp32 +10738 0/imm32/output-is-write-only +10739 0x11/imm32/alloc-id:fake +10740 _Primitive-copy-to-eax/imm32/next +10741 # - copy +10742 _Primitive-copy-to-eax: # (payload primitive) +10743 0x11/imm32/alloc-id:fake:payload +10744 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 +10745 0x11/imm32/alloc-id:fake +10746 _string-copy/imm32/name +10747 0x11/imm32/alloc-id:fake +10748 Single-lit-var/imm32/inouts +10749 0x11/imm32/alloc-id:fake +10750 Single-int-var-in-eax/imm32/outputs 10751 0x11/imm32/alloc-id:fake -10752 _Primitive-copy-to-ecx/imm32/next -10753 _Primitive-copy-to-ecx: # (payload primitive) -10754 0x11/imm32/alloc-id:fake:payload -10755 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 -10756 0x11/imm32/alloc-id:fake -10757 _string-copy/imm32/name +10752 _string_b8_copy_to_eax/imm32/subx-name +10753 0/imm32/no-rm32 +10754 0/imm32/no-r32 +10755 1/imm32/imm32-is-first-inout +10756 0/imm32/no-disp32 +10757 1/imm32/output-is-write-only 10758 0x11/imm32/alloc-id:fake -10759 Single-lit-var/imm32/inouts -10760 0x11/imm32/alloc-id:fake -10761 Single-int-var-in-ecx/imm32/outputs -10762 0x11/imm32/alloc-id:fake -10763 _string_b9_copy_to_ecx/imm32/subx-name -10764 0/imm32/no-rm32 -10765 0/imm32/no-r32 -10766 1/imm32/imm32-is-first-inout -10767 0/imm32/no-disp32 -10768 1/imm32/output-is-write-only +10759 _Primitive-copy-to-ecx/imm32/next +10760 _Primitive-copy-to-ecx: # (payload primitive) +10761 0x11/imm32/alloc-id:fake:payload +10762 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 +10763 0x11/imm32/alloc-id:fake +10764 _string-copy/imm32/name +10765 0x11/imm32/alloc-id:fake +10766 Single-lit-var/imm32/inouts +10767 0x11/imm32/alloc-id:fake +10768 Single-int-var-in-ecx/imm32/outputs 10769 0x11/imm32/alloc-id:fake -10770 _Primitive-copy-to-edx/imm32/next -10771 _Primitive-copy-to-edx: # (payload primitive) -10772 0x11/imm32/alloc-id:fake:payload -10773 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 -10774 0x11/imm32/alloc-id:fake -10775 _string-copy/imm32/name +10770 _string_b9_copy_to_ecx/imm32/subx-name +10771 0/imm32/no-rm32 +10772 0/imm32/no-r32 +10773 1/imm32/imm32-is-first-inout +10774 0/imm32/no-disp32 +10775 1/imm32/output-is-write-only 10776 0x11/imm32/alloc-id:fake -10777 Single-lit-var/imm32/inouts -10778 0x11/imm32/alloc-id:fake -10779 Single-int-var-in-edx/imm32/outputs -10780 0x11/imm32/alloc-id:fake -10781 _string_ba_copy_to_edx/imm32/subx-name -10782 0/imm32/no-rm32 -10783 0/imm32/no-r32 -10784 1/imm32/imm32-is-first-inout -10785 0/imm32/no-disp32 -10786 1/imm32/output-is-write-only +10777 _Primitive-copy-to-edx/imm32/next +10778 _Primitive-copy-to-edx: # (payload primitive) +10779 0x11/imm32/alloc-id:fake:payload +10780 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 +10781 0x11/imm32/alloc-id:fake +10782 _string-copy/imm32/name +10783 0x11/imm32/alloc-id:fake +10784 Single-lit-var/imm32/inouts +10785 0x11/imm32/alloc-id:fake +10786 Single-int-var-in-edx/imm32/outputs 10787 0x11/imm32/alloc-id:fake -10788 _Primitive-copy-to-ebx/imm32/next -10789 _Primitive-copy-to-ebx: # (payload primitive) -10790 0x11/imm32/alloc-id:fake:payload -10791 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 -10792 0x11/imm32/alloc-id:fake -10793 _string-copy/imm32/name +10788 _string_ba_copy_to_edx/imm32/subx-name +10789 0/imm32/no-rm32 +10790 0/imm32/no-r32 +10791 1/imm32/imm32-is-first-inout +10792 0/imm32/no-disp32 +10793 1/imm32/output-is-write-only 10794 0x11/imm32/alloc-id:fake -10795 Single-lit-var/imm32/inouts -10796 0x11/imm32/alloc-id:fake -10797 Single-int-var-in-ebx/imm32/outputs -10798 0x11/imm32/alloc-id:fake -10799 _string_bb_copy_to_ebx/imm32/subx-name -10800 0/imm32/no-rm32 -10801 0/imm32/no-r32 -10802 1/imm32/imm32-is-first-inout -10803 0/imm32/no-disp32 -10804 1/imm32/output-is-write-only +10795 _Primitive-copy-to-ebx/imm32/next +10796 _Primitive-copy-to-ebx: # (payload primitive) +10797 0x11/imm32/alloc-id:fake:payload +10798 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 +10799 0x11/imm32/alloc-id:fake +10800 _string-copy/imm32/name +10801 0x11/imm32/alloc-id:fake +10802 Single-lit-var/imm32/inouts +10803 0x11/imm32/alloc-id:fake +10804 Single-int-var-in-ebx/imm32/outputs 10805 0x11/imm32/alloc-id:fake -10806 _Primitive-copy-to-esi/imm32/next -10807 _Primitive-copy-to-esi: # (payload primitive) -10808 0x11/imm32/alloc-id:fake:payload -10809 # var/esi <- copy lit => be/copy-to-esi lit/imm32 -10810 0x11/imm32/alloc-id:fake -10811 _string-copy/imm32/name +10806 _string_bb_copy_to_ebx/imm32/subx-name +10807 0/imm32/no-rm32 +10808 0/imm32/no-r32 +10809 1/imm32/imm32-is-first-inout +10810 0/imm32/no-disp32 +10811 1/imm32/output-is-write-only 10812 0x11/imm32/alloc-id:fake -10813 Single-lit-var/imm32/inouts -10814 0x11/imm32/alloc-id:fake -10815 Single-int-var-in-esi/imm32/outputs -10816 0x11/imm32/alloc-id:fake -10817 _string_be_copy_to_esi/imm32/subx-name -10818 0/imm32/no-rm32 -10819 0/imm32/no-r32 -10820 1/imm32/imm32-is-first-inout -10821 0/imm32/no-disp32 -10822 1/imm32/output-is-write-only +10813 _Primitive-copy-to-esi/imm32/next +10814 _Primitive-copy-to-esi: # (payload primitive) +10815 0x11/imm32/alloc-id:fake:payload +10816 # var/esi <- copy lit => be/copy-to-esi lit/imm32 +10817 0x11/imm32/alloc-id:fake +10818 _string-copy/imm32/name +10819 0x11/imm32/alloc-id:fake +10820 Single-lit-var/imm32/inouts +10821 0x11/imm32/alloc-id:fake +10822 Single-int-var-in-esi/imm32/outputs 10823 0x11/imm32/alloc-id:fake -10824 _Primitive-copy-to-edi/imm32/next -10825 _Primitive-copy-to-edi: # (payload primitive) -10826 0x11/imm32/alloc-id:fake:payload -10827 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 -10828 0x11/imm32/alloc-id:fake -10829 _string-copy/imm32/name +10824 _string_be_copy_to_esi/imm32/subx-name +10825 0/imm32/no-rm32 +10826 0/imm32/no-r32 +10827 1/imm32/imm32-is-first-inout +10828 0/imm32/no-disp32 +10829 1/imm32/output-is-write-only 10830 0x11/imm32/alloc-id:fake -10831 Single-lit-var/imm32/inouts -10832 0x11/imm32/alloc-id:fake -10833 Single-int-var-in-edi/imm32/outputs -10834 0x11/imm32/alloc-id:fake -10835 _string_bf_copy_to_edi/imm32/subx-name -10836 0/imm32/no-rm32 -10837 0/imm32/no-r32 -10838 1/imm32/imm32-is-first-inout -10839 0/imm32/no-disp32 -10840 1/imm32/output-is-write-only +10831 _Primitive-copy-to-edi/imm32/next +10832 _Primitive-copy-to-edi: # (payload primitive) +10833 0x11/imm32/alloc-id:fake:payload +10834 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 +10835 0x11/imm32/alloc-id:fake +10836 _string-copy/imm32/name +10837 0x11/imm32/alloc-id:fake +10838 Single-lit-var/imm32/inouts +10839 0x11/imm32/alloc-id:fake +10840 Single-int-var-in-edi/imm32/outputs 10841 0x11/imm32/alloc-id:fake -10842 _Primitive-copy-reg-to-reg/imm32/next -10843 _Primitive-copy-reg-to-reg: # (payload primitive) -10844 0x11/imm32/alloc-id:fake:payload -10845 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 -10846 0x11/imm32/alloc-id:fake -10847 _string-copy/imm32/name +10842 _string_bf_copy_to_edi/imm32/subx-name +10843 0/imm32/no-rm32 +10844 0/imm32/no-r32 +10845 1/imm32/imm32-is-first-inout +10846 0/imm32/no-disp32 +10847 1/imm32/output-is-write-only 10848 0x11/imm32/alloc-id:fake -10849 Single-int-var-in-some-register/imm32/inouts -10850 0x11/imm32/alloc-id:fake -10851 Single-int-var-in-some-register/imm32/outputs -10852 0x11/imm32/alloc-id:fake -10853 _string_89_<-/imm32/subx-name -10854 3/imm32/rm32-is-first-output -10855 1/imm32/r32-is-first-inout -10856 0/imm32/no-imm32 -10857 0/imm32/no-disp32 -10858 1/imm32/output-is-write-only +10849 _Primitive-copy-reg-to-reg/imm32/next +10850 _Primitive-copy-reg-to-reg: # (payload primitive) +10851 0x11/imm32/alloc-id:fake:payload +10852 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 +10853 0x11/imm32/alloc-id:fake +10854 _string-copy/imm32/name +10855 0x11/imm32/alloc-id:fake +10856 Single-int-var-in-some-register/imm32/inouts +10857 0x11/imm32/alloc-id:fake +10858 Single-int-var-in-some-register/imm32/outputs 10859 0x11/imm32/alloc-id:fake -10860 _Primitive-copy-reg-to-mem/imm32/next -10861 _Primitive-copy-reg-to-mem: # (payload primitive) -10862 0x11/imm32/alloc-id:fake:payload -10863 # copy-to var1 var2/reg => 89/<- var1 var2/r32 -10864 0x11/imm32/alloc-id:fake -10865 _string-copy-to/imm32/name +10860 _string_89_<-/imm32/subx-name +10861 3/imm32/rm32-is-first-output +10862 1/imm32/r32-is-first-inout +10863 0/imm32/no-imm32 +10864 0/imm32/no-disp32 +10865 1/imm32/output-is-write-only 10866 0x11/imm32/alloc-id:fake -10867 Two-args-int-stack-int-reg/imm32/inouts -10868 0/imm32/no-outputs -10869 0/imm32/no-outputs -10870 0x11/imm32/alloc-id:fake -10871 _string_89_<-/imm32/subx-name -10872 1/imm32/rm32-is-first-inout -10873 2/imm32/r32-is-second-inout -10874 0/imm32/no-imm32 -10875 0/imm32/no-disp32 -10876 1/imm32/output-is-write-only +10867 _Primitive-copy-reg-to-mem/imm32/next +10868 _Primitive-copy-reg-to-mem: # (payload primitive) +10869 0x11/imm32/alloc-id:fake:payload +10870 # copy-to var1 var2/reg => 89/<- var1 var2/r32 +10871 0x11/imm32/alloc-id:fake +10872 _string-copy-to/imm32/name +10873 0x11/imm32/alloc-id:fake +10874 Two-args-int-stack-int-reg/imm32/inouts +10875 0/imm32/no-outputs +10876 0/imm32/no-outputs 10877 0x11/imm32/alloc-id:fake -10878 _Primitive-copy-mem-to-reg/imm32/next -10879 _Primitive-copy-mem-to-reg: # (payload primitive) -10880 0x11/imm32/alloc-id:fake:payload -10881 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 -10882 0x11/imm32/alloc-id:fake -10883 _string-copy/imm32/name +10878 _string_89_<-/imm32/subx-name +10879 1/imm32/rm32-is-first-inout +10880 2/imm32/r32-is-second-inout +10881 0/imm32/no-imm32 +10882 0/imm32/no-disp32 +10883 1/imm32/output-is-write-only 10884 0x11/imm32/alloc-id:fake -10885 Single-int-var-in-mem/imm32/inouts -10886 0x11/imm32/alloc-id:fake -10887 Single-int-var-in-some-register/imm32/outputs -10888 0x11/imm32/alloc-id:fake -10889 _string_8b_->/imm32/subx-name -10890 1/imm32/rm32-is-first-inout -10891 3/imm32/r32-is-first-output -10892 0/imm32/no-imm32 -10893 0/imm32/no-disp32 -10894 1/imm32/output-is-write-only +10885 _Primitive-copy-mem-to-reg/imm32/next +10886 _Primitive-copy-mem-to-reg: # (payload primitive) +10887 0x11/imm32/alloc-id:fake:payload +10888 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 +10889 0x11/imm32/alloc-id:fake +10890 _string-copy/imm32/name +10891 0x11/imm32/alloc-id:fake +10892 Single-int-var-in-mem/imm32/inouts +10893 0x11/imm32/alloc-id:fake +10894 Single-int-var-in-some-register/imm32/outputs 10895 0x11/imm32/alloc-id:fake -10896 _Primitive-copy-lit-to-reg/imm32/next -10897 _Primitive-copy-lit-to-reg: # (payload primitive) -10898 0x11/imm32/alloc-id:fake:payload -10899 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 -10900 0x11/imm32/alloc-id:fake -10901 _string-copy/imm32/name +10896 _string_8b_->/imm32/subx-name +10897 1/imm32/rm32-is-first-inout +10898 3/imm32/r32-is-first-output +10899 0/imm32/no-imm32 +10900 0/imm32/no-disp32 +10901 1/imm32/output-is-write-only 10902 0x11/imm32/alloc-id:fake -10903 Single-lit-var/imm32/inouts -10904 0x11/imm32/alloc-id:fake -10905 Single-int-var-in-some-register/imm32/outputs -10906 0x11/imm32/alloc-id:fake -10907 _string_c7_subop_copy/imm32/subx-name -10908 3/imm32/rm32-is-first-output -10909 0/imm32/no-r32 -10910 1/imm32/imm32-is-first-inout -10911 0/imm32/no-disp32 -10912 1/imm32/output-is-write-only +10903 _Primitive-copy-lit-to-reg/imm32/next +10904 _Primitive-copy-lit-to-reg: # (payload primitive) +10905 0x11/imm32/alloc-id:fake:payload +10906 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 +10907 0x11/imm32/alloc-id:fake +10908 _string-copy/imm32/name +10909 0x11/imm32/alloc-id:fake +10910 Single-lit-var/imm32/inouts +10911 0x11/imm32/alloc-id:fake +10912 Single-int-var-in-some-register/imm32/outputs 10913 0x11/imm32/alloc-id:fake -10914 _Primitive-copy-lit-to-mem/imm32/next -10915 _Primitive-copy-lit-to-mem: # (payload primitive) -10916 0x11/imm32/alloc-id:fake:payload -10917 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 -10918 0x11/imm32/alloc-id:fake -10919 _string-copy-to/imm32/name +10914 _string_c7_subop_copy/imm32/subx-name +10915 3/imm32/rm32-is-first-output +10916 0/imm32/no-r32 +10917 1/imm32/imm32-is-first-inout +10918 0/imm32/no-disp32 +10919 1/imm32/output-is-write-only 10920 0x11/imm32/alloc-id:fake -10921 Int-var-and-literal/imm32/inouts -10922 0/imm32/no-outputs -10923 0/imm32/no-outputs -10924 0x11/imm32/alloc-id:fake -10925 _string_c7_subop_copy/imm32/subx-name -10926 1/imm32/rm32-is-first-inout -10927 0/imm32/no-r32 -10928 2/imm32/imm32-is-first-inout -10929 0/imm32/no-disp32 -10930 1/imm32/output-is-write-only +10921 _Primitive-copy-lit-to-mem/imm32/next +10922 _Primitive-copy-lit-to-mem: # (payload primitive) +10923 0x11/imm32/alloc-id:fake:payload +10924 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 +10925 0x11/imm32/alloc-id:fake +10926 _string-copy-to/imm32/name +10927 0x11/imm32/alloc-id:fake +10928 Int-var-and-literal/imm32/inouts +10929 0/imm32/no-outputs +10930 0/imm32/no-outputs 10931 0x11/imm32/alloc-id:fake -10932 _Primitive-address/imm32/next -10933 # - address -10934 _Primitive-address: # (payload primitive) -10935 0x11/imm32/alloc-id:fake:payload -10936 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 -10937 0x11/imm32/alloc-id:fake -10938 _string-address/imm32/name -10939 0x11/imm32/alloc-id:fake -10940 Single-int-var-in-mem/imm32/inouts -10941 0x11/imm32/alloc-id:fake -10942 Single-addr-var-in-some-register/imm32/outputs -10943 0x11/imm32/alloc-id:fake -10944 _string_8d_copy_address/imm32/subx-name -10945 1/imm32/rm32-is-first-inout -10946 3/imm32/r32-is-first-output -10947 0/imm32/no-imm32 -10948 0/imm32/no-disp32 -10949 1/imm32/output-is-write-only +10932 _string_c7_subop_copy/imm32/subx-name +10933 1/imm32/rm32-is-first-inout +10934 0/imm32/no-r32 +10935 2/imm32/imm32-is-first-inout +10936 0/imm32/no-disp32 +10937 1/imm32/output-is-write-only +10938 0x11/imm32/alloc-id:fake +10939 _Primitive-address/imm32/next +10940 # - address +10941 _Primitive-address: # (payload primitive) +10942 0x11/imm32/alloc-id:fake:payload +10943 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 +10944 0x11/imm32/alloc-id:fake +10945 _string-address/imm32/name +10946 0x11/imm32/alloc-id:fake +10947 Single-int-var-in-mem/imm32/inouts +10948 0x11/imm32/alloc-id:fake +10949 Single-addr-var-in-some-register/imm32/outputs 10950 0x11/imm32/alloc-id:fake -10951 _Primitive-compare-mem-with-reg/imm32/next -10952 # - compare -10953 _Primitive-compare-mem-with-reg: # (payload primitive) -10954 0x11/imm32/alloc-id:fake:payload -10955 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 -10956 0x11/imm32/alloc-id:fake -10957 _string-compare/imm32/name -10958 0x11/imm32/alloc-id:fake -10959 Two-args-int-stack-int-reg/imm32/inouts -10960 0/imm32/no-outputs -10961 0/imm32/no-outputs -10962 0x11/imm32/alloc-id:fake -10963 _string_39_compare->/imm32/subx-name -10964 1/imm32/rm32-is-first-inout -10965 2/imm32/r32-is-second-inout -10966 0/imm32/no-imm32 -10967 0/imm32/no-disp32 -10968 0/imm32/output-is-write-only +10951 _string_8d_copy_address/imm32/subx-name +10952 1/imm32/rm32-is-first-inout +10953 3/imm32/r32-is-first-output +10954 0/imm32/no-imm32 +10955 0/imm32/no-disp32 +10956 1/imm32/output-is-write-only +10957 0x11/imm32/alloc-id:fake +10958 _Primitive-compare-mem-with-reg/imm32/next +10959 # - compare +10960 _Primitive-compare-mem-with-reg: # (payload primitive) +10961 0x11/imm32/alloc-id:fake:payload +10962 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 +10963 0x11/imm32/alloc-id:fake +10964 _string-compare/imm32/name +10965 0x11/imm32/alloc-id:fake +10966 Two-args-int-stack-int-reg/imm32/inouts +10967 0/imm32/no-outputs +10968 0/imm32/no-outputs 10969 0x11/imm32/alloc-id:fake -10970 _Primitive-compare-reg-with-mem/imm32/next -10971 _Primitive-compare-reg-with-mem: # (payload primitive) -10972 0x11/imm32/alloc-id:fake:payload -10973 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 -10974 0x11/imm32/alloc-id:fake -10975 _string-compare/imm32/name +10970 _string_39_compare->/imm32/subx-name +10971 1/imm32/rm32-is-first-inout +10972 2/imm32/r32-is-second-inout +10973 0/imm32/no-imm32 +10974 0/imm32/no-disp32 +10975 0/imm32/output-is-write-only 10976 0x11/imm32/alloc-id:fake -10977 Two-args-int-reg-int-stack/imm32/inouts -10978 0/imm32/no-outputs -10979 0/imm32/no-outputs -10980 0x11/imm32/alloc-id:fake -10981 _string_3b_compare<-/imm32/subx-name -10982 2/imm32/rm32-is-second-inout -10983 1/imm32/r32-is-first-inout -10984 0/imm32/no-imm32 -10985 0/imm32/no-disp32 -10986 0/imm32/output-is-write-only +10977 _Primitive-compare-reg-with-mem/imm32/next +10978 _Primitive-compare-reg-with-mem: # (payload primitive) +10979 0x11/imm32/alloc-id:fake:payload +10980 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 +10981 0x11/imm32/alloc-id:fake +10982 _string-compare/imm32/name +10983 0x11/imm32/alloc-id:fake +10984 Two-args-int-reg-int-stack/imm32/inouts +10985 0/imm32/no-outputs +10986 0/imm32/no-outputs 10987 0x11/imm32/alloc-id:fake -10988 _Primitive-compare-eax-with-literal/imm32/next -10989 _Primitive-compare-eax-with-literal: # (payload primitive) -10990 0x11/imm32/alloc-id:fake:payload -10991 # compare var1/eax n => 3d/compare-eax-with n/imm32 -10992 0x11/imm32/alloc-id:fake -10993 _string-compare/imm32/name +10988 _string_3b_compare<-/imm32/subx-name +10989 2/imm32/rm32-is-second-inout +10990 1/imm32/r32-is-first-inout +10991 0/imm32/no-imm32 +10992 0/imm32/no-disp32 +10993 0/imm32/output-is-write-only 10994 0x11/imm32/alloc-id:fake -10995 Two-args-int-eax-int-literal/imm32/inouts -10996 0/imm32/no-outputs -10997 0/imm32/no-outputs -10998 0x11/imm32/alloc-id:fake -10999 _string_3d_compare_eax_with/imm32/subx-name -11000 0/imm32/no-rm32 -11001 0/imm32/no-r32 -11002 2/imm32/imm32-is-second-inout -11003 0/imm32/no-disp32 -11004 0/imm32/output-is-write-only +10995 _Primitive-compare-eax-with-literal/imm32/next +10996 _Primitive-compare-eax-with-literal: # (payload primitive) +10997 0x11/imm32/alloc-id:fake:payload +10998 # compare var1/eax n => 3d/compare-eax-with n/imm32 +10999 0x11/imm32/alloc-id:fake +11000 _string-compare/imm32/name +11001 0x11/imm32/alloc-id:fake +11002 Two-args-int-eax-int-literal/imm32/inouts +11003 0/imm32/no-outputs +11004 0/imm32/no-outputs 11005 0x11/imm32/alloc-id:fake -11006 _Primitive-compare-reg-with-literal/imm32/next -11007 _Primitive-compare-reg-with-literal: # (payload primitive) -11008 0x11/imm32/alloc-id:fake:payload -11009 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 -11010 0x11/imm32/alloc-id:fake -11011 _string-compare/imm32/name +11006 _string_3d_compare_eax_with/imm32/subx-name +11007 0/imm32/no-rm32 +11008 0/imm32/no-r32 +11009 2/imm32/imm32-is-second-inout +11010 0/imm32/no-disp32 +11011 0/imm32/output-is-write-only 11012 0x11/imm32/alloc-id:fake -11013 Int-var-in-register-and-literal/imm32/inouts -11014 0/imm32/no-outputs -11015 0/imm32/no-outputs -11016 0x11/imm32/alloc-id:fake -11017 _string_81_subop_compare/imm32/subx-name -11018 1/imm32/rm32-is-first-inout -11019 0/imm32/no-r32 -11020 2/imm32/imm32-is-second-inout -11021 0/imm32/no-disp32 -11022 0/imm32/output-is-write-only +11013 _Primitive-compare-reg-with-literal/imm32/next +11014 _Primitive-compare-reg-with-literal: # (payload primitive) +11015 0x11/imm32/alloc-id:fake:payload +11016 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 +11017 0x11/imm32/alloc-id:fake +11018 _string-compare/imm32/name +11019 0x11/imm32/alloc-id:fake +11020 Int-var-in-register-and-literal/imm32/inouts +11021 0/imm32/no-outputs +11022 0/imm32/no-outputs 11023 0x11/imm32/alloc-id:fake -11024 _Primitive-compare-mem-with-literal/imm32/next -11025 _Primitive-compare-mem-with-literal: # (payload primitive) -11026 0x11/imm32/alloc-id:fake:payload -11027 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 -11028 0x11/imm32/alloc-id:fake -11029 _string-compare/imm32/name +11024 _string_81_subop_compare/imm32/subx-name +11025 1/imm32/rm32-is-first-inout +11026 0/imm32/no-r32 +11027 2/imm32/imm32-is-second-inout +11028 0/imm32/no-disp32 +11029 0/imm32/output-is-write-only 11030 0x11/imm32/alloc-id:fake -11031 Int-var-and-literal/imm32/inouts -11032 0/imm32/no-outputs -11033 0/imm32/no-outputs -11034 0x11/imm32/alloc-id:fake -11035 _string_81_subop_compare/imm32/subx-name -11036 1/imm32/rm32-is-first-inout -11037 0/imm32/no-r32 -11038 2/imm32/imm32-is-second-inout -11039 0/imm32/no-disp32 -11040 0/imm32/output-is-write-only +11031 _Primitive-compare-mem-with-literal/imm32/next +11032 _Primitive-compare-mem-with-literal: # (payload primitive) +11033 0x11/imm32/alloc-id:fake:payload +11034 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 +11035 0x11/imm32/alloc-id:fake +11036 _string-compare/imm32/name +11037 0x11/imm32/alloc-id:fake +11038 Int-var-and-literal/imm32/inouts +11039 0/imm32/no-outputs +11040 0/imm32/no-outputs 11041 0x11/imm32/alloc-id:fake -11042 _Primitive-multiply-reg-by-mem/imm32/next -11043 # - multiply -11044 _Primitive-multiply-reg-by-mem: # (payload primitive) -11045 0x11/imm32/alloc-id:fake:payload -11046 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 -11047 0x11/imm32/alloc-id:fake -11048 _string-multiply/imm32/name -11049 0x11/imm32/alloc-id:fake -11050 Single-int-var-in-mem/imm32/inouts -11051 0x11/imm32/alloc-id:fake -11052 Single-int-var-in-some-register/imm32/outputs -11053 0x11/imm32/alloc-id:fake -11054 _string_0f_af_multiply/imm32/subx-name -11055 1/imm32/rm32-is-first-inout -11056 3/imm32/r32-is-first-output -11057 0/imm32/no-imm32 -11058 0/imm32/no-disp32 -11059 0/imm32/output-is-write-only +11042 _string_81_subop_compare/imm32/subx-name +11043 1/imm32/rm32-is-first-inout +11044 0/imm32/no-r32 +11045 2/imm32/imm32-is-second-inout +11046 0/imm32/no-disp32 +11047 0/imm32/output-is-write-only +11048 0x11/imm32/alloc-id:fake +11049 _Primitive-multiply-reg-by-mem/imm32/next +11050 # - multiply +11051 _Primitive-multiply-reg-by-mem: # (payload primitive) +11052 0x11/imm32/alloc-id:fake:payload +11053 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +11054 0x11/imm32/alloc-id:fake +11055 _string-multiply/imm32/name +11056 0x11/imm32/alloc-id:fake +11057 Single-int-var-in-mem/imm32/inouts +11058 0x11/imm32/alloc-id:fake +11059 Single-int-var-in-some-register/imm32/outputs 11060 0x11/imm32/alloc-id:fake -11061 _Primitive-break-if-addr</imm32/next -11062 # - branches -11063 _Primitive-break-if-addr<: # (payload primitive) -11064 0x11/imm32/alloc-id:fake:payload -11065 0x11/imm32/alloc-id:fake -11066 _string-break-if-addr</imm32/name -11067 0/imm32/no-inouts -11068 0/imm32/no-inouts -11069 0/imm32/no-outputs -11070 0/imm32/no-outputs -11071 0x11/imm32/alloc-id:fake -11072 _string_0f_82_jump_break/imm32/subx-name -11073 0/imm32/no-rm32 -11074 0/imm32/no-r32 -11075 0/imm32/no-imm32 -11076 0/imm32/no-disp32 -11077 0/imm32/no-output +11061 _string_0f_af_multiply/imm32/subx-name +11062 1/imm32/rm32-is-first-inout +11063 3/imm32/r32-is-first-output +11064 0/imm32/no-imm32 +11065 0/imm32/no-disp32 +11066 0/imm32/output-is-write-only +11067 0x11/imm32/alloc-id:fake +11068 _Primitive-break-if-addr</imm32/next +11069 # - branches +11070 _Primitive-break-if-addr<: # (payload primitive) +11071 0x11/imm32/alloc-id:fake:payload +11072 0x11/imm32/alloc-id:fake +11073 _string-break-if-addr</imm32/name +11074 0/imm32/no-inouts +11075 0/imm32/no-inouts +11076 0/imm32/no-outputs +11077 0/imm32/no-outputs 11078 0x11/imm32/alloc-id:fake -11079 _Primitive-break-if-addr>=/imm32/next -11080 _Primitive-break-if-addr>=: # (payload primitive) -11081 0x11/imm32/alloc-id:fake:payload -11082 0x11/imm32/alloc-id:fake -11083 _string-break-if-addr>=/imm32/name -11084 0/imm32/no-inouts -11085 0/imm32/no-inouts -11086 0/imm32/no-outputs -11087 0/imm32/no-outputs -11088 0x11/imm32/alloc-id:fake -11089 _string_0f_83_jump_break/imm32/subx-name -11090 0/imm32/no-rm32 -11091 0/imm32/no-r32 -11092 0/imm32/no-imm32 -11093 0/imm32/no-disp32 -11094 0/imm32/no-output +11079 _string_0f_82_jump_break/imm32/subx-name +11080 0/imm32/no-rm32 +11081 0/imm32/no-r32 +11082 0/imm32/no-imm32 +11083 0/imm32/no-disp32 +11084 0/imm32/no-output +11085 0x11/imm32/alloc-id:fake +11086 _Primitive-break-if-addr>=/imm32/next +11087 _Primitive-break-if-addr>=: # (payload primitive) +11088 0x11/imm32/alloc-id:fake:payload +11089 0x11/imm32/alloc-id:fake +11090 _string-break-if-addr>=/imm32/name +11091 0/imm32/no-inouts +11092 0/imm32/no-inouts +11093 0/imm32/no-outputs +11094 0/imm32/no-outputs 11095 0x11/imm32/alloc-id:fake -11096 _Primitive-break-if-=/imm32/next -11097 _Primitive-break-if-=: # (payload primitive) -11098 0x11/imm32/alloc-id:fake:payload -11099 0x11/imm32/alloc-id:fake -11100 _string-break-if-=/imm32/name -11101 0/imm32/no-inouts -11102 0/imm32/no-inouts -11103 0/imm32/no-outputs -11104 0/imm32/no-outputs -11105 0x11/imm32/alloc-id:fake -11106 _string_0f_84_jump_break/imm32/subx-name -11107 0/imm32/no-rm32 -11108 0/imm32/no-r32 -11109 0/imm32/no-imm32 -11110 0/imm32/no-disp32 -11111 0/imm32/no-output +11096 _string_0f_83_jump_break/imm32/subx-name +11097 0/imm32/no-rm32 +11098 0/imm32/no-r32 +11099 0/imm32/no-imm32 +11100 0/imm32/no-disp32 +11101 0/imm32/no-output +11102 0x11/imm32/alloc-id:fake +11103 _Primitive-break-if-=/imm32/next +11104 _Primitive-break-if-=: # (payload primitive) +11105 0x11/imm32/alloc-id:fake:payload +11106 0x11/imm32/alloc-id:fake +11107 _string-break-if-=/imm32/name +11108 0/imm32/no-inouts +11109 0/imm32/no-inouts +11110 0/imm32/no-outputs +11111 0/imm32/no-outputs 11112 0x11/imm32/alloc-id:fake -11113 _Primitive-break-if-!=/imm32/next -11114 _Primitive-break-if-!=: # (payload primitive) -11115 0x11/imm32/alloc-id:fake:payload -11116 0x11/imm32/alloc-id:fake -11117 _string-break-if-!=/imm32/name -11118 0/imm32/no-inouts -11119 0/imm32/no-inouts -11120 0/imm32/no-outputs -11121 0/imm32/no-outputs -11122 0x11/imm32/alloc-id:fake -11123 _string_0f_85_jump_break/imm32/subx-name -11124 0/imm32/no-rm32 -11125 0/imm32/no-r32 -11126 0/imm32/no-imm32 -11127 0/imm32/no-disp32 -11128 0/imm32/no-output +11113 _string_0f_84_jump_break/imm32/subx-name +11114 0/imm32/no-rm32 +11115 0/imm32/no-r32 +11116 0/imm32/no-imm32 +11117 0/imm32/no-disp32 +11118 0/imm32/no-output +11119 0x11/imm32/alloc-id:fake +11120 _Primitive-break-if-!=/imm32/next +11121 _Primitive-break-if-!=: # (payload primitive) +11122 0x11/imm32/alloc-id:fake:payload +11123 0x11/imm32/alloc-id:fake +11124 _string-break-if-!=/imm32/name +11125 0/imm32/no-inouts +11126 0/imm32/no-inouts +11127 0/imm32/no-outputs +11128 0/imm32/no-outputs 11129 0x11/imm32/alloc-id:fake -11130 _Primitive-break-if-addr<=/imm32/next -11131 _Primitive-break-if-addr<=: # (payload primitive) -11132 0x11/imm32/alloc-id:fake:payload -11133 0x11/imm32/alloc-id:fake -11134 _string-break-if-addr<=/imm32/name -11135 0/imm32/no-inouts -11136 0/imm32/no-inouts -11137 0/imm32/no-outputs -11138 0/imm32/no-outputs -11139 0x11/imm32/alloc-id:fake -11140 _string_0f_86_jump_break/imm32/subx-name -11141 0/imm32/no-rm32 -11142 0/imm32/no-r32 -11143 0/imm32/no-imm32 -11144 0/imm32/no-disp32 -11145 0/imm32/no-output +11130 _string_0f_85_jump_break/imm32/subx-name +11131 0/imm32/no-rm32 +11132 0/imm32/no-r32 +11133 0/imm32/no-imm32 +11134 0/imm32/no-disp32 +11135 0/imm32/no-output +11136 0x11/imm32/alloc-id:fake +11137 _Primitive-break-if-addr<=/imm32/next +11138 _Primitive-break-if-addr<=: # (payload primitive) +11139 0x11/imm32/alloc-id:fake:payload +11140 0x11/imm32/alloc-id:fake +11141 _string-break-if-addr<=/imm32/name +11142 0/imm32/no-inouts +11143 0/imm32/no-inouts +11144 0/imm32/no-outputs +11145 0/imm32/no-outputs 11146 0x11/imm32/alloc-id:fake -11147 _Primitive-break-if-addr>/imm32/next -11148 _Primitive-break-if-addr>: # (payload primitive) -11149 0x11/imm32/alloc-id:fake:payload -11150 0x11/imm32/alloc-id:fake -11151 _string-break-if-addr>/imm32/name -11152 0/imm32/no-inouts -11153 0/imm32/no-inouts -11154 0/imm32/no-outputs -11155 0/imm32/no-outputs -11156 0x11/imm32/alloc-id:fake -11157 _string_0f_87_jump_break/imm32/subx-name -11158 0/imm32/no-rm32 -11159 0/imm32/no-r32 -11160 0/imm32/no-imm32 -11161 0/imm32/no-disp32 -11162 0/imm32/no-output +11147 _string_0f_86_jump_break/imm32/subx-name +11148 0/imm32/no-rm32 +11149 0/imm32/no-r32 +11150 0/imm32/no-imm32 +11151 0/imm32/no-disp32 +11152 0/imm32/no-output +11153 0x11/imm32/alloc-id:fake +11154 _Primitive-break-if-addr>/imm32/next +11155 _Primitive-break-if-addr>: # (payload primitive) +11156 0x11/imm32/alloc-id:fake:payload +11157 0x11/imm32/alloc-id:fake +11158 _string-break-if-addr>/imm32/name +11159 0/imm32/no-inouts +11160 0/imm32/no-inouts +11161 0/imm32/no-outputs +11162 0/imm32/no-outputs 11163 0x11/imm32/alloc-id:fake -11164 _Primitive-break-if-</imm32/next -11165 _Primitive-break-if-<: # (payload primitive) -11166 0x11/imm32/alloc-id:fake:payload -11167 0x11/imm32/alloc-id:fake -11168 _string-break-if-</imm32/name -11169 0/imm32/no-inouts -11170 0/imm32/no-inouts -11171 0/imm32/no-outputs -11172 0/imm32/no-outputs -11173 0x11/imm32/alloc-id:fake -11174 _string_0f_8c_jump_break/imm32/subx-name -11175 0/imm32/no-rm32 -11176 0/imm32/no-r32 -11177 0/imm32/no-imm32 -11178 0/imm32/no-disp32 -11179 0/imm32/no-output +11164 _string_0f_87_jump_break/imm32/subx-name +11165 0/imm32/no-rm32 +11166 0/imm32/no-r32 +11167 0/imm32/no-imm32 +11168 0/imm32/no-disp32 +11169 0/imm32/no-output +11170 0x11/imm32/alloc-id:fake +11171 _Primitive-break-if-</imm32/next +11172 _Primitive-break-if-<: # (payload primitive) +11173 0x11/imm32/alloc-id:fake:payload +11174 0x11/imm32/alloc-id:fake +11175 _string-break-if-</imm32/name +11176 0/imm32/no-inouts +11177 0/imm32/no-inouts +11178 0/imm32/no-outputs +11179 0/imm32/no-outputs 11180 0x11/imm32/alloc-id:fake -11181 _Primitive-break-if->=/imm32/next -11182 _Primitive-break-if->=: # (payload primitive) -11183 0x11/imm32/alloc-id:fake:payload -11184 0x11/imm32/alloc-id:fake -11185 _string-break-if->=/imm32/name -11186 0/imm32/no-inouts -11187 0/imm32/no-inouts -11188 0/imm32/no-outputs -11189 0/imm32/no-outputs -11190 0x11/imm32/alloc-id:fake -11191 _string_0f_8d_jump_break/imm32/subx-name -11192 0/imm32/no-rm32 -11193 0/imm32/no-r32 -11194 0/imm32/no-imm32 -11195 0/imm32/no-disp32 -11196 0/imm32/no-output +11181 _string_0f_8c_jump_break/imm32/subx-name +11182 0/imm32/no-rm32 +11183 0/imm32/no-r32 +11184 0/imm32/no-imm32 +11185 0/imm32/no-disp32 +11186 0/imm32/no-output +11187 0x11/imm32/alloc-id:fake +11188 _Primitive-break-if->=/imm32/next +11189 _Primitive-break-if->=: # (payload primitive) +11190 0x11/imm32/alloc-id:fake:payload +11191 0x11/imm32/alloc-id:fake +11192 _string-break-if->=/imm32/name +11193 0/imm32/no-inouts +11194 0/imm32/no-inouts +11195 0/imm32/no-outputs +11196 0/imm32/no-outputs 11197 0x11/imm32/alloc-id:fake -11198 _Primitive-break-if-<=/imm32/next -11199 _Primitive-break-if-<=: # (payload primitive) -11200 0x11/imm32/alloc-id:fake:payload -11201 0x11/imm32/alloc-id:fake -11202 _string-break-if-<=/imm32/name -11203 0/imm32/no-inouts -11204 0/imm32/no-inouts -11205 0/imm32/no-outputs -11206 0/imm32/no-outputs -11207 0x11/imm32/alloc-id:fake -11208 _string_0f_8e_jump_break/imm32/subx-name -11209 0/imm32/no-rm32 -11210 0/imm32/no-r32 -11211 0/imm32/no-imm32 -11212 0/imm32/no-disp32 -11213 0/imm32/no-output +11198 _string_0f_8d_jump_break/imm32/subx-name +11199 0/imm32/no-rm32 +11200 0/imm32/no-r32 +11201 0/imm32/no-imm32 +11202 0/imm32/no-disp32 +11203 0/imm32/no-output +11204 0x11/imm32/alloc-id:fake +11205 _Primitive-break-if-<=/imm32/next +11206 _Primitive-break-if-<=: # (payload primitive) +11207 0x11/imm32/alloc-id:fake:payload +11208 0x11/imm32/alloc-id:fake +11209 _string-break-if-<=/imm32/name +11210 0/imm32/no-inouts +11211 0/imm32/no-inouts +11212 0/imm32/no-outputs +11213 0/imm32/no-outputs 11214 0x11/imm32/alloc-id:fake -11215 _Primitive-break-if->/imm32/next -11216 _Primitive-break-if->: # (payload primitive) -11217 0x11/imm32/alloc-id:fake:payload -11218 0x11/imm32/alloc-id:fake -11219 _string-break-if->/imm32/name -11220 0/imm32/no-inouts -11221 0/imm32/no-inouts -11222 0/imm32/no-outputs -11223 0/imm32/no-outputs -11224 0x11/imm32/alloc-id:fake -11225 _string_0f_8f_jump_break/imm32/subx-name -11226 0/imm32/no-rm32 -11227 0/imm32/no-r32 -11228 0/imm32/no-imm32 -11229 0/imm32/no-disp32 -11230 0/imm32/no-output +11215 _string_0f_8e_jump_break/imm32/subx-name +11216 0/imm32/no-rm32 +11217 0/imm32/no-r32 +11218 0/imm32/no-imm32 +11219 0/imm32/no-disp32 +11220 0/imm32/no-output +11221 0x11/imm32/alloc-id:fake +11222 _Primitive-break-if->/imm32/next +11223 _Primitive-break-if->: # (payload primitive) +11224 0x11/imm32/alloc-id:fake:payload +11225 0x11/imm32/alloc-id:fake +11226 _string-break-if->/imm32/name +11227 0/imm32/no-inouts +11228 0/imm32/no-inouts +11229 0/imm32/no-outputs +11230 0/imm32/no-outputs 11231 0x11/imm32/alloc-id:fake -11232 _Primitive-break/imm32/next -11233 _Primitive-break: # (payload primitive) -11234 0x11/imm32/alloc-id:fake:payload -11235 0x11/imm32/alloc-id:fake -11236 _string-break/imm32/name -11237 0/imm32/no-inouts -11238 0/imm32/no-inouts -11239 0/imm32/no-outputs -11240 0/imm32/no-outputs -11241 0x11/imm32/alloc-id:fake -11242 _string_e9_jump_break/imm32/subx-name -11243 0/imm32/no-rm32 -11244 0/imm32/no-r32 -11245 0/imm32/no-imm32 -11246 0/imm32/no-disp32 -11247 0/imm32/no-output +11232 _string_0f_8f_jump_break/imm32/subx-name +11233 0/imm32/no-rm32 +11234 0/imm32/no-r32 +11235 0/imm32/no-imm32 +11236 0/imm32/no-disp32 +11237 0/imm32/no-output +11238 0x11/imm32/alloc-id:fake +11239 _Primitive-break/imm32/next +11240 _Primitive-break: # (payload primitive) +11241 0x11/imm32/alloc-id:fake:payload +11242 0x11/imm32/alloc-id:fake +11243 _string-break/imm32/name +11244 0/imm32/no-inouts +11245 0/imm32/no-inouts +11246 0/imm32/no-outputs +11247 0/imm32/no-outputs 11248 0x11/imm32/alloc-id:fake -11249 _Primitive-loop-if-addr</imm32/next -11250 _Primitive-loop-if-addr<: # (payload primitive) -11251 0x11/imm32/alloc-id:fake:payload -11252 0x11/imm32/alloc-id:fake -11253 _string-loop-if-addr</imm32/name -11254 0/imm32/no-inouts -11255 0/imm32/no-inouts -11256 0/imm32/no-outputs -11257 0/imm32/no-outputs -11258 0x11/imm32/alloc-id:fake -11259 _string_0f_82_jump_loop/imm32/subx-name -11260 0/imm32/no-rm32 -11261 0/imm32/no-r32 -11262 0/imm32/no-imm32 -11263 0/imm32/no-disp32 -11264 0/imm32/no-output +11249 _string_e9_jump_break/imm32/subx-name +11250 0/imm32/no-rm32 +11251 0/imm32/no-r32 +11252 0/imm32/no-imm32 +11253 0/imm32/no-disp32 +11254 0/imm32/no-output +11255 0x11/imm32/alloc-id:fake +11256 _Primitive-loop-if-addr</imm32/next +11257 _Primitive-loop-if-addr<: # (payload primitive) +11258 0x11/imm32/alloc-id:fake:payload +11259 0x11/imm32/alloc-id:fake +11260 _string-loop-if-addr</imm32/name +11261 0/imm32/no-inouts +11262 0/imm32/no-inouts +11263 0/imm32/no-outputs +11264 0/imm32/no-outputs 11265 0x11/imm32/alloc-id:fake -11266 _Primitive-loop-if-addr>=/imm32/next -11267 _Primitive-loop-if-addr>=: # (payload primitive) -11268 0x11/imm32/alloc-id:fake:payload -11269 0x11/imm32/alloc-id:fake -11270 _string-loop-if-addr>=/imm32/name -11271 0/imm32/no-inouts -11272 0/imm32/no-inouts -11273 0/imm32/no-outputs -11274 0/imm32/no-outputs -11275 0x11/imm32/alloc-id:fake -11276 _string_0f_83_jump_loop/imm32/subx-name -11277 0/imm32/no-rm32 -11278 0/imm32/no-r32 -11279 0/imm32/no-imm32 -11280 0/imm32/no-disp32 -11281 0/imm32/no-output +11266 _string_0f_82_jump_loop/imm32/subx-name +11267 0/imm32/no-rm32 +11268 0/imm32/no-r32 +11269 0/imm32/no-imm32 +11270 0/imm32/no-disp32 +11271 0/imm32/no-output +11272 0x11/imm32/alloc-id:fake +11273 _Primitive-loop-if-addr>=/imm32/next +11274 _Primitive-loop-if-addr>=: # (payload primitive) +11275 0x11/imm32/alloc-id:fake:payload +11276 0x11/imm32/alloc-id:fake +11277 _string-loop-if-addr>=/imm32/name +11278 0/imm32/no-inouts +11279 0/imm32/no-inouts +11280 0/imm32/no-outputs +11281 0/imm32/no-outputs 11282 0x11/imm32/alloc-id:fake -11283 _Primitive-loop-if-=/imm32/next -11284 _Primitive-loop-if-=: # (payload primitive) -11285 0x11/imm32/alloc-id:fake:payload -11286 0x11/imm32/alloc-id:fake -11287 _string-loop-if-=/imm32/name -11288 0/imm32/no-inouts -11289 0/imm32/no-inouts -11290 0/imm32/no-outputs -11291 0/imm32/no-outputs -11292 0x11/imm32/alloc-id:fake -11293 _string_0f_84_jump_loop/imm32/subx-name -11294 0/imm32/no-rm32 -11295 0/imm32/no-r32 -11296 0/imm32/no-imm32 -11297 0/imm32/no-disp32 -11298 0/imm32/no-output +11283 _string_0f_83_jump_loop/imm32/subx-name +11284 0/imm32/no-rm32 +11285 0/imm32/no-r32 +11286 0/imm32/no-imm32 +11287 0/imm32/no-disp32 +11288 0/imm32/no-output +11289 0x11/imm32/alloc-id:fake +11290 _Primitive-loop-if-=/imm32/next +11291 _Primitive-loop-if-=: # (payload primitive) +11292 0x11/imm32/alloc-id:fake:payload +11293 0x11/imm32/alloc-id:fake +11294 _string-loop-if-=/imm32/name +11295 0/imm32/no-inouts +11296 0/imm32/no-inouts +11297 0/imm32/no-outputs +11298 0/imm32/no-outputs 11299 0x11/imm32/alloc-id:fake -11300 _Primitive-loop-if-!=/imm32/next -11301 _Primitive-loop-if-!=: # (payload primitive) -11302 0x11/imm32/alloc-id:fake:payload -11303 0x11/imm32/alloc-id:fake -11304 _string-loop-if-!=/imm32/name -11305 0/imm32/no-inouts -11306 0/imm32/no-inouts -11307 0/imm32/no-outputs -11308 0/imm32/no-outputs -11309 0x11/imm32/alloc-id:fake -11310 _string_0f_85_jump_loop/imm32/subx-name -11311 0/imm32/no-rm32 -11312 0/imm32/no-r32 -11313 0/imm32/no-imm32 -11314 0/imm32/no-disp32 -11315 0/imm32/no-output +11300 _string_0f_84_jump_loop/imm32/subx-name +11301 0/imm32/no-rm32 +11302 0/imm32/no-r32 +11303 0/imm32/no-imm32 +11304 0/imm32/no-disp32 +11305 0/imm32/no-output +11306 0x11/imm32/alloc-id:fake +11307 _Primitive-loop-if-!=/imm32/next +11308 _Primitive-loop-if-!=: # (payload primitive) +11309 0x11/imm32/alloc-id:fake:payload +11310 0x11/imm32/alloc-id:fake +11311 _string-loop-if-!=/imm32/name +11312 0/imm32/no-inouts +11313 0/imm32/no-inouts +11314 0/imm32/no-outputs +11315 0/imm32/no-outputs 11316 0x11/imm32/alloc-id:fake -11317 _Primitive-loop-if-addr<=/imm32/next -11318 _Primitive-loop-if-addr<=: # (payload primitive) -11319 0x11/imm32/alloc-id:fake:payload -11320 0x11/imm32/alloc-id:fake -11321 _string-loop-if-addr<=/imm32/name -11322 0/imm32/no-inouts -11323 0/imm32/no-inouts -11324 0/imm32/no-outputs -11325 0/imm32/no-outputs -11326 0x11/imm32/alloc-id:fake -11327 _string_0f_86_jump_loop/imm32/subx-name -11328 0/imm32/no-rm32 -11329 0/imm32/no-r32 -11330 0/imm32/no-imm32 -11331 0/imm32/no-disp32 -11332 0/imm32/no-output +11317 _string_0f_85_jump_loop/imm32/subx-name +11318 0/imm32/no-rm32 +11319 0/imm32/no-r32 +11320 0/imm32/no-imm32 +11321 0/imm32/no-disp32 +11322 0/imm32/no-output +11323 0x11/imm32/alloc-id:fake +11324 _Primitive-loop-if-addr<=/imm32/next +11325 _Primitive-loop-if-addr<=: # (payload primitive) +11326 0x11/imm32/alloc-id:fake:payload +11327 0x11/imm32/alloc-id:fake +11328 _string-loop-if-addr<=/imm32/name +11329 0/imm32/no-inouts +11330 0/imm32/no-inouts +11331 0/imm32/no-outputs +11332 0/imm32/no-outputs 11333 0x11/imm32/alloc-id:fake -11334 _Primitive-loop-if-addr>/imm32/next -11335 _Primitive-loop-if-addr>: # (payload primitive) -11336 0x11/imm32/alloc-id:fake:payload -11337 0x11/imm32/alloc-id:fake -11338 _string-loop-if-addr>/imm32/name -11339 0/imm32/no-inouts -11340 0/imm32/no-inouts -11341 0/imm32/no-outputs -11342 0/imm32/no-outputs -11343 0x11/imm32/alloc-id:fake -11344 _string_0f_87_jump_loop/imm32/subx-name -11345 0/imm32/no-rm32 -11346 0/imm32/no-r32 -11347 0/imm32/no-imm32 -11348 0/imm32/no-disp32 -11349 0/imm32/no-output +11334 _string_0f_86_jump_loop/imm32/subx-name +11335 0/imm32/no-rm32 +11336 0/imm32/no-r32 +11337 0/imm32/no-imm32 +11338 0/imm32/no-disp32 +11339 0/imm32/no-output +11340 0x11/imm32/alloc-id:fake +11341 _Primitive-loop-if-addr>/imm32/next +11342 _Primitive-loop-if-addr>: # (payload primitive) +11343 0x11/imm32/alloc-id:fake:payload +11344 0x11/imm32/alloc-id:fake +11345 _string-loop-if-addr>/imm32/name +11346 0/imm32/no-inouts +11347 0/imm32/no-inouts +11348 0/imm32/no-outputs +11349 0/imm32/no-outputs 11350 0x11/imm32/alloc-id:fake -11351 _Primitive-loop-if-</imm32/next -11352 _Primitive-loop-if-<: # (payload primitive) -11353 0x11/imm32/alloc-id:fake:payload -11354 0x11/imm32/alloc-id:fake -11355 _string-loop-if-</imm32/name -11356 0/imm32/no-inouts -11357 0/imm32/no-inouts -11358 0/imm32/no-outputs -11359 0/imm32/no-outputs -11360 0x11/imm32/alloc-id:fake -11361 _string_0f_8c_jump_loop/imm32/subx-name -11362 0/imm32/no-rm32 -11363 0/imm32/no-r32 -11364 0/imm32/no-imm32 -11365 0/imm32/no-disp32 -11366 0/imm32/no-output +11351 _string_0f_87_jump_loop/imm32/subx-name +11352 0/imm32/no-rm32 +11353 0/imm32/no-r32 +11354 0/imm32/no-imm32 +11355 0/imm32/no-disp32 +11356 0/imm32/no-output +11357 0x11/imm32/alloc-id:fake +11358 _Primitive-loop-if-</imm32/next +11359 _Primitive-loop-if-<: # (payload primitive) +11360 0x11/imm32/alloc-id:fake:payload +11361 0x11/imm32/alloc-id:fake +11362 _string-loop-if-</imm32/name +11363 0/imm32/no-inouts +11364 0/imm32/no-inouts +11365 0/imm32/no-outputs +11366 0/imm32/no-outputs 11367 0x11/imm32/alloc-id:fake -11368 _Primitive-loop-if->=/imm32/next -11369 _Primitive-loop-if->=: # (payload primitive) -11370 0x11/imm32/alloc-id:fake:payload -11371 0x11/imm32/alloc-id:fake -11372 _string-loop-if->=/imm32/name -11373 0/imm32/no-inouts -11374 0/imm32/no-inouts -11375 0/imm32/no-outputs -11376 0/imm32/no-outputs -11377 0x11/imm32/alloc-id:fake -11378 _string_0f_8d_jump_loop/imm32/subx-name -11379 0/imm32/no-rm32 -11380 0/imm32/no-r32 -11381 0/imm32/no-imm32 -11382 0/imm32/no-disp32 -11383 0/imm32/no-output +11368 _string_0f_8c_jump_loop/imm32/subx-name +11369 0/imm32/no-rm32 +11370 0/imm32/no-r32 +11371 0/imm32/no-imm32 +11372 0/imm32/no-disp32 +11373 0/imm32/no-output +11374 0x11/imm32/alloc-id:fake +11375 _Primitive-loop-if->=/imm32/next +11376 _Primitive-loop-if->=: # (payload primitive) +11377 0x11/imm32/alloc-id:fake:payload +11378 0x11/imm32/alloc-id:fake +11379 _string-loop-if->=/imm32/name +11380 0/imm32/no-inouts +11381 0/imm32/no-inouts +11382 0/imm32/no-outputs +11383 0/imm32/no-outputs 11384 0x11/imm32/alloc-id:fake -11385 _Primitive-loop-if-<=/imm32/next -11386 _Primitive-loop-if-<=: # (payload primitive) -11387 0x11/imm32/alloc-id:fake:payload -11388 0x11/imm32/alloc-id:fake -11389 _string-loop-if-<=/imm32/name -11390 0/imm32/no-inouts -11391 0/imm32/no-inouts -11392 0/imm32/no-outputs -11393 0/imm32/no-outputs -11394 0x11/imm32/alloc-id:fake -11395 _string_0f_8e_jump_loop/imm32/subx-name -11396 0/imm32/no-rm32 -11397 0/imm32/no-r32 -11398 0/imm32/no-imm32 -11399 0/imm32/no-disp32 -11400 0/imm32/no-output +11385 _string_0f_8d_jump_loop/imm32/subx-name +11386 0/imm32/no-rm32 +11387 0/imm32/no-r32 +11388 0/imm32/no-imm32 +11389 0/imm32/no-disp32 +11390 0/imm32/no-output +11391 0x11/imm32/alloc-id:fake +11392 _Primitive-loop-if-<=/imm32/next +11393 _Primitive-loop-if-<=: # (payload primitive) +11394 0x11/imm32/alloc-id:fake:payload +11395 0x11/imm32/alloc-id:fake +11396 _string-loop-if-<=/imm32/name +11397 0/imm32/no-inouts +11398 0/imm32/no-inouts +11399 0/imm32/no-outputs +11400 0/imm32/no-outputs 11401 0x11/imm32/alloc-id:fake -11402 _Primitive-loop-if->/imm32/next -11403 _Primitive-loop-if->: # (payload primitive) -11404 0x11/imm32/alloc-id:fake:payload -11405 0x11/imm32/alloc-id:fake -11406 _string-loop-if->/imm32/name -11407 0/imm32/no-inouts -11408 0/imm32/no-inouts -11409 0/imm32/no-outputs -11410 0/imm32/no-outputs -11411 0x11/imm32/alloc-id:fake -11412 _string_0f_8f_jump_loop/imm32/subx-name -11413 0/imm32/no-rm32 -11414 0/imm32/no-r32 -11415 0/imm32/no-imm32 -11416 0/imm32/no-disp32 -11417 0/imm32/no-output +11402 _string_0f_8e_jump_loop/imm32/subx-name +11403 0/imm32/no-rm32 +11404 0/imm32/no-r32 +11405 0/imm32/no-imm32 +11406 0/imm32/no-disp32 +11407 0/imm32/no-output +11408 0x11/imm32/alloc-id:fake +11409 _Primitive-loop-if->/imm32/next +11410 _Primitive-loop-if->: # (payload primitive) +11411 0x11/imm32/alloc-id:fake:payload +11412 0x11/imm32/alloc-id:fake +11413 _string-loop-if->/imm32/name +11414 0/imm32/no-inouts +11415 0/imm32/no-inouts +11416 0/imm32/no-outputs +11417 0/imm32/no-outputs 11418 0x11/imm32/alloc-id:fake -11419 _Primitive-loop/imm32/next # we probably don't need an unconditional break -11420 _Primitive-loop: # (payload primitive) -11421 0x11/imm32/alloc-id:fake:payload -11422 0x11/imm32/alloc-id:fake -11423 _string-loop/imm32/name -11424 0/imm32/no-inouts -11425 0/imm32/no-inouts -11426 0/imm32/no-outputs -11427 0/imm32/no-outputs -11428 0x11/imm32/alloc-id:fake -11429 _string_e9_jump_loop/imm32/subx-name -11430 0/imm32/no-rm32 -11431 0/imm32/no-r32 -11432 0/imm32/no-imm32 -11433 0/imm32/no-disp32 -11434 0/imm32/no-output +11419 _string_0f_8f_jump_loop/imm32/subx-name +11420 0/imm32/no-rm32 +11421 0/imm32/no-r32 +11422 0/imm32/no-imm32 +11423 0/imm32/no-disp32 +11424 0/imm32/no-output +11425 0x11/imm32/alloc-id:fake +11426 _Primitive-loop/imm32/next # we probably don't need an unconditional break +11427 _Primitive-loop: # (payload primitive) +11428 0x11/imm32/alloc-id:fake:payload +11429 0x11/imm32/alloc-id:fake +11430 _string-loop/imm32/name +11431 0/imm32/no-inouts +11432 0/imm32/no-inouts +11433 0/imm32/no-outputs +11434 0/imm32/no-outputs 11435 0x11/imm32/alloc-id:fake -11436 _Primitive-break-if-addr<-named/imm32/next -11437 # - branches to named blocks -11438 _Primitive-break-if-addr<-named: # (payload primitive) -11439 0x11/imm32/alloc-id:fake:payload -11440 0x11/imm32/alloc-id:fake -11441 _string-break-if-addr</imm32/name +11436 _string_e9_jump_loop/imm32/subx-name +11437 0/imm32/no-rm32 +11438 0/imm32/no-r32 +11439 0/imm32/no-imm32 +11440 0/imm32/no-disp32 +11441 0/imm32/no-output 11442 0x11/imm32/alloc-id:fake -11443 Single-lit-var/imm32/inouts -11444 0/imm32/no-outputs -11445 0/imm32/no-outputs -11446 0x11/imm32/alloc-id:fake -11447 _string_0f_82_jump_label/imm32/subx-name -11448 0/imm32/no-rm32 -11449 0/imm32/no-r32 -11450 0/imm32/no-imm32 -11451 1/imm32/disp32-is-first-inout -11452 0/imm32/no-output +11443 _Primitive-break-if-addr<-named/imm32/next +11444 # - branches to named blocks +11445 _Primitive-break-if-addr<-named: # (payload primitive) +11446 0x11/imm32/alloc-id:fake:payload +11447 0x11/imm32/alloc-id:fake +11448 _string-break-if-addr</imm32/name +11449 0x11/imm32/alloc-id:fake +11450 Single-lit-var/imm32/inouts +11451 0/imm32/no-outputs +11452 0/imm32/no-outputs 11453 0x11/imm32/alloc-id:fake -11454 _Primitive-break-if-addr>=-named/imm32/next -11455 _Primitive-break-if-addr>=-named: # (payload primitive) -11456 0x11/imm32/alloc-id:fake:payload -11457 0x11/imm32/alloc-id:fake -11458 _string-break-if-addr>=/imm32/name -11459 0x11/imm32/alloc-id:fake -11460 Single-lit-var/imm32/inouts -11461 0/imm32/no-outputs -11462 0/imm32/no-outputs -11463 0x11/imm32/alloc-id:fake -11464 _string_0f_83_jump_label/imm32/subx-name -11465 0/imm32/no-rm32 -11466 0/imm32/no-r32 -11467 0/imm32/no-imm32 -11468 1/imm32/disp32-is-first-inout -11469 0/imm32/no-output +11454 _string_0f_82_jump_label/imm32/subx-name +11455 0/imm32/no-rm32 +11456 0/imm32/no-r32 +11457 0/imm32/no-imm32 +11458 1/imm32/disp32-is-first-inout +11459 0/imm32/no-output +11460 0x11/imm32/alloc-id:fake +11461 _Primitive-break-if-addr>=-named/imm32/next +11462 _Primitive-break-if-addr>=-named: # (payload primitive) +11463 0x11/imm32/alloc-id:fake:payload +11464 0x11/imm32/alloc-id:fake +11465 _string-break-if-addr>=/imm32/name +11466 0x11/imm32/alloc-id:fake +11467 Single-lit-var/imm32/inouts +11468 0/imm32/no-outputs +11469 0/imm32/no-outputs 11470 0x11/imm32/alloc-id:fake -11471 _Primitive-break-if-=-named/imm32/next -11472 _Primitive-break-if-=-named: # (payload primitive) -11473 0x11/imm32/alloc-id:fake:payload -11474 0x11/imm32/alloc-id:fake -11475 _string-break-if-=/imm32/name -11476 0x11/imm32/alloc-id:fake -11477 Single-lit-var/imm32/inouts -11478 0/imm32/no-outputs -11479 0/imm32/no-outputs -11480 0x11/imm32/alloc-id:fake -11481 _string_0f_84_jump_label/imm32/subx-name -11482 0/imm32/no-rm32 -11483 0/imm32/no-r32 -11484 0/imm32/no-imm32 -11485 1/imm32/disp32-is-first-inout -11486 0/imm32/no-output +11471 _string_0f_83_jump_label/imm32/subx-name +11472 0/imm32/no-rm32 +11473 0/imm32/no-r32 +11474 0/imm32/no-imm32 +11475 1/imm32/disp32-is-first-inout +11476 0/imm32/no-output +11477 0x11/imm32/alloc-id:fake +11478 _Primitive-break-if-=-named/imm32/next +11479 _Primitive-break-if-=-named: # (payload primitive) +11480 0x11/imm32/alloc-id:fake:payload +11481 0x11/imm32/alloc-id:fake +11482 _string-break-if-=/imm32/name +11483 0x11/imm32/alloc-id:fake +11484 Single-lit-var/imm32/inouts +11485 0/imm32/no-outputs +11486 0/imm32/no-outputs 11487 0x11/imm32/alloc-id:fake -11488 _Primitive-break-if-!=-named/imm32/next -11489 _Primitive-break-if-!=-named: # (payload primitive) -11490 0x11/imm32/alloc-id:fake:payload -11491 0x11/imm32/alloc-id:fake -11492 _string-break-if-!=/imm32/name -11493 0x11/imm32/alloc-id:fake -11494 Single-lit-var/imm32/inouts -11495 0/imm32/no-outputs -11496 0/imm32/no-outputs -11497 0x11/imm32/alloc-id:fake -11498 _string_0f_85_jump_label/imm32/subx-name -11499 0/imm32/no-rm32 -11500 0/imm32/no-r32 -11501 0/imm32/no-imm32 -11502 1/imm32/disp32-is-first-inout -11503 0/imm32/no-output +11488 _string_0f_84_jump_label/imm32/subx-name +11489 0/imm32/no-rm32 +11490 0/imm32/no-r32 +11491 0/imm32/no-imm32 +11492 1/imm32/disp32-is-first-inout +11493 0/imm32/no-output +11494 0x11/imm32/alloc-id:fake +11495 _Primitive-break-if-!=-named/imm32/next +11496 _Primitive-break-if-!=-named: # (payload primitive) +11497 0x11/imm32/alloc-id:fake:payload +11498 0x11/imm32/alloc-id:fake +11499 _string-break-if-!=/imm32/name +11500 0x11/imm32/alloc-id:fake +11501 Single-lit-var/imm32/inouts +11502 0/imm32/no-outputs +11503 0/imm32/no-outputs 11504 0x11/imm32/alloc-id:fake -11505 _Primitive-break-if-addr<=-named/imm32/next -11506 _Primitive-break-if-addr<=-named: # (payload primitive) -11507 0x11/imm32/alloc-id:fake:payload -11508 0x11/imm32/alloc-id:fake -11509 _string-break-if-addr<=/imm32/name -11510 0x11/imm32/alloc-id:fake -11511 Single-lit-var/imm32/inouts -11512 0/imm32/no-outputs -11513 0/imm32/no-outputs -11514 0x11/imm32/alloc-id:fake -11515 _string_0f_86_jump_label/imm32/subx-name -11516 0/imm32/no-rm32 -11517 0/imm32/no-r32 -11518 0/imm32/no-imm32 -11519 1/imm32/disp32-is-first-inout -11520 0/imm32/no-output +11505 _string_0f_85_jump_label/imm32/subx-name +11506 0/imm32/no-rm32 +11507 0/imm32/no-r32 +11508 0/imm32/no-imm32 +11509 1/imm32/disp32-is-first-inout +11510 0/imm32/no-output +11511 0x11/imm32/alloc-id:fake +11512 _Primitive-break-if-addr<=-named/imm32/next +11513 _Primitive-break-if-addr<=-named: # (payload primitive) +11514 0x11/imm32/alloc-id:fake:payload +11515 0x11/imm32/alloc-id:fake +11516 _string-break-if-addr<=/imm32/name +11517 0x11/imm32/alloc-id:fake +11518 Single-lit-var/imm32/inouts +11519 0/imm32/no-outputs +11520 0/imm32/no-outputs 11521 0x11/imm32/alloc-id:fake -11522 _Primitive-break-if-addr>-named/imm32/next -11523 _Primitive-break-if-addr>-named: # (payload primitive) -11524 0x11/imm32/alloc-id:fake:payload -11525 0x11/imm32/alloc-id:fake -11526 _string-break-if-addr>/imm32/name -11527 0x11/imm32/alloc-id:fake -11528 Single-lit-var/imm32/inouts -11529 0/imm32/no-outputs -11530 0/imm32/no-outputs -11531 0x11/imm32/alloc-id:fake -11532 _string_0f_87_jump_label/imm32/subx-name -11533 0/imm32/no-rm32 -11534 0/imm32/no-r32 -11535 0/imm32/no-imm32 -11536 1/imm32/disp32-is-first-inout -11537 0/imm32/no-output +11522 _string_0f_86_jump_label/imm32/subx-name +11523 0/imm32/no-rm32 +11524 0/imm32/no-r32 +11525 0/imm32/no-imm32 +11526 1/imm32/disp32-is-first-inout +11527 0/imm32/no-output +11528 0x11/imm32/alloc-id:fake +11529 _Primitive-break-if-addr>-named/imm32/next +11530 _Primitive-break-if-addr>-named: # (payload primitive) +11531 0x11/imm32/alloc-id:fake:payload +11532 0x11/imm32/alloc-id:fake +11533 _string-break-if-addr>/imm32/name +11534 0x11/imm32/alloc-id:fake +11535 Single-lit-var/imm32/inouts +11536 0/imm32/no-outputs +11537 0/imm32/no-outputs 11538 0x11/imm32/alloc-id:fake -11539 _Primitive-break-if-<-named/imm32/next -11540 _Primitive-break-if-<-named: # (payload primitive) -11541 0x11/imm32/alloc-id:fake:payload -11542 0x11/imm32/alloc-id:fake -11543 _string-break-if-</imm32/name -11544 0x11/imm32/alloc-id:fake -11545 Single-lit-var/imm32/inouts -11546 0/imm32/no-outputs -11547 0/imm32/no-outputs -11548 0x11/imm32/alloc-id:fake -11549 _string_0f_8c_jump_label/imm32/subx-name -11550 0/imm32/no-rm32 -11551 0/imm32/no-r32 -11552 0/imm32/no-imm32 -11553 1/imm32/disp32-is-first-inout -11554 0/imm32/no-output +11539 _string_0f_87_jump_label/imm32/subx-name +11540 0/imm32/no-rm32 +11541 0/imm32/no-r32 +11542 0/imm32/no-imm32 +11543 1/imm32/disp32-is-first-inout +11544 0/imm32/no-output +11545 0x11/imm32/alloc-id:fake +11546 _Primitive-break-if-<-named/imm32/next +11547 _Primitive-break-if-<-named: # (payload primitive) +11548 0x11/imm32/alloc-id:fake:payload +11549 0x11/imm32/alloc-id:fake +11550 _string-break-if-</imm32/name +11551 0x11/imm32/alloc-id:fake +11552 Single-lit-var/imm32/inouts +11553 0/imm32/no-outputs +11554 0/imm32/no-outputs 11555 0x11/imm32/alloc-id:fake -11556 _Primitive-break-if->=-named/imm32/next -11557 _Primitive-break-if->=-named: # (payload primitive) -11558 0x11/imm32/alloc-id:fake:payload -11559 0x11/imm32/alloc-id:fake -11560 _string-break-if->=/imm32/name -11561 0x11/imm32/alloc-id:fake -11562 Single-lit-var/imm32/inouts -11563 0/imm32/no-outputs -11564 0/imm32/no-outputs -11565 0x11/imm32/alloc-id:fake -11566 _string_0f_8d_jump_label/imm32/subx-name -11567 0/imm32/no-rm32 -11568 0/imm32/no-r32 -11569 0/imm32/no-imm32 -11570 1/imm32/disp32-is-first-inout -11571 0/imm32/no-output +11556 _string_0f_8c_jump_label/imm32/subx-name +11557 0/imm32/no-rm32 +11558 0/imm32/no-r32 +11559 0/imm32/no-imm32 +11560 1/imm32/disp32-is-first-inout +11561 0/imm32/no-output +11562 0x11/imm32/alloc-id:fake +11563 _Primitive-break-if->=-named/imm32/next +11564 _Primitive-break-if->=-named: # (payload primitive) +11565 0x11/imm32/alloc-id:fake:payload +11566 0x11/imm32/alloc-id:fake +11567 _string-break-if->=/imm32/name +11568 0x11/imm32/alloc-id:fake +11569 Single-lit-var/imm32/inouts +11570 0/imm32/no-outputs +11571 0/imm32/no-outputs 11572 0x11/imm32/alloc-id:fake -11573 _Primitive-break-if-<=-named/imm32/next -11574 _Primitive-break-if-<=-named: # (payload primitive) -11575 0x11/imm32/alloc-id:fake:payload -11576 0x11/imm32/alloc-id:fake -11577 _string-break-if-<=/imm32/name -11578 0x11/imm32/alloc-id:fake -11579 Single-lit-var/imm32/inouts -11580 0/imm32/no-outputs -11581 0/imm32/no-outputs -11582 0x11/imm32/alloc-id:fake -11583 _string_0f_8e_jump_label/imm32/subx-name -11584 0/imm32/no-rm32 -11585 0/imm32/no-r32 -11586 0/imm32/no-imm32 -11587 1/imm32/disp32-is-first-inout -11588 0/imm32/no-output +11573 _string_0f_8d_jump_label/imm32/subx-name +11574 0/imm32/no-rm32 +11575 0/imm32/no-r32 +11576 0/imm32/no-imm32 +11577 1/imm32/disp32-is-first-inout +11578 0/imm32/no-output +11579 0x11/imm32/alloc-id:fake +11580 _Primitive-break-if-<=-named/imm32/next +11581 _Primitive-break-if-<=-named: # (payload primitive) +11582 0x11/imm32/alloc-id:fake:payload +11583 0x11/imm32/alloc-id:fake +11584 _string-break-if-<=/imm32/name +11585 0x11/imm32/alloc-id:fake +11586 Single-lit-var/imm32/inouts +11587 0/imm32/no-outputs +11588 0/imm32/no-outputs 11589 0x11/imm32/alloc-id:fake -11590 _Primitive-break-if->-named/imm32/next -11591 _Primitive-break-if->-named: # (payload primitive) -11592 0x11/imm32/alloc-id:fake:payload -11593 0x11/imm32/alloc-id:fake -11594 _string-break-if->/imm32/name -11595 0x11/imm32/alloc-id:fake -11596 Single-lit-var/imm32/inouts -11597 0/imm32/no-outputs -11598 0/imm32/no-outputs -11599 0x11/imm32/alloc-id:fake -11600 _string_0f_8f_jump_label/imm32/subx-name -11601 0/imm32/no-rm32 -11602 0/imm32/no-r32 -11603 0/imm32/no-imm32 -11604 1/imm32/disp32-is-first-inout -11605 0/imm32/no-output +11590 _string_0f_8e_jump_label/imm32/subx-name +11591 0/imm32/no-rm32 +11592 0/imm32/no-r32 +11593 0/imm32/no-imm32 +11594 1/imm32/disp32-is-first-inout +11595 0/imm32/no-output +11596 0x11/imm32/alloc-id:fake +11597 _Primitive-break-if->-named/imm32/next +11598 _Primitive-break-if->-named: # (payload primitive) +11599 0x11/imm32/alloc-id:fake:payload +11600 0x11/imm32/alloc-id:fake +11601 _string-break-if->/imm32/name +11602 0x11/imm32/alloc-id:fake +11603 Single-lit-var/imm32/inouts +11604 0/imm32/no-outputs +11605 0/imm32/no-outputs 11606 0x11/imm32/alloc-id:fake -11607 _Primitive-break-named/imm32/next -11608 _Primitive-break-named: # (payload primitive) -11609 0x11/imm32/alloc-id:fake:payload -11610 0x11/imm32/alloc-id:fake -11611 _string-break/imm32/name -11612 0x11/imm32/alloc-id:fake -11613 Single-lit-var/imm32/inouts -11614 0/imm32/no-outputs -11615 0/imm32/no-outputs -11616 0x11/imm32/alloc-id:fake -11617 _string_e9_jump_label/imm32/subx-name -11618 0/imm32/no-rm32 -11619 0/imm32/no-r32 -11620 0/imm32/no-imm32 -11621 1/imm32/disp32-is-first-inout -11622 0/imm32/no-output +11607 _string_0f_8f_jump_label/imm32/subx-name +11608 0/imm32/no-rm32 +11609 0/imm32/no-r32 +11610 0/imm32/no-imm32 +11611 1/imm32/disp32-is-first-inout +11612 0/imm32/no-output +11613 0x11/imm32/alloc-id:fake +11614 _Primitive-break-named/imm32/next +11615 _Primitive-break-named: # (payload primitive) +11616 0x11/imm32/alloc-id:fake:payload +11617 0x11/imm32/alloc-id:fake +11618 _string-break/imm32/name +11619 0x11/imm32/alloc-id:fake +11620 Single-lit-var/imm32/inouts +11621 0/imm32/no-outputs +11622 0/imm32/no-outputs 11623 0x11/imm32/alloc-id:fake -11624 _Primitive-loop-if-addr<-named/imm32/next -11625 _Primitive-loop-if-addr<-named: # (payload primitive) -11626 0x11/imm32/alloc-id:fake:payload -11627 0x11/imm32/alloc-id:fake -11628 _string-loop-if-addr</imm32/name -11629 0x11/imm32/alloc-id:fake -11630 Single-lit-var/imm32/inouts -11631 0/imm32/no-outputs -11632 0/imm32/no-outputs -11633 0x11/imm32/alloc-id:fake -11634 _string_0f_82_jump_label/imm32/subx-name -11635 0/imm32/no-rm32 -11636 0/imm32/no-r32 -11637 0/imm32/no-imm32 -11638 1/imm32/disp32-is-first-inout -11639 0/imm32/no-output +11624 _string_e9_jump_label/imm32/subx-name +11625 0/imm32/no-rm32 +11626 0/imm32/no-r32 +11627 0/imm32/no-imm32 +11628 1/imm32/disp32-is-first-inout +11629 0/imm32/no-output +11630 0x11/imm32/alloc-id:fake +11631 _Primitive-loop-if-addr<-named/imm32/next +11632 _Primitive-loop-if-addr<-named: # (payload primitive) +11633 0x11/imm32/alloc-id:fake:payload +11634 0x11/imm32/alloc-id:fake +11635 _string-loop-if-addr</imm32/name +11636 0x11/imm32/alloc-id:fake +11637 Single-lit-var/imm32/inouts +11638 0/imm32/no-outputs +11639 0/imm32/no-outputs 11640 0x11/imm32/alloc-id:fake -11641 _Primitive-loop-if-addr>=-named/imm32/next -11642 _Primitive-loop-if-addr>=-named: # (payload primitive) -11643 0x11/imm32/alloc-id:fake:payload -11644 0x11/imm32/alloc-id:fake -11645 _string-loop-if-addr>=/imm32/name -11646 0x11/imm32/alloc-id:fake -11647 Single-lit-var/imm32/inouts -11648 0/imm32/no-outputs -11649 0/imm32/no-outputs -11650 0x11/imm32/alloc-id:fake -11651 _string_0f_83_jump_label/imm32/subx-name -11652 0/imm32/no-rm32 -11653 0/imm32/no-r32 -11654 0/imm32/no-imm32 -11655 1/imm32/disp32-is-first-inout -11656 0/imm32/no-output +11641 _string_0f_82_jump_label/imm32/subx-name +11642 0/imm32/no-rm32 +11643 0/imm32/no-r32 +11644 0/imm32/no-imm32 +11645 1/imm32/disp32-is-first-inout +11646 0/imm32/no-output +11647 0x11/imm32/alloc-id:fake +11648 _Primitive-loop-if-addr>=-named/imm32/next +11649 _Primitive-loop-if-addr>=-named: # (payload primitive) +11650 0x11/imm32/alloc-id:fake:payload +11651 0x11/imm32/alloc-id:fake +11652 _string-loop-if-addr>=/imm32/name +11653 0x11/imm32/alloc-id:fake +11654 Single-lit-var/imm32/inouts +11655 0/imm32/no-outputs +11656 0/imm32/no-outputs 11657 0x11/imm32/alloc-id:fake -11658 _Primitive-loop-if-=-named/imm32/next -11659 _Primitive-loop-if-=-named: # (payload primitive) -11660 0x11/imm32/alloc-id:fake:payload -11661 0x11/imm32/alloc-id:fake -11662 _string-loop-if-=/imm32/name -11663 0x11/imm32/alloc-id:fake -11664 Single-lit-var/imm32/inouts -11665 0/imm32/no-outputs -11666 0/imm32/no-outputs -11667 0x11/imm32/alloc-id:fake -11668 _string_0f_84_jump_label/imm32/subx-name -11669 0/imm32/no-rm32 -11670 0/imm32/no-r32 -11671 0/imm32/no-imm32 -11672 1/imm32/disp32-is-first-inout -11673 0/imm32/no-output +11658 _string_0f_83_jump_label/imm32/subx-name +11659 0/imm32/no-rm32 +11660 0/imm32/no-r32 +11661 0/imm32/no-imm32 +11662 1/imm32/disp32-is-first-inout +11663 0/imm32/no-output +11664 0x11/imm32/alloc-id:fake +11665 _Primitive-loop-if-=-named/imm32/next +11666 _Primitive-loop-if-=-named: # (payload primitive) +11667 0x11/imm32/alloc-id:fake:payload +11668 0x11/imm32/alloc-id:fake +11669 _string-loop-if-=/imm32/name +11670 0x11/imm32/alloc-id:fake +11671 Single-lit-var/imm32/inouts +11672 0/imm32/no-outputs +11673 0/imm32/no-outputs 11674 0x11/imm32/alloc-id:fake -11675 _Primitive-loop-if-!=-named/imm32/next -11676 _Primitive-loop-if-!=-named: # (payload primitive) -11677 0x11/imm32/alloc-id:fake:payload -11678 0x11/imm32/alloc-id:fake -11679 _string-loop-if-!=/imm32/name -11680 0x11/imm32/alloc-id:fake -11681 Single-lit-var/imm32/inouts -11682 0/imm32/no-outputs -11683 0/imm32/no-outputs -11684 0x11/imm32/alloc-id:fake -11685 _string_0f_85_jump_label/imm32/subx-name -11686 0/imm32/no-rm32 -11687 0/imm32/no-r32 -11688 0/imm32/no-imm32 -11689 1/imm32/disp32-is-first-inout -11690 0/imm32/no-output +11675 _string_0f_84_jump_label/imm32/subx-name +11676 0/imm32/no-rm32 +11677 0/imm32/no-r32 +11678 0/imm32/no-imm32 +11679 1/imm32/disp32-is-first-inout +11680 0/imm32/no-output +11681 0x11/imm32/alloc-id:fake +11682 _Primitive-loop-if-!=-named/imm32/next +11683 _Primitive-loop-if-!=-named: # (payload primitive) +11684 0x11/imm32/alloc-id:fake:payload +11685 0x11/imm32/alloc-id:fake +11686 _string-loop-if-!=/imm32/name +11687 0x11/imm32/alloc-id:fake +11688 Single-lit-var/imm32/inouts +11689 0/imm32/no-outputs +11690 0/imm32/no-outputs 11691 0x11/imm32/alloc-id:fake -11692 _Primitive-loop-if-addr<=-named/imm32/next -11693 _Primitive-loop-if-addr<=-named: # (payload primitive) -11694 0x11/imm32/alloc-id:fake:payload -11695 0x11/imm32/alloc-id:fake -11696 _string-loop-if-addr<=/imm32/name -11697 0x11/imm32/alloc-id:fake -11698 Single-lit-var/imm32/inouts -11699 0/imm32/no-outputs -11700 0/imm32/no-outputs -11701 0x11/imm32/alloc-id:fake -11702 _string_0f_86_jump_label/imm32/subx-name -11703 0/imm32/no-rm32 -11704 0/imm32/no-r32 -11705 0/imm32/no-imm32 -11706 1/imm32/disp32-is-first-inout -11707 0/imm32/no-output +11692 _string_0f_85_jump_label/imm32/subx-name +11693 0/imm32/no-rm32 +11694 0/imm32/no-r32 +11695 0/imm32/no-imm32 +11696 1/imm32/disp32-is-first-inout +11697 0/imm32/no-output +11698 0x11/imm32/alloc-id:fake +11699 _Primitive-loop-if-addr<=-named/imm32/next +11700 _Primitive-loop-if-addr<=-named: # (payload primitive) +11701 0x11/imm32/alloc-id:fake:payload +11702 0x11/imm32/alloc-id:fake +11703 _string-loop-if-addr<=/imm32/name +11704 0x11/imm32/alloc-id:fake +11705 Single-lit-var/imm32/inouts +11706 0/imm32/no-outputs +11707 0/imm32/no-outputs 11708 0x11/imm32/alloc-id:fake -11709 _Primitive-loop-if-addr>-named/imm32/next -11710 _Primitive-loop-if-addr>-named: # (payload primitive) -11711 0x11/imm32/alloc-id:fake:payload -11712 0x11/imm32/alloc-id:fake -11713 _string-loop-if-addr>/imm32/name -11714 0x11/imm32/alloc-id:fake -11715 Single-lit-var/imm32/inouts -11716 0/imm32/no-outputs -11717 0/imm32/no-outputs -11718 0x11/imm32/alloc-id:fake -11719 _string_0f_87_jump_label/imm32/subx-name -11720 0/imm32/no-rm32 -11721 0/imm32/no-r32 -11722 0/imm32/no-imm32 -11723 1/imm32/disp32-is-first-inout -11724 0/imm32/no-output +11709 _string_0f_86_jump_label/imm32/subx-name +11710 0/imm32/no-rm32 +11711 0/imm32/no-r32 +11712 0/imm32/no-imm32 +11713 1/imm32/disp32-is-first-inout +11714 0/imm32/no-output +11715 0x11/imm32/alloc-id:fake +11716 _Primitive-loop-if-addr>-named/imm32/next +11717 _Primitive-loop-if-addr>-named: # (payload primitive) +11718 0x11/imm32/alloc-id:fake:payload +11719 0x11/imm32/alloc-id:fake +11720 _string-loop-if-addr>/imm32/name +11721 0x11/imm32/alloc-id:fake +11722 Single-lit-var/imm32/inouts +11723 0/imm32/no-outputs +11724 0/imm32/no-outputs 11725 0x11/imm32/alloc-id:fake -11726 _Primitive-loop-if-<-named/imm32/next -11727 _Primitive-loop-if-<-named: # (payload primitive) -11728 0x11/imm32/alloc-id:fake:payload -11729 0x11/imm32/alloc-id:fake -11730 _string-loop-if-</imm32/name -11731 0x11/imm32/alloc-id:fake -11732 Single-lit-var/imm32/inouts -11733 0/imm32/no-outputs -11734 0/imm32/no-outputs -11735 0x11/imm32/alloc-id:fake -11736 _string_0f_8c_jump_label/imm32/subx-name -11737 0/imm32/no-rm32 -11738 0/imm32/no-r32 -11739 0/imm32/no-imm32 -11740 1/imm32/disp32-is-first-inout -11741 0/imm32/no-output +11726 _string_0f_87_jump_label/imm32/subx-name +11727 0/imm32/no-rm32 +11728 0/imm32/no-r32 +11729 0/imm32/no-imm32 +11730 1/imm32/disp32-is-first-inout +11731 0/imm32/no-output +11732 0x11/imm32/alloc-id:fake +11733 _Primitive-loop-if-<-named/imm32/next +11734 _Primitive-loop-if-<-named: # (payload primitive) +11735 0x11/imm32/alloc-id:fake:payload +11736 0x11/imm32/alloc-id:fake +11737 _string-loop-if-</imm32/name +11738 0x11/imm32/alloc-id:fake +11739 Single-lit-var/imm32/inouts +11740 0/imm32/no-outputs +11741 0/imm32/no-outputs 11742 0x11/imm32/alloc-id:fake -11743 _Primitive-loop-if->=-named/imm32/next -11744 _Primitive-loop-if->=-named: # (payload primitive) -11745 0x11/imm32/alloc-id:fake:payload -11746 0x11/imm32/alloc-id:fake -11747 _string-loop-if->=/imm32/name -11748 0x11/imm32/alloc-id:fake -11749 Single-lit-var/imm32/inouts -11750 0/imm32/no-outputs -11751 0/imm32/no-outputs -11752 0x11/imm32/alloc-id:fake -11753 _string_0f_8d_jump_label/imm32/subx-name -11754 0/imm32/no-rm32 -11755 0/imm32/no-r32 -11756 0/imm32/no-imm32 -11757 1/imm32/disp32-is-first-inout -11758 0/imm32/no-output +11743 _string_0f_8c_jump_label/imm32/subx-name +11744 0/imm32/no-rm32 +11745 0/imm32/no-r32 +11746 0/imm32/no-imm32 +11747 1/imm32/disp32-is-first-inout +11748 0/imm32/no-output +11749 0x11/imm32/alloc-id:fake +11750 _Primitive-loop-if->=-named/imm32/next +11751 _Primitive-loop-if->=-named: # (payload primitive) +11752 0x11/imm32/alloc-id:fake:payload +11753 0x11/imm32/alloc-id:fake +11754 _string-loop-if->=/imm32/name +11755 0x11/imm32/alloc-id:fake +11756 Single-lit-var/imm32/inouts +11757 0/imm32/no-outputs +11758 0/imm32/no-outputs 11759 0x11/imm32/alloc-id:fake -11760 _Primitive-loop-if-<=-named/imm32/next -11761 _Primitive-loop-if-<=-named: # (payload primitive) -11762 0x11/imm32/alloc-id:fake:payload -11763 0x11/imm32/alloc-id:fake -11764 _string-loop-if-<=/imm32/name -11765 0x11/imm32/alloc-id:fake -11766 Single-lit-var/imm32/inouts -11767 0/imm32/no-outputs -11768 0/imm32/no-outputs -11769 0x11/imm32/alloc-id:fake -11770 _string_0f_8e_jump_label/imm32/subx-name -11771 0/imm32/no-rm32 -11772 0/imm32/no-r32 -11773 0/imm32/no-imm32 -11774 1/imm32/disp32-is-first-inout -11775 0/imm32/no-output +11760 _string_0f_8d_jump_label/imm32/subx-name +11761 0/imm32/no-rm32 +11762 0/imm32/no-r32 +11763 0/imm32/no-imm32 +11764 1/imm32/disp32-is-first-inout +11765 0/imm32/no-output +11766 0x11/imm32/alloc-id:fake +11767 _Primitive-loop-if-<=-named/imm32/next +11768 _Primitive-loop-if-<=-named: # (payload primitive) +11769 0x11/imm32/alloc-id:fake:payload +11770 0x11/imm32/alloc-id:fake +11771 _string-loop-if-<=/imm32/name +11772 0x11/imm32/alloc-id:fake +11773 Single-lit-var/imm32/inouts +11774 0/imm32/no-outputs +11775 0/imm32/no-outputs 11776 0x11/imm32/alloc-id:fake -11777 _Primitive-loop-if->-named/imm32/next -11778 _Primitive-loop-if->-named: # (payload primitive) -11779 0x11/imm32/alloc-id:fake:payload -11780 0x11/imm32/alloc-id:fake -11781 _string-loop-if->/imm32/name -11782 0x11/imm32/alloc-id:fake -11783 Single-lit-var/imm32/inouts -11784 0/imm32/no-outputs -11785 0/imm32/no-outputs -11786 0x11/imm32/alloc-id:fake -11787 _string_0f_8f_jump_label/imm32/subx-name -11788 0/imm32/no-rm32 -11789 0/imm32/no-r32 -11790 0/imm32/no-imm32 -11791 1/imm32/disp32-is-first-inout -11792 0/imm32/no-output +11777 _string_0f_8e_jump_label/imm32/subx-name +11778 0/imm32/no-rm32 +11779 0/imm32/no-r32 +11780 0/imm32/no-imm32 +11781 1/imm32/disp32-is-first-inout +11782 0/imm32/no-output +11783 0x11/imm32/alloc-id:fake +11784 _Primitive-loop-if->-named/imm32/next +11785 _Primitive-loop-if->-named: # (payload primitive) +11786 0x11/imm32/alloc-id:fake:payload +11787 0x11/imm32/alloc-id:fake +11788 _string-loop-if->/imm32/name +11789 0x11/imm32/alloc-id:fake +11790 Single-lit-var/imm32/inouts +11791 0/imm32/no-outputs +11792 0/imm32/no-outputs 11793 0x11/imm32/alloc-id:fake -11794 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break -11795 _Primitive-loop-named: # (payload primitive) -11796 0x11/imm32/alloc-id:fake:payload -11797 0x11/imm32/alloc-id:fake -11798 _string-loop/imm32/name -11799 0x11/imm32/alloc-id:fake -11800 Single-lit-var/imm32/inouts -11801 0/imm32/no-outputs -11802 0/imm32/no-outputs -11803 0x11/imm32/alloc-id:fake -11804 _string_e9_jump_label/imm32/subx-name -11805 0/imm32/no-rm32 -11806 0/imm32/no-r32 -11807 0/imm32/no-imm32 -11808 1/imm32/disp32-is-first-inout -11809 0/imm32/no-output -11810 0/imm32/next -11811 0/imm32/next -11812 -11813 # string literals for Mu instructions -11814 _string-add: # (payload array byte) -11815 0x11/imm32/alloc-id:fake:payload -11816 # "add" -11817 0x3/imm32/size -11818 0x61/a 0x64/d 0x64/d -11819 _string-address: # (payload array byte) -11820 0x11/imm32/alloc-id:fake:payload -11821 # "address" -11822 0x7/imm32/size -11823 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s -11824 _string-add-to: # (payload array byte) -11825 0x11/imm32/alloc-id:fake:payload -11826 # "add-to" -11827 0x6/imm32/size -11828 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -11829 _string-and: # (payload array byte) -11830 0x11/imm32/alloc-id:fake:payload -11831 # "and" -11832 0x3/imm32/size -11833 0x61/a 0x6e/n 0x64/d -11834 _string-and-with: # (payload array byte) -11835 0x11/imm32/alloc-id:fake:payload -11836 # "and-with" -11837 0x8/imm32/size -11838 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -11839 _string-break: # (payload array byte) -11840 0x11/imm32/alloc-id:fake:payload -11841 # "break" -11842 0x5/imm32/size -11843 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k -11844 _string-break-if-<: # (payload array byte) -11845 0x11/imm32/alloc-id:fake:payload -11846 # "break-if-<" -11847 0xa/imm32/size -11848 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -11849 _string-break-if-<=: # (payload array byte) -11850 0x11/imm32/alloc-id:fake:payload -11851 # "break-if-<=" -11852 0xb/imm32/size -11853 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -11854 _string-break-if-=: # (payload array byte) -11855 0x11/imm32/alloc-id:fake:payload -11856 # "break-if-=" -11857 0xa/imm32/size -11858 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -11859 _string-break-if->: # (payload array byte) -11860 0x11/imm32/alloc-id:fake:payload -11861 # "break-if->" -11862 0xa/imm32/size -11863 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -11864 _string-break-if->=: # (payload array byte) -11865 0x11/imm32/alloc-id:fake:payload -11866 # "break-if->=" -11867 0xb/imm32/size -11868 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -11869 _string-break-if-!=: # (payload array byte) -11870 0x11/imm32/alloc-id:fake:payload -11871 # "break-if-!=" -11872 0xb/imm32/size -11873 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -11874 _string-break-if-addr<: # (payload array byte) -11875 0x11/imm32/alloc-id:fake:payload -11876 # "break-if-addr<" -11877 0xe/imm32/size -11878 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/< -11879 _string-break-if-addr<=: # (payload array byte) -11880 0x11/imm32/alloc-id:fake:payload -11881 # "break-if-addr<=" -11882 0xf/imm32/size -11883 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/= -11884 _string-break-if-addr>: # (payload array byte) -11885 0x11/imm32/alloc-id:fake:payload -11886 # "break-if-addr>" -11887 0xe/imm32/size -11888 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/> -11889 _string-break-if-addr>=: # (payload array byte) -11890 0x11/imm32/alloc-id:fake:payload -11891 # "break-if-addr>=" -11892 0xf/imm32/size -11893 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/= -11894 _string-compare: # (payload array byte) -11895 0x11/imm32/alloc-id:fake:payload -11896 # "compare" -11897 0x7/imm32/size -11898 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e -11899 _string-copy: # (payload array byte) -11900 0x11/imm32/alloc-id:fake:payload -11901 # "copy" -11902 0x4/imm32/size -11903 0x63/c 0x6f/o 0x70/p 0x79/y -11904 _string-copy-to: # (payload array byte) -11905 0x11/imm32/alloc-id:fake:payload -11906 # "copy-to" -11907 0x7/imm32/size -11908 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o -11909 _string-decrement: # (payload array byte) -11910 0x11/imm32/alloc-id:fake:payload -11911 # "decrement" -11912 0x9/imm32/size -11913 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -11914 _string-increment: # (payload array byte) -11915 0x11/imm32/alloc-id:fake:payload -11916 # "increment" -11917 0x9/imm32/size -11918 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -11919 _string-loop: # (payload array byte) -11920 0x11/imm32/alloc-id:fake:payload -11921 # "loop" -11922 0x4/imm32/size -11923 0x6c/l 0x6f/o 0x6f/o 0x70/p -11924 _string-loop-if-<: # (payload array byte) -11925 0x11/imm32/alloc-id:fake:payload -11926 # "loop-if-<" -11927 0x9/imm32/size -11928 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -11929 _string-loop-if-<=: # (payload array byte) -11930 0x11/imm32/alloc-id:fake:payload -11931 # "loop-if-<=" -11932 0xa/imm32/size -11933 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -11934 _string-loop-if-=: # (payload array byte) -11935 0x11/imm32/alloc-id:fake:payload -11936 # "loop-if-=" -11937 0x9/imm32/size -11938 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -11939 _string-loop-if->: # (payload array byte) -11940 0x11/imm32/alloc-id:fake:payload -11941 # "loop-if->" -11942 0x9/imm32/size -11943 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -11944 _string-loop-if->=: # (payload array byte) -11945 0x11/imm32/alloc-id:fake:payload -11946 # "loop-if->=" -11947 0xa/imm32/size -11948 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -11949 _string-loop-if-!=: # (payload array byte) -11950 0x11/imm32/alloc-id:fake:payload -11951 # "loop-if-!=" -11952 0xa/imm32/size -11953 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -11954 _string-loop-if-addr<: # (payload array byte) -11955 0x11/imm32/alloc-id:fake:payload -11956 # "loop-if-addr<" -11957 0xd/imm32/size -11958 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/< -11959 _string-loop-if-addr<=: # (payload array byte) -11960 0x11/imm32/alloc-id:fake:payload -11961 # "loop-if-addr<=" -11962 0xe/imm32/size -11963 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/= -11964 _string-loop-if-addr>: # (payload array byte) -11965 0x11/imm32/alloc-id:fake:payload -11966 # "loop-if-addr>" -11967 0xd/imm32/size -11968 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/> -11969 _string-loop-if-addr>=: # (payload array byte) -11970 0x11/imm32/alloc-id:fake:payload -11971 # "loop-if-addr>=" -11972 0xe/imm32/size -11973 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/= -11974 _string-multiply: # (payload array byte) -11975 0x11/imm32/alloc-id:fake:payload -11976 # "multiply" -11977 0x8/imm32/size -11978 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y -11979 _string-or: # (payload array byte) -11980 0x11/imm32/alloc-id:fake:payload -11981 # "or" -11982 0x2/imm32/size -11983 0x6f/o 0x72/r -11984 _string-or-with: # (payload array byte) -11985 0x11/imm32/alloc-id:fake:payload -11986 # "or-with" -11987 0x7/imm32/size -11988 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -11989 _string-subtract: # (payload array byte) -11990 0x11/imm32/alloc-id:fake:payload -11991 # "subtract" -11992 0x8/imm32/size -11993 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -11994 _string-subtract-from: # (payload array byte) -11995 0x11/imm32/alloc-id:fake:payload -11996 # "subtract-from" -11997 0xd/imm32/size -11998 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 -11999 _string-xor: # (payload array byte) -12000 0x11/imm32/alloc-id:fake:payload -12001 # "xor" -12002 0x3/imm32/size -12003 0x78/x 0x6f/o 0x72/r -12004 _string-xor-with: # (payload array byte) -12005 0x11/imm32/alloc-id:fake:payload -12006 # "xor-with" -12007 0x8/imm32/size -12008 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -12009 -12010 # string literals for SubX instructions -12011 _string_01_add_to: # (payload array byte) +11794 _string_0f_8f_jump_label/imm32/subx-name +11795 0/imm32/no-rm32 +11796 0/imm32/no-r32 +11797 0/imm32/no-imm32 +11798 1/imm32/disp32-is-first-inout +11799 0/imm32/no-output +11800 0x11/imm32/alloc-id:fake +11801 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break +11802 _Primitive-loop-named: # (payload primitive) +11803 0x11/imm32/alloc-id:fake:payload +11804 0x11/imm32/alloc-id:fake +11805 _string-loop/imm32/name +11806 0x11/imm32/alloc-id:fake +11807 Single-lit-var/imm32/inouts +11808 0/imm32/no-outputs +11809 0/imm32/no-outputs +11810 0x11/imm32/alloc-id:fake +11811 _string_e9_jump_label/imm32/subx-name +11812 0/imm32/no-rm32 +11813 0/imm32/no-r32 +11814 0/imm32/no-imm32 +11815 1/imm32/disp32-is-first-inout +11816 0/imm32/no-output +11817 0/imm32/next +11818 0/imm32/next +11819 +11820 # string literals for Mu instructions +11821 _string-add: # (payload array byte) +11822 0x11/imm32/alloc-id:fake:payload +11823 # "add" +11824 0x3/imm32/size +11825 0x61/a 0x64/d 0x64/d +11826 _string-address: # (payload array byte) +11827 0x11/imm32/alloc-id:fake:payload +11828 # "address" +11829 0x7/imm32/size +11830 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s +11831 _string-add-to: # (payload array byte) +11832 0x11/imm32/alloc-id:fake:payload +11833 # "add-to" +11834 0x6/imm32/size +11835 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +11836 _string-and: # (payload array byte) +11837 0x11/imm32/alloc-id:fake:payload +11838 # "and" +11839 0x3/imm32/size +11840 0x61/a 0x6e/n 0x64/d +11841 _string-and-with: # (payload array byte) +11842 0x11/imm32/alloc-id:fake:payload +11843 # "and-with" +11844 0x8/imm32/size +11845 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +11846 _string-break: # (payload array byte) +11847 0x11/imm32/alloc-id:fake:payload +11848 # "break" +11849 0x5/imm32/size +11850 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k +11851 _string-break-if-<: # (payload array byte) +11852 0x11/imm32/alloc-id:fake:payload +11853 # "break-if-<" +11854 0xa/imm32/size +11855 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +11856 _string-break-if-<=: # (payload array byte) +11857 0x11/imm32/alloc-id:fake:payload +11858 # "break-if-<=" +11859 0xb/imm32/size +11860 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +11861 _string-break-if-=: # (payload array byte) +11862 0x11/imm32/alloc-id:fake:payload +11863 # "break-if-=" +11864 0xa/imm32/size +11865 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +11866 _string-break-if->: # (payload array byte) +11867 0x11/imm32/alloc-id:fake:payload +11868 # "break-if->" +11869 0xa/imm32/size +11870 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +11871 _string-break-if->=: # (payload array byte) +11872 0x11/imm32/alloc-id:fake:payload +11873 # "break-if->=" +11874 0xb/imm32/size +11875 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +11876 _string-break-if-!=: # (payload array byte) +11877 0x11/imm32/alloc-id:fake:payload +11878 # "break-if-!=" +11879 0xb/imm32/size +11880 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +11881 _string-break-if-addr<: # (payload array byte) +11882 0x11/imm32/alloc-id:fake:payload +11883 # "break-if-addr<" +11884 0xe/imm32/size +11885 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/< +11886 _string-break-if-addr<=: # (payload array byte) +11887 0x11/imm32/alloc-id:fake:payload +11888 # "break-if-addr<=" +11889 0xf/imm32/size +11890 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/= +11891 _string-break-if-addr>: # (payload array byte) +11892 0x11/imm32/alloc-id:fake:payload +11893 # "break-if-addr>" +11894 0xe/imm32/size +11895 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/> +11896 _string-break-if-addr>=: # (payload array byte) +11897 0x11/imm32/alloc-id:fake:payload +11898 # "break-if-addr>=" +11899 0xf/imm32/size +11900 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/= +11901 _string-compare: # (payload array byte) +11902 0x11/imm32/alloc-id:fake:payload +11903 # "compare" +11904 0x7/imm32/size +11905 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e +11906 _string-copy: # (payload array byte) +11907 0x11/imm32/alloc-id:fake:payload +11908 # "copy" +11909 0x4/imm32/size +11910 0x63/c 0x6f/o 0x70/p 0x79/y +11911 _string-copy-to: # (payload array byte) +11912 0x11/imm32/alloc-id:fake:payload +11913 # "copy-to" +11914 0x7/imm32/size +11915 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o +11916 _string-decrement: # (payload array byte) +11917 0x11/imm32/alloc-id:fake:payload +11918 # "decrement" +11919 0x9/imm32/size +11920 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +11921 _string-increment: # (payload array byte) +11922 0x11/imm32/alloc-id:fake:payload +11923 # "increment" +11924 0x9/imm32/size +11925 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +11926 _string-loop: # (payload array byte) +11927 0x11/imm32/alloc-id:fake:payload +11928 # "loop" +11929 0x4/imm32/size +11930 0x6c/l 0x6f/o 0x6f/o 0x70/p +11931 _string-loop-if-<: # (payload array byte) +11932 0x11/imm32/alloc-id:fake:payload +11933 # "loop-if-<" +11934 0x9/imm32/size +11935 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +11936 _string-loop-if-<=: # (payload array byte) +11937 0x11/imm32/alloc-id:fake:payload +11938 # "loop-if-<=" +11939 0xa/imm32/size +11940 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +11941 _string-loop-if-=: # (payload array byte) +11942 0x11/imm32/alloc-id:fake:payload +11943 # "loop-if-=" +11944 0x9/imm32/size +11945 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +11946 _string-loop-if->: # (payload array byte) +11947 0x11/imm32/alloc-id:fake:payload +11948 # "loop-if->" +11949 0x9/imm32/size +11950 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +11951 _string-loop-if->=: # (payload array byte) +11952 0x11/imm32/alloc-id:fake:payload +11953 # "loop-if->=" +11954 0xa/imm32/size +11955 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +11956 _string-loop-if-!=: # (payload array byte) +11957 0x11/imm32/alloc-id:fake:payload +11958 # "loop-if-!=" +11959 0xa/imm32/size +11960 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +11961 _string-loop-if-addr<: # (payload array byte) +11962 0x11/imm32/alloc-id:fake:payload +11963 # "loop-if-addr<" +11964 0xd/imm32/size +11965 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/< +11966 _string-loop-if-addr<=: # (payload array byte) +11967 0x11/imm32/alloc-id:fake:payload +11968 # "loop-if-addr<=" +11969 0xe/imm32/size +11970 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/= +11971 _string-loop-if-addr>: # (payload array byte) +11972 0x11/imm32/alloc-id:fake:payload +11973 # "loop-if-addr>" +11974 0xd/imm32/size +11975 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/> +11976 _string-loop-if-addr>=: # (payload array byte) +11977 0x11/imm32/alloc-id:fake:payload +11978 # "loop-if-addr>=" +11979 0xe/imm32/size +11980 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/= +11981 _string-multiply: # (payload array byte) +11982 0x11/imm32/alloc-id:fake:payload +11983 # "multiply" +11984 0x8/imm32/size +11985 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y +11986 _string-or: # (payload array byte) +11987 0x11/imm32/alloc-id:fake:payload +11988 # "or" +11989 0x2/imm32/size +11990 0x6f/o 0x72/r +11991 _string-or-with: # (payload array byte) +11992 0x11/imm32/alloc-id:fake:payload +11993 # "or-with" +11994 0x7/imm32/size +11995 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +11996 _string-subtract: # (payload array byte) +11997 0x11/imm32/alloc-id:fake:payload +11998 # "subtract" +11999 0x8/imm32/size +12000 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +12001 _string-subtract-from: # (payload array byte) +12002 0x11/imm32/alloc-id:fake:payload +12003 # "subtract-from" +12004 0xd/imm32/size +12005 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 +12006 _string-xor: # (payload array byte) +12007 0x11/imm32/alloc-id:fake:payload +12008 # "xor" +12009 0x3/imm32/size +12010 0x78/x 0x6f/o 0x72/r +12011 _string-xor-with: # (payload array byte) 12012 0x11/imm32/alloc-id:fake:payload -12013 # "01/add-to" -12014 0x9/imm32/size -12015 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -12016 _string_03_add: # (payload array byte) -12017 0x11/imm32/alloc-id:fake:payload -12018 # "03/add" -12019 0x6/imm32/size -12020 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d -12021 _string_05_add_to_eax: # (payload array byte) -12022 0x11/imm32/alloc-id:fake:payload -12023 # "05/add-to-eax" -12024 0xd/imm32/size -12025 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 -12026 _string_09_or_with: # (payload array byte) -12027 0x11/imm32/alloc-id:fake:payload -12028 # "09/or-with" -12029 0xa/imm32/size -12030 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -12031 _string_0b_or: # (payload array byte) -12032 0x11/imm32/alloc-id:fake:payload -12033 # "0b/or" -12034 0x5/imm32/size -12035 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r -12036 _string_0d_or_with_eax: # (payload array byte) -12037 0x11/imm32/alloc-id:fake:payload -12038 # "0d/or-with-eax" -12039 0xe/imm32/size -12040 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 -12041 _string_0f_82_jump_label: # (payload array byte) -12042 0x11/imm32/alloc-id:fake:payload -12043 # "0f 82/jump-if-addr<" -12044 0x13/imm32/size -12045 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/< -12046 _string_0f_82_jump_break: # (payload array byte) -12047 0x11/imm32/alloc-id:fake:payload -12048 # "0f 82/jump-if-addr< break/disp32" -12049 0x20/imm32/size -12050 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 -12051 _string_0f_82_jump_loop: # (payload array byte) -12052 0x11/imm32/alloc-id:fake:payload -12053 # "0f 82/jump-if-addr< loop/disp32" -12054 0x1f/imm32/size -12055 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 -12056 _string_0f_83_jump_label: # (payload array byte) -12057 0x11/imm32/alloc-id:fake:payload -12058 # "0f 83/jump-if-addr>=" -12059 0x14/imm32/size -12060 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/= -12061 _string_0f_83_jump_break: # (payload array byte) -12062 0x11/imm32/alloc-id:fake:payload -12063 # "0f 83/jump-if-addr>= break/disp32" -12064 0x21/imm32/size -12065 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 -12066 _string_0f_83_jump_loop: # (payload array byte) -12067 0x11/imm32/alloc-id:fake:payload -12068 # "0f 83/jump-if-addr>= loop/disp32" -12069 0x20/imm32/size -12070 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 -12071 _string_0f_84_jump_label: # (payload array byte) -12072 0x11/imm32/alloc-id:fake:payload -12073 # "0f 84/jump-if-=" -12074 0xf/imm32/size -12075 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/= -12076 _string_0f_84_jump_break: # (payload array byte) -12077 0x11/imm32/alloc-id:fake:payload -12078 # "0f 84/jump-if-= break/disp32" -12079 0x1c/imm32/size -12080 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 -12081 _string_0f_84_jump_loop: # (payload array byte) -12082 0x11/imm32/alloc-id:fake:payload -12083 # "0f 84/jump-if-= loop/disp32" -12084 0x1b/imm32/size -12085 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 -12086 _string_0f_85_jump_label: # (payload array byte) -12087 0x11/imm32/alloc-id:fake:payload -12088 # "0f 85/jump-if-!=" -12089 0x10/imm32/size -12090 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/= -12091 _string_0f_85_jump_break: # (payload array byte) -12092 0x11/imm32/alloc-id:fake:payload -12093 # "0f 85/jump-if-!= break/disp32" -12094 0x1d/imm32/size -12095 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 -12096 _string_0f_85_jump_loop: # (payload array byte) -12097 0x11/imm32/alloc-id:fake:payload -12098 # "0f 85/jump-if-!= loop/disp32" -12099 0x1c/imm32/size -12100 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 -12101 _string_0f_86_jump_label: # (payload array byte) -12102 0x11/imm32/alloc-id:fake:payload -12103 # "0f 86/jump-if-addr<=" -12104 0x14/imm32/size -12105 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/= -12106 _string_0f_86_jump_break: # (payload array byte) -12107 0x11/imm32/alloc-id:fake:payload -12108 # "0f 86/jump-if-addr<= break/disp32" -12109 0x21/imm32/size -12110 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 -12111 _string_0f_86_jump_loop: # (payload array byte) -12112 0x11/imm32/alloc-id:fake:payload -12113 # "0f 86/jump-if-addr<= loop/disp32" -12114 0x20/imm32/size -12115 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 -12116 _string_0f_87_jump_label: # (payload array byte) -12117 0x11/imm32/alloc-id:fake:payload -12118 # "0f 87/jump-if-addr>" -12119 0x13/imm32/size -12120 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/> -12121 _string_0f_87_jump_break: # (payload array byte) -12122 0x11/imm32/alloc-id:fake:payload -12123 # "0f 87/jump-if-addr> break/disp32" -12124 0x20/imm32/size -12125 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 -12126 _string_0f_87_jump_loop: # (payload array byte) -12127 0x11/imm32/alloc-id:fake:payload -12128 # "0f 87/jump-if-addr> loop/disp32" -12129 0x1f/imm32/size -12130 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 -12131 _string_0f_8c_jump_label: # (payload array byte) -12132 0x11/imm32/alloc-id:fake:payload -12133 # "0f 8c/jump-if-<" -12134 0xf/imm32/size -12135 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/< -12136 _string_0f_8c_jump_break: # (payload array byte) -12137 0x11/imm32/alloc-id:fake:payload -12138 # "0f 8c/jump-if-< break/disp32" -12139 0x1c/imm32/size -12140 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 -12141 _string_0f_8c_jump_loop: # (payload array byte) -12142 0x11/imm32/alloc-id:fake:payload -12143 # "0f 8c/jump-if-< loop/disp32" -12144 0x1b/imm32/size -12145 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 -12146 _string_0f_8d_jump_label: # (payload array byte) -12147 0x11/imm32/alloc-id:fake:payload -12148 # "0f 8d/jump-if->=" -12149 0x10/imm32/size -12150 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/= -12151 _string_0f_8d_jump_break: # (payload array byte) -12152 0x11/imm32/alloc-id:fake:payload -12153 # "0f 8d/jump-if->= break/disp32" -12154 0x1d/imm32/size -12155 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 -12156 _string_0f_8d_jump_loop: # (payload array byte) -12157 0x11/imm32/alloc-id:fake:payload -12158 # "0f 8d/jump-if->= loop/disp32" -12159 0x1c/imm32/size -12160 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 -12161 _string_0f_8e_jump_label: # (payload array byte) -12162 0x11/imm32/alloc-id:fake:payload -12163 # "0f 8e/jump-if-<=" -12164 0x10/imm32/size -12165 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/= -12166 _string_0f_8e_jump_break: # (payload array byte) -12167 0x11/imm32/alloc-id:fake:payload -12168 # "0f 8e/jump-if-<= break/disp32" -12169 0x1d/imm32/size -12170 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 -12171 _string_0f_8e_jump_loop: # (payload array byte) -12172 0x11/imm32/alloc-id:fake:payload -12173 # "0f 8e/jump-if-<= loop/disp32" -12174 0x1c/imm32/size -12175 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 -12176 _string_0f_8f_jump_label: # (payload array byte) -12177 0x11/imm32/alloc-id:fake:payload -12178 # "0f 8f/jump-if->" -12179 0xf/imm32/size -12180 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/> -12181 _string_0f_8f_jump_break: # (payload array byte) -12182 0x11/imm32/alloc-id:fake:payload -12183 # "0f 8f/jump-if-> break/disp32" -12184 0x1c/imm32/size -12185 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 -12186 _string_0f_8f_jump_loop: # (payload array byte) -12187 0x11/imm32/alloc-id:fake:payload -12188 # "0f 8f/jump-if-> loop/disp32" -12189 0x1b/imm32/size -12190 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 -12191 _string_0f_af_multiply: # (payload array byte) -12192 0x11/imm32/alloc-id:fake:payload -12193 # "0f af/multiply" -12194 0xe/imm32/size -12195 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 -12196 _string_21_and_with: # (payload array byte) -12197 0x11/imm32/alloc-id:fake:payload -12198 # "21/and-with" -12199 0xb/imm32/size -12200 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -12201 _string_23_and: # (payload array byte) -12202 0x11/imm32/alloc-id:fake:payload -12203 # "23/and" -12204 0x6/imm32/size -12205 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d -12206 _string_25_and_with_eax: # (payload array byte) -12207 0x11/imm32/alloc-id:fake:payload -12208 # "25/and-with-eax" -12209 0xf/imm32/size -12210 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 -12211 _string_29_subtract_from: # (payload array byte) -12212 0x11/imm32/alloc-id:fake:payload -12213 # "29/subtract-from" -12214 0x10/imm32/size -12215 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 -12216 _string_2b_subtract: # (payload array byte) -12217 0x11/imm32/alloc-id:fake:payload -12218 # "2b/subtract" -12219 0xb/imm32/size -12220 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -12221 _string_2d_subtract_from_eax: # (payload array byte) -12222 0x11/imm32/alloc-id:fake:payload -12223 # "2d/subtract-from-eax" -12224 0x14/imm32/size -12225 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 -12226 _string_31_xor_with: # (payload array byte) -12227 0x11/imm32/alloc-id:fake:payload -12228 # "31/xor-with" -12229 0xb/imm32/size -12230 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -12231 _string_33_xor: # (payload array byte) -12232 0x11/imm32/alloc-id:fake:payload -12233 # "33/xor" -12234 0x6/imm32/size -12235 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r -12236 _string_35_xor_with_eax: # (payload array byte) -12237 0x11/imm32/alloc-id:fake:payload -12238 # "35/xor-with-eax" -12239 0xf/imm32/size -12240 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 -12241 _string_39_compare->: # (payload array byte) -12242 0x11/imm32/alloc-id:fake:payload -12243 # "39/compare->" -12244 0xc/imm32/size -12245 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> -12246 _string_3b_compare<-: # (payload array byte) -12247 0x11/imm32/alloc-id:fake:payload -12248 # "3b/compare<-" -12249 0xc/imm32/size -12250 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash -12251 _string_3d_compare_eax_with: # (payload array byte) -12252 0x11/imm32/alloc-id:fake:payload -12253 # "3d/compare-eax-with" -12254 0x13/imm32/size -12255 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 -12256 _string_40_increment_eax: # (payload array byte) -12257 0x11/imm32/alloc-id:fake:payload -12258 # "40/increment-eax" -12259 0x10/imm32/size -12260 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 -12261 _string_41_increment_ecx: # (payload array byte) -12262 0x11/imm32/alloc-id:fake:payload -12263 # "41/increment-ecx" -12264 0x10/imm32/size -12265 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 -12266 _string_42_increment_edx: # (payload array byte) -12267 0x11/imm32/alloc-id:fake:payload -12268 # "42/increment-edx" -12269 0x10/imm32/size -12270 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 -12271 _string_43_increment_ebx: # (payload array byte) -12272 0x11/imm32/alloc-id:fake:payload -12273 # "43/increment-ebx" -12274 0x10/imm32/size -12275 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 -12276 _string_46_increment_esi: # (payload array byte) -12277 0x11/imm32/alloc-id:fake:payload -12278 # "46/increment-esi" -12279 0x10/imm32/size -12280 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 -12281 _string_47_increment_edi: # (payload array byte) -12282 0x11/imm32/alloc-id:fake:payload -12283 # "47/increment-edi" -12284 0x10/imm32/size -12285 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 -12286 _string_48_decrement_eax: # (payload array byte) -12287 0x11/imm32/alloc-id:fake:payload -12288 # "48/decrement-eax" -12289 0x10/imm32/size -12290 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 -12291 _string_49_decrement_ecx: # (payload array byte) -12292 0x11/imm32/alloc-id:fake:payload -12293 # "49/decrement-ecx" -12294 0x10/imm32/size -12295 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 -12296 _string_4a_decrement_edx: # (payload array byte) -12297 0x11/imm32/alloc-id:fake:payload -12298 # "4a/decrement-edx" -12299 0x10/imm32/size -12300 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 -12301 _string_4b_decrement_ebx: # (payload array byte) -12302 0x11/imm32/alloc-id:fake:payload -12303 # "4b/decrement-ebx" -12304 0x10/imm32/size -12305 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 -12306 _string_4e_decrement_esi: # (payload array byte) -12307 0x11/imm32/alloc-id:fake:payload -12308 # "4e/decrement-esi" -12309 0x10/imm32/size -12310 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 -12311 _string_4f_decrement_edi: # (payload array byte) -12312 0x11/imm32/alloc-id:fake:payload -12313 # "4f/decrement-edi" -12314 0x10/imm32/size -12315 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 -12316 _string_81_subop_add: # (payload array byte) -12317 0x11/imm32/alloc-id:fake:payload -12318 # "81 0/subop/add" -12319 0xe/imm32/size -12320 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 -12321 _string_81_subop_or: # (payload array byte) -12322 0x11/imm32/alloc-id:fake:payload -12323 # "81 1/subop/or" -12324 0xd/imm32/size -12325 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 -12326 _string_81_subop_and: # (payload array byte) -12327 0x11/imm32/alloc-id:fake:payload -12328 # "81 4/subop/and" -12329 0xe/imm32/size -12330 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 -12331 _string_81_subop_subtract: # (payload array byte) -12332 0x11/imm32/alloc-id:fake:payload -12333 # "81 5/subop/subtract" -12334 0x13/imm32/size -12335 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 -12336 _string_81_subop_xor: # (payload array byte) -12337 0x11/imm32/alloc-id:fake:payload -12338 # "81 6/subop/xor" -12339 0xe/imm32/size -12340 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 -12341 _string_81_subop_compare: # (payload array byte) -12342 0x11/imm32/alloc-id:fake:payload -12343 # "81 7/subop/compare" -12344 0x12/imm32/size -12345 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 -12346 _string_89_<-: # (payload array byte) -12347 0x11/imm32/alloc-id:fake:payload -12348 # "89/<-" -12349 0x5/imm32/size -12350 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash -12351 _string_8b_->: # (payload array byte) -12352 0x11/imm32/alloc-id:fake:payload -12353 # "8b/->" -12354 0x5/imm32/size -12355 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> -12356 _string_8d_copy_address: # (payload array byte) -12357 0x11/imm32/alloc-id:fake:payload -12358 # "8d/copy-address" -12359 0xf/imm32/size -12360 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 -12361 _string_b8_copy_to_eax: # (payload array byte) -12362 0x11/imm32/alloc-id:fake:payload -12363 # "b8/copy-to-eax" -12364 0xe/imm32/size -12365 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 -12366 _string_b9_copy_to_ecx: # (payload array byte) -12367 0x11/imm32/alloc-id:fake:payload -12368 # "b9/copy-to-ecx" -12369 0xe/imm32/size -12370 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 -12371 _string_ba_copy_to_edx: # (payload array byte) -12372 0x11/imm32/alloc-id:fake:payload -12373 # "ba/copy-to-edx" -12374 0xe/imm32/size -12375 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 -12376 _string_bb_copy_to_ebx: # (payload array byte) -12377 0x11/imm32/alloc-id:fake:payload -12378 # "bb/copy-to-ebx" -12379 0xe/imm32/size -12380 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 -12381 _string_be_copy_to_esi: # (payload array byte) -12382 0x11/imm32/alloc-id:fake:payload -12383 # "be/copy-to-esi" -12384 0xe/imm32/size -12385 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 -12386 _string_bf_copy_to_edi: # (payload array byte) -12387 0x11/imm32/alloc-id:fake:payload -12388 # "bf/copy-to-edi" -12389 0xe/imm32/size -12390 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 -12391 _string_c7_subop_copy: # (payload array byte) -12392 0x11/imm32/alloc-id:fake:payload -12393 # "c7 0/subop/copy" -12394 0xf/imm32/size -12395 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 -12396 _string_e9_jump_label: # (payload array byte) -12397 0x11/imm32/alloc-id:fake:payload -12398 # "e9/jump" -12399 0x7/imm32/size -12400 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p -12401 _string_e9_jump_break: # (payload array byte) -12402 0x11/imm32/alloc-id:fake:payload -12403 # "e9/jump break/disp32" -12404 0x14/imm32/size -12405 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 -12406 _string_e9_jump_loop: # (payload array byte) -12407 0x11/imm32/alloc-id:fake:payload -12408 # "e9/jump loop/disp32" -12409 0x13/imm32/size -12410 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 -12411 _string_ff_subop_increment: # (payload array byte) -12412 0x11/imm32/alloc-id:fake:payload -12413 # "ff 0/subop/increment" -12414 0x14/imm32/size -12415 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 -12416 _string_ff_subop_decrement: # (payload array byte) -12417 0x11/imm32/alloc-id:fake:payload -12418 # "ff 1/subop/decrement" -12419 0x14/imm32/size -12420 0x66/f 0x66/f 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 -12421 -12422 Single-int-var-in-mem: # (payload list var) -12423 0x11/imm32/alloc-id:fake:payload -12424 0x11/imm32/alloc-id:fake -12425 Int-var-in-mem/imm32 -12426 0/imm32/next -12427 0/imm32/next +12013 # "xor-with" +12014 0x8/imm32/size +12015 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +12016 +12017 # string literals for SubX instructions +12018 _string_01_add_to: # (payload array byte) +12019 0x11/imm32/alloc-id:fake:payload +12020 # "01/add-to" +12021 0x9/imm32/size +12022 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +12023 _string_03_add: # (payload array byte) +12024 0x11/imm32/alloc-id:fake:payload +12025 # "03/add" +12026 0x6/imm32/size +12027 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d +12028 _string_05_add_to_eax: # (payload array byte) +12029 0x11/imm32/alloc-id:fake:payload +12030 # "05/add-to-eax" +12031 0xd/imm32/size +12032 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 +12033 _string_09_or_with: # (payload array byte) +12034 0x11/imm32/alloc-id:fake:payload +12035 # "09/or-with" +12036 0xa/imm32/size +12037 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +12038 _string_0b_or: # (payload array byte) +12039 0x11/imm32/alloc-id:fake:payload +12040 # "0b/or" +12041 0x5/imm32/size +12042 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r +12043 _string_0d_or_with_eax: # (payload array byte) +12044 0x11/imm32/alloc-id:fake:payload +12045 # "0d/or-with-eax" +12046 0xe/imm32/size +12047 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 +12048 _string_0f_82_jump_label: # (payload array byte) +12049 0x11/imm32/alloc-id:fake:payload +12050 # "0f 82/jump-if-addr<" +12051 0x13/imm32/size +12052 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/< +12053 _string_0f_82_jump_break: # (payload array byte) +12054 0x11/imm32/alloc-id:fake:payload +12055 # "0f 82/jump-if-addr< break/disp32" +12056 0x20/imm32/size +12057 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 +12058 _string_0f_82_jump_loop: # (payload array byte) +12059 0x11/imm32/alloc-id:fake:payload +12060 # "0f 82/jump-if-addr< loop/disp32" +12061 0x1f/imm32/size +12062 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 +12063 _string_0f_83_jump_label: # (payload array byte) +12064 0x11/imm32/alloc-id:fake:payload +12065 # "0f 83/jump-if-addr>=" +12066 0x14/imm32/size +12067 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/= +12068 _string_0f_83_jump_break: # (payload array byte) +12069 0x11/imm32/alloc-id:fake:payload +12070 # "0f 83/jump-if-addr>= break/disp32" +12071 0x21/imm32/size +12072 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 +12073 _string_0f_83_jump_loop: # (payload array byte) +12074 0x11/imm32/alloc-id:fake:payload +12075 # "0f 83/jump-if-addr>= loop/disp32" +12076 0x20/imm32/size +12077 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 +12078 _string_0f_84_jump_label: # (payload array byte) +12079 0x11/imm32/alloc-id:fake:payload +12080 # "0f 84/jump-if-=" +12081 0xf/imm32/size +12082 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/= +12083 _string_0f_84_jump_break: # (payload array byte) +12084 0x11/imm32/alloc-id:fake:payload +12085 # "0f 84/jump-if-= break/disp32" +12086 0x1c/imm32/size +12087 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 +12088 _string_0f_84_jump_loop: # (payload array byte) +12089 0x11/imm32/alloc-id:fake:payload +12090 # "0f 84/jump-if-= loop/disp32" +12091 0x1b/imm32/size +12092 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 +12093 _string_0f_85_jump_label: # (payload array byte) +12094 0x11/imm32/alloc-id:fake:payload +12095 # "0f 85/jump-if-!=" +12096 0x10/imm32/size +12097 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/= +12098 _string_0f_85_jump_break: # (payload array byte) +12099 0x11/imm32/alloc-id:fake:payload +12100 # "0f 85/jump-if-!= break/disp32" +12101 0x1d/imm32/size +12102 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 +12103 _string_0f_85_jump_loop: # (payload array byte) +12104 0x11/imm32/alloc-id:fake:payload +12105 # "0f 85/jump-if-!= loop/disp32" +12106 0x1c/imm32/size +12107 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 +12108 _string_0f_86_jump_label: # (payload array byte) +12109 0x11/imm32/alloc-id:fake:payload +12110 # "0f 86/jump-if-addr<=" +12111 0x14/imm32/size +12112 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/= +12113 _string_0f_86_jump_break: # (payload array byte) +12114 0x11/imm32/alloc-id:fake:payload +12115 # "0f 86/jump-if-addr<= break/disp32" +12116 0x21/imm32/size +12117 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 +12118 _string_0f_86_jump_loop: # (payload array byte) +12119 0x11/imm32/alloc-id:fake:payload +12120 # "0f 86/jump-if-addr<= loop/disp32" +12121 0x20/imm32/size +12122 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 +12123 _string_0f_87_jump_label: # (payload array byte) +12124 0x11/imm32/alloc-id:fake:payload +12125 # "0f 87/jump-if-addr>" +12126 0x13/imm32/size +12127 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/> +12128 _string_0f_87_jump_break: # (payload array byte) +12129 0x11/imm32/alloc-id:fake:payload +12130 # "0f 87/jump-if-addr> break/disp32" +12131 0x20/imm32/size +12132 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 +12133 _string_0f_87_jump_loop: # (payload array byte) +12134 0x11/imm32/alloc-id:fake:payload +12135 # "0f 87/jump-if-addr> loop/disp32" +12136 0x1f/imm32/size +12137 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 +12138 _string_0f_8c_jump_label: # (payload array byte) +12139 0x11/imm32/alloc-id:fake:payload +12140 # "0f 8c/jump-if-<" +12141 0xf/imm32/size +12142 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/< +12143 _string_0f_8c_jump_break: # (payload array byte) +12144 0x11/imm32/alloc-id:fake:payload +12145 # "0f 8c/jump-if-< break/disp32" +12146 0x1c/imm32/size +12147 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 +12148 _string_0f_8c_jump_loop: # (payload array byte) +12149 0x11/imm32/alloc-id:fake:payload +12150 # "0f 8c/jump-if-< loop/disp32" +12151 0x1b/imm32/size +12152 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 +12153 _string_0f_8d_jump_label: # (payload array byte) +12154 0x11/imm32/alloc-id:fake:payload +12155 # "0f 8d/jump-if->=" +12156 0x10/imm32/size +12157 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/= +12158 _string_0f_8d_jump_break: # (payload array byte) +12159 0x11/imm32/alloc-id:fake:payload +12160 # "0f 8d/jump-if->= break/disp32" +12161 0x1d/imm32/size +12162 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 +12163 _string_0f_8d_jump_loop: # (payload array byte) +12164 0x11/imm32/alloc-id:fake:payload +12165 # "0f 8d/jump-if->= loop/disp32" +12166 0x1c/imm32/size +12167 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 +12168 _string_0f_8e_jump_label: # (payload array byte) +12169 0x11/imm32/alloc-id:fake:payload +12170 # "0f 8e/jump-if-<=" +12171 0x10/imm32/size +12172 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/= +12173 _string_0f_8e_jump_break: # (payload array byte) +12174 0x11/imm32/alloc-id:fake:payload +12175 # "0f 8e/jump-if-<= break/disp32" +12176 0x1d/imm32/size +12177 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 +12178 _string_0f_8e_jump_loop: # (payload array byte) +12179 0x11/imm32/alloc-id:fake:payload +12180 # "0f 8e/jump-if-<= loop/disp32" +12181 0x1c/imm32/size +12182 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 +12183 _string_0f_8f_jump_label: # (payload array byte) +12184 0x11/imm32/alloc-id:fake:payload +12185 # "0f 8f/jump-if->" +12186 0xf/imm32/size +12187 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/> +12188 _string_0f_8f_jump_break: # (payload array byte) +12189 0x11/imm32/alloc-id:fake:payload +12190 # "0f 8f/jump-if-> break/disp32" +12191 0x1c/imm32/size +12192 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 +12193 _string_0f_8f_jump_loop: # (payload array byte) +12194 0x11/imm32/alloc-id:fake:payload +12195 # "0f 8f/jump-if-> loop/disp32" +12196 0x1b/imm32/size +12197 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 +12198 _string_0f_af_multiply: # (payload array byte) +12199 0x11/imm32/alloc-id:fake:payload +12200 # "0f af/multiply" +12201 0xe/imm32/size +12202 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 +12203 _string_21_and_with: # (payload array byte) +12204 0x11/imm32/alloc-id:fake:payload +12205 # "21/and-with" +12206 0xb/imm32/size +12207 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +12208 _string_23_and: # (payload array byte) +12209 0x11/imm32/alloc-id:fake:payload +12210 # "23/and" +12211 0x6/imm32/size +12212 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d +12213 _string_25_and_with_eax: # (payload array byte) +12214 0x11/imm32/alloc-id:fake:payload +12215 # "25/and-with-eax" +12216 0xf/imm32/size +12217 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 +12218 _string_29_subtract_from: # (payload array byte) +12219 0x11/imm32/alloc-id:fake:payload +12220 # "29/subtract-from" +12221 0x10/imm32/size +12222 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 +12223 _string_2b_subtract: # (payload array byte) +12224 0x11/imm32/alloc-id:fake:payload +12225 # "2b/subtract" +12226 0xb/imm32/size +12227 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +12228 _string_2d_subtract_from_eax: # (payload array byte) +12229 0x11/imm32/alloc-id:fake:payload +12230 # "2d/subtract-from-eax" +12231 0x14/imm32/size +12232 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 +12233 _string_31_xor_with: # (payload array byte) +12234 0x11/imm32/alloc-id:fake:payload +12235 # "31/xor-with" +12236 0xb/imm32/size +12237 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +12238 _string_33_xor: # (payload array byte) +12239 0x11/imm32/alloc-id:fake:payload +12240 # "33/xor" +12241 0x6/imm32/size +12242 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r +12243 _string_35_xor_with_eax: # (payload array byte) +12244 0x11/imm32/alloc-id:fake:payload +12245 # "35/xor-with-eax" +12246 0xf/imm32/size +12247 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 +12248 _string_39_compare->: # (payload array byte) +12249 0x11/imm32/alloc-id:fake:payload +12250 # "39/compare->" +12251 0xc/imm32/size +12252 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> +12253 _string_3b_compare<-: # (payload array byte) +12254 0x11/imm32/alloc-id:fake:payload +12255 # "3b/compare<-" +12256 0xc/imm32/size +12257 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash +12258 _string_3d_compare_eax_with: # (payload array byte) +12259 0x11/imm32/alloc-id:fake:payload +12260 # "3d/compare-eax-with" +12261 0x13/imm32/size +12262 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 +12263 _string_40_increment_eax: # (payload array byte) +12264 0x11/imm32/alloc-id:fake:payload +12265 # "40/increment-eax" +12266 0x10/imm32/size +12267 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 +12268 _string_41_increment_ecx: # (payload array byte) +12269 0x11/imm32/alloc-id:fake:payload +12270 # "41/increment-ecx" +12271 0x10/imm32/size +12272 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 +12273 _string_42_increment_edx: # (payload array byte) +12274 0x11/imm32/alloc-id:fake:payload +12275 # "42/increment-edx" +12276 0x10/imm32/size +12277 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 +12278 _string_43_increment_ebx: # (payload array byte) +12279 0x11/imm32/alloc-id:fake:payload +12280 # "43/increment-ebx" +12281 0x10/imm32/size +12282 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 +12283 _string_46_increment_esi: # (payload array byte) +12284 0x11/imm32/alloc-id:fake:payload +12285 # "46/increment-esi" +12286 0x10/imm32/size +12287 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 +12288 _string_47_increment_edi: # (payload array byte) +12289 0x11/imm32/alloc-id:fake:payload +12290 # "47/increment-edi" +12291 0x10/imm32/size +12292 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 +12293 _string_48_decrement_eax: # (payload array byte) +12294 0x11/imm32/alloc-id:fake:payload +12295 # "48/decrement-eax" +12296 0x10/imm32/size +12297 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 +12298 _string_49_decrement_ecx: # (payload array byte) +12299 0x11/imm32/alloc-id:fake:payload +12300 # "49/decrement-ecx" +12301 0x10/imm32/size +12302 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 +12303 _string_4a_decrement_edx: # (payload array byte) +12304 0x11/imm32/alloc-id:fake:payload +12305 # "4a/decrement-edx" +12306 0x10/imm32/size +12307 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 +12308 _string_4b_decrement_ebx: # (payload array byte) +12309 0x11/imm32/alloc-id:fake:payload +12310 # "4b/decrement-ebx" +12311 0x10/imm32/size +12312 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 +12313 _string_4e_decrement_esi: # (payload array byte) +12314 0x11/imm32/alloc-id:fake:payload +12315 # "4e/decrement-esi" +12316 0x10/imm32/size +12317 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 +12318 _string_4f_decrement_edi: # (payload array byte) +12319 0x11/imm32/alloc-id:fake:payload +12320 # "4f/decrement-edi" +12321 0x10/imm32/size +12322 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 +12323 _string_81_subop_add: # (payload array byte) +12324 0x11/imm32/alloc-id:fake:payload +12325 # "81 0/subop/add" +12326 0xe/imm32/size +12327 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 +12328 _string_81_subop_or: # (payload array byte) +12329 0x11/imm32/alloc-id:fake:payload +12330 # "81 1/subop/or" +12331 0xd/imm32/size +12332 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 +12333 _string_81_subop_and: # (payload array byte) +12334 0x11/imm32/alloc-id:fake:payload +12335 # "81 4/subop/and" +12336 0xe/imm32/size +12337 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 +12338 _string_81_subop_subtract: # (payload array byte) +12339 0x11/imm32/alloc-id:fake:payload +12340 # "81 5/subop/subtract" +12341 0x13/imm32/size +12342 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 +12343 _string_81_subop_xor: # (payload array byte) +12344 0x11/imm32/alloc-id:fake:payload +12345 # "81 6/subop/xor" +12346 0xe/imm32/size +12347 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 +12348 _string_81_subop_compare: # (payload array byte) +12349 0x11/imm32/alloc-id:fake:payload +12350 # "81 7/subop/compare" +12351 0x12/imm32/size +12352 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 +12353 _string_89_<-: # (payload array byte) +12354 0x11/imm32/alloc-id:fake:payload +12355 # "89/<-" +12356 0x5/imm32/size +12357 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash +12358 _string_8b_->: # (payload array byte) +12359 0x11/imm32/alloc-id:fake:payload +12360 # "8b/->" +12361 0x5/imm32/size +12362 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> +12363 _string_8d_copy_address: # (payload array byte) +12364 0x11/imm32/alloc-id:fake:payload +12365 # "8d/copy-address" +12366 0xf/imm32/size +12367 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 +12368 _string_b8_copy_to_eax: # (payload array byte) +12369 0x11/imm32/alloc-id:fake:payload +12370 # "b8/copy-to-eax" +12371 0xe/imm32/size +12372 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 +12373 _string_b9_copy_to_ecx: # (payload array byte) +12374 0x11/imm32/alloc-id:fake:payload +12375 # "b9/copy-to-ecx" +12376 0xe/imm32/size +12377 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 +12378 _string_ba_copy_to_edx: # (payload array byte) +12379 0x11/imm32/alloc-id:fake:payload +12380 # "ba/copy-to-edx" +12381 0xe/imm32/size +12382 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 +12383 _string_bb_copy_to_ebx: # (payload array byte) +12384 0x11/imm32/alloc-id:fake:payload +12385 # "bb/copy-to-ebx" +12386 0xe/imm32/size +12387 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 +12388 _string_be_copy_to_esi: # (payload array byte) +12389 0x11/imm32/alloc-id:fake:payload +12390 # "be/copy-to-esi" +12391 0xe/imm32/size +12392 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 +12393 _string_bf_copy_to_edi: # (payload array byte) +12394 0x11/imm32/alloc-id:fake:payload +12395 # "bf/copy-to-edi" +12396 0xe/imm32/size +12397 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 +12398 _string_c7_subop_copy: # (payload array byte) +12399 0x11/imm32/alloc-id:fake:payload +12400 # "c7 0/subop/copy" +12401 0xf/imm32/size +12402 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 +12403 _string_e9_jump_label: # (payload array byte) +12404 0x11/imm32/alloc-id:fake:payload +12405 # "e9/jump" +12406 0x7/imm32/size +12407 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p +12408 _string_e9_jump_break: # (payload array byte) +12409 0x11/imm32/alloc-id:fake:payload +12410 # "e9/jump break/disp32" +12411 0x14/imm32/size +12412 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 +12413 _string_e9_jump_loop: # (payload array byte) +12414 0x11/imm32/alloc-id:fake:payload +12415 # "e9/jump loop/disp32" +12416 0x13/imm32/size +12417 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 +12418 _string_ff_subop_increment: # (payload array byte) +12419 0x11/imm32/alloc-id:fake:payload +12420 # "ff 0/subop/increment" +12421 0x14/imm32/size +12422 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 +12423 _string_ff_subop_decrement: # (payload array byte) +12424 0x11/imm32/alloc-id:fake:payload +12425 # "ff 1/subop/decrement" +12426 0x14/imm32/size +12427 0x66/f 0x66/f 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 12428 -12429 Int-var-in-mem: # (payload var) +12429 Single-int-var-in-mem: # (payload list var) 12430 0x11/imm32/alloc-id:fake:payload -12431 0/imm32/name -12432 0/imm32/name -12433 0x11/imm32/alloc-id:fake -12434 Type-int/imm32 -12435 1/imm32/some-block-depth -12436 1/imm32/some-stack-offset -12437 0/imm32/no-register -12438 0/imm32/no-register -12439 -12440 Two-args-int-stack-int-reg: # (payload list var) -12441 0x11/imm32/alloc-id:fake:payload -12442 0x11/imm32/alloc-id:fake -12443 Int-var-in-mem/imm32 -12444 0x11/imm32/alloc-id:fake -12445 Single-int-var-in-some-register/imm32/next +12431 0x11/imm32/alloc-id:fake +12432 Int-var-in-mem/imm32 +12433 0/imm32/next +12434 0/imm32/next +12435 +12436 Int-var-in-mem: # (payload var) +12437 0x11/imm32/alloc-id:fake:payload +12438 0/imm32/name +12439 0/imm32/name +12440 0x11/imm32/alloc-id:fake +12441 Type-int/imm32 +12442 1/imm32/some-block-depth +12443 1/imm32/some-stack-offset +12444 0/imm32/no-register +12445 0/imm32/no-register 12446 -12447 Two-args-int-reg-int-stack: # (payload list var) +12447 Two-args-int-stack-int-reg: # (payload list var) 12448 0x11/imm32/alloc-id:fake:payload 12449 0x11/imm32/alloc-id:fake -12450 Int-var-in-some-register/imm32 +12450 Int-var-in-mem/imm32 12451 0x11/imm32/alloc-id:fake -12452 Single-int-var-in-mem/imm32/next +12452 Single-int-var-in-some-register/imm32/next 12453 -12454 Two-args-int-eax-int-literal: # (payload list var) +12454 Two-args-int-reg-int-stack: # (payload list var) 12455 0x11/imm32/alloc-id:fake:payload 12456 0x11/imm32/alloc-id:fake -12457 Int-var-in-eax/imm32 +12457 Int-var-in-some-register/imm32 12458 0x11/imm32/alloc-id:fake -12459 Single-lit-var/imm32/next +12459 Single-int-var-in-mem/imm32/next 12460 -12461 Int-var-and-literal: # (payload list var) +12461 Two-args-int-eax-int-literal: # (payload list var) 12462 0x11/imm32/alloc-id:fake:payload 12463 0x11/imm32/alloc-id:fake -12464 Int-var-in-mem/imm32 +12464 Int-var-in-eax/imm32 12465 0x11/imm32/alloc-id:fake -12466 Single-lit-var/imm32/next +12466 Single-lit-var/imm32/next 12467 -12468 Int-var-in-register-and-literal: # (payload list var) +12468 Int-var-and-literal: # (payload list var) 12469 0x11/imm32/alloc-id:fake:payload 12470 0x11/imm32/alloc-id:fake -12471 Int-var-in-some-register/imm32 +12471 Int-var-in-mem/imm32 12472 0x11/imm32/alloc-id:fake -12473 Single-lit-var/imm32/next +12473 Single-lit-var/imm32/next 12474 -12475 Single-int-var-in-some-register: # (payload list var) +12475 Int-var-in-register-and-literal: # (payload list var) 12476 0x11/imm32/alloc-id:fake:payload 12477 0x11/imm32/alloc-id:fake -12478 Int-var-in-some-register/imm32 -12479 0/imm32/next -12480 0/imm32/next +12478 Int-var-in-some-register/imm32 +12479 0x11/imm32/alloc-id:fake +12480 Single-lit-var/imm32/next 12481 -12482 Single-addr-var-in-some-register: # (payload list var) +12482 Single-int-var-in-some-register: # (payload list var) 12483 0x11/imm32/alloc-id:fake:payload 12484 0x11/imm32/alloc-id:fake -12485 Addr-var-in-some-register/imm32 +12485 Int-var-in-some-register/imm32 12486 0/imm32/next 12487 0/imm32/next 12488 -12489 Int-var-in-some-register: # (payload var) +12489 Single-addr-var-in-some-register: # (payload list var) 12490 0x11/imm32/alloc-id:fake:payload -12491 0/imm32/name -12492 0/imm32/name -12493 0x11/imm32/alloc-id:fake -12494 Type-int/imm32 -12495 1/imm32/some-block-depth -12496 0/imm32/no-stack-offset -12497 0x11/imm32/alloc-id:fake -12498 Any-register/imm32 -12499 -12500 Any-register: # (payload array byte) -12501 0x11/imm32/alloc-id:fake:payload -12502 1/imm32/size -12503 # data -12504 2a/asterisk -12505 -12506 Addr-var-in-some-register: # (payload var) -12507 0x11/imm32/alloc-id:fake:payload -12508 0/imm32/name -12509 0/imm32/name -12510 0x11/imm32/alloc-id:fake -12511 Type-addr/imm32 -12512 1/imm32/some-block-depth -12513 0/imm32/no-stack-offset -12514 0x11/imm32/alloc-id:fake -12515 Any-register/imm32 -12516 -12517 Single-int-var-in-eax: # (payload list var) -12518 0x11/imm32/alloc-id:fake:payload -12519 0x11/imm32/alloc-id:fake -12520 Int-var-in-eax/imm32 -12521 0/imm32/next -12522 0/imm32/next +12491 0x11/imm32/alloc-id:fake +12492 Addr-var-in-some-register/imm32 +12493 0/imm32/next +12494 0/imm32/next +12495 +12496 Int-var-in-some-register: # (payload var) +12497 0x11/imm32/alloc-id:fake:payload +12498 0/imm32/name +12499 0/imm32/name +12500 0x11/imm32/alloc-id:fake +12501 Type-int/imm32 +12502 1/imm32/some-block-depth +12503 0/imm32/no-stack-offset +12504 0x11/imm32/alloc-id:fake +12505 Any-register/imm32 +12506 +12507 Any-register: # (payload array byte) +12508 0x11/imm32/alloc-id:fake:payload +12509 1/imm32/size +12510 # data +12511 2a/asterisk +12512 +12513 Addr-var-in-some-register: # (payload var) +12514 0x11/imm32/alloc-id:fake:payload +12515 0/imm32/name +12516 0/imm32/name +12517 0x11/imm32/alloc-id:fake +12518 Type-addr/imm32 +12519 1/imm32/some-block-depth +12520 0/imm32/no-stack-offset +12521 0x11/imm32/alloc-id:fake +12522 Any-register/imm32 12523 -12524 Int-var-in-eax: +12524 Single-int-var-in-eax: # (payload list var) 12525 0x11/imm32/alloc-id:fake:payload -12526 0/imm32/name -12527 0/imm32/name -12528 0x11/imm32/alloc-id:fake -12529 Type-int/imm32 -12530 1/imm32/some-block-depth -12531 0/imm32/no-stack-offset -12532 0x11/imm32/alloc-id:fake -12533 $Register-eax/imm32 -12534 -12535 Single-int-var-in-ecx: # (payload list var) -12536 0x11/imm32/alloc-id:fake:payload -12537 0x11/imm32/alloc-id:fake -12538 Int-var-in-ecx/imm32 -12539 0/imm32/next -12540 0/imm32/next +12526 0x11/imm32/alloc-id:fake +12527 Int-var-in-eax/imm32 +12528 0/imm32/next +12529 0/imm32/next +12530 +12531 Int-var-in-eax: +12532 0x11/imm32/alloc-id:fake:payload +12533 0/imm32/name +12534 0/imm32/name +12535 0x11/imm32/alloc-id:fake +12536 Type-int/imm32 +12537 1/imm32/some-block-depth +12538 0/imm32/no-stack-offset +12539 0x11/imm32/alloc-id:fake +12540 $Register-eax/imm32 12541 -12542 Int-var-in-ecx: +12542 Single-int-var-in-ecx: # (payload list var) 12543 0x11/imm32/alloc-id:fake:payload -12544 0/imm32/name -12545 0/imm32/name -12546 0x11/imm32/alloc-id:fake -12547 Type-int/imm32 -12548 1/imm32/some-block-depth -12549 0/imm32/no-stack-offset -12550 0x11/imm32/alloc-id:fake -12551 $Register-ecx/imm32/register -12552 -12553 Single-int-var-in-edx: # (payload list var) -12554 0x11/imm32/alloc-id:fake:payload -12555 0x11/imm32/alloc-id:fake -12556 Int-var-in-edx/imm32 -12557 0/imm32/next -12558 0/imm32/next +12544 0x11/imm32/alloc-id:fake +12545 Int-var-in-ecx/imm32 +12546 0/imm32/next +12547 0/imm32/next +12548 +12549 Int-var-in-ecx: +12550 0x11/imm32/alloc-id:fake:payload +12551 0/imm32/name +12552 0/imm32/name +12553 0x11/imm32/alloc-id:fake +12554 Type-int/imm32 +12555 1/imm32/some-block-depth +12556 0/imm32/no-stack-offset +12557 0x11/imm32/alloc-id:fake +12558 $Register-ecx/imm32/register 12559 -12560 Int-var-in-edx: # (payload list var) +12560 Single-int-var-in-edx: # (payload list var) 12561 0x11/imm32/alloc-id:fake:payload -12562 0/imm32/name -12563 0/imm32/name -12564 0x11/imm32/alloc-id:fake -12565 Type-int/imm32 -12566 1/imm32/some-block-depth -12567 0/imm32/no-stack-offset -12568 0x11/imm32/alloc-id:fake -12569 $Register-edx/imm32/register -12570 -12571 Single-int-var-in-ebx: # (payload list var) -12572 0x11/imm32/alloc-id:fake:payload -12573 0x11/imm32/alloc-id:fake -12574 Int-var-in-ebx/imm32 -12575 0/imm32/next -12576 0/imm32/next +12562 0x11/imm32/alloc-id:fake +12563 Int-var-in-edx/imm32 +12564 0/imm32/next +12565 0/imm32/next +12566 +12567 Int-var-in-edx: # (payload list var) +12568 0x11/imm32/alloc-id:fake:payload +12569 0/imm32/name +12570 0/imm32/name +12571 0x11/imm32/alloc-id:fake +12572 Type-int/imm32 +12573 1/imm32/some-block-depth +12574 0/imm32/no-stack-offset +12575 0x11/imm32/alloc-id:fake +12576 $Register-edx/imm32/register 12577 -12578 Int-var-in-ebx: # (payload list var) +12578 Single-int-var-in-ebx: # (payload list var) 12579 0x11/imm32/alloc-id:fake:payload -12580 0/imm32/name -12581 0/imm32/name -12582 0x11/imm32/alloc-id:fake -12583 Type-int/imm32 -12584 1/imm32/some-block-depth -12585 0/imm32/no-stack-offset -12586 0x11/imm32/alloc-id:fake -12587 $Register-ebx/imm32/register -12588 -12589 Single-int-var-in-esi: # (payload list var) -12590 0x11/imm32/alloc-id:fake:payload -12591 0x11/imm32/alloc-id:fake -12592 Int-var-in-esi/imm32 -12593 0/imm32/next -12594 0/imm32/next +12580 0x11/imm32/alloc-id:fake +12581 Int-var-in-ebx/imm32 +12582 0/imm32/next +12583 0/imm32/next +12584 +12585 Int-var-in-ebx: # (payload list var) +12586 0x11/imm32/alloc-id:fake:payload +12587 0/imm32/name +12588 0/imm32/name +12589 0x11/imm32/alloc-id:fake +12590 Type-int/imm32 +12591 1/imm32/some-block-depth +12592 0/imm32/no-stack-offset +12593 0x11/imm32/alloc-id:fake +12594 $Register-ebx/imm32/register 12595 -12596 Int-var-in-esi: # (payload list var) +12596 Single-int-var-in-esi: # (payload list var) 12597 0x11/imm32/alloc-id:fake:payload -12598 0/imm32/name -12599 0/imm32/name -12600 0x11/imm32/alloc-id:fake -12601 Type-int/imm32 -12602 1/imm32/some-block-depth -12603 0/imm32/no-stack-offset -12604 0x11/imm32/alloc-id:fake -12605 $Register-esi/imm32/register -12606 -12607 Single-int-var-in-edi: # (payload list var) -12608 0x11/imm32/alloc-id:fake:payload -12609 0x11/imm32/alloc-id:fake -12610 Int-var-in-edi/imm32 -12611 0/imm32/next -12612 0/imm32/next +12598 0x11/imm32/alloc-id:fake +12599 Int-var-in-esi/imm32 +12600 0/imm32/next +12601 0/imm32/next +12602 +12603 Int-var-in-esi: # (payload list var) +12604 0x11/imm32/alloc-id:fake:payload +12605 0/imm32/name +12606 0/imm32/name +12607 0x11/imm32/alloc-id:fake +12608 Type-int/imm32 +12609 1/imm32/some-block-depth +12610 0/imm32/no-stack-offset +12611 0x11/imm32/alloc-id:fake +12612 $Register-esi/imm32/register 12613 -12614 Int-var-in-edi: # (payload list var) +12614 Single-int-var-in-edi: # (payload list var) 12615 0x11/imm32/alloc-id:fake:payload -12616 0/imm32/name -12617 0/imm32/name -12618 0x11/imm32/alloc-id:fake -12619 Type-int/imm32 -12620 1/imm32/some-block-depth -12621 0/imm32/no-stack-offset -12622 0x11/imm32/alloc-id:fake -12623 $Register-edi/imm32/register -12624 -12625 Single-lit-var: # (payload list var) -12626 0x11/imm32/alloc-id:fake:payload -12627 0x11/imm32/alloc-id:fake -12628 Lit-var/imm32 -12629 0/imm32/next -12630 0/imm32/next +12616 0x11/imm32/alloc-id:fake +12617 Int-var-in-edi/imm32 +12618 0/imm32/next +12619 0/imm32/next +12620 +12621 Int-var-in-edi: # (payload list var) +12622 0x11/imm32/alloc-id:fake:payload +12623 0/imm32/name +12624 0/imm32/name +12625 0x11/imm32/alloc-id:fake +12626 Type-int/imm32 +12627 1/imm32/some-block-depth +12628 0/imm32/no-stack-offset +12629 0x11/imm32/alloc-id:fake +12630 $Register-edi/imm32/register 12631 -12632 Lit-var: # (payload var) +12632 Single-lit-var: # (payload list var) 12633 0x11/imm32/alloc-id:fake:payload -12634 0/imm32/name -12635 0/imm32/name -12636 0x11/imm32/alloc-id:fake -12637 Type-literal/imm32 -12638 1/imm32/some-block-depth -12639 0/imm32/no-stack-offset -12640 0/imm32/no-register -12641 0/imm32/no-register -12642 -12643 Type-int: # (payload tree type-id) -12644 0x11/imm32/alloc-id:fake:payload -12645 1/imm32/left-is-atom -12646 1/imm32/value:int -12647 0/imm32/left:unused -12648 0/imm32/right:null -12649 0/imm32/right:null -12650 -12651 Type-literal: # (payload tree type-id) -12652 0x11/imm32/alloc-id:fake:payload -12653 1/imm32/is-atom -12654 0/imm32/value:literal -12655 0/imm32/left:unused +12634 0x11/imm32/alloc-id:fake +12635 Lit-var/imm32 +12636 0/imm32/next +12637 0/imm32/next +12638 +12639 Lit-var: # (payload var) +12640 0x11/imm32/alloc-id:fake:payload +12641 0/imm32/name +12642 0/imm32/name +12643 0x11/imm32/alloc-id:fake +12644 Type-literal/imm32 +12645 1/imm32/some-block-depth +12646 0/imm32/no-stack-offset +12647 0/imm32/no-register +12648 0/imm32/no-register +12649 +12650 Type-int: # (payload tree type-id) +12651 0x11/imm32/alloc-id:fake:payload +12652 1/imm32/left-is-atom +12653 1/imm32/value:int +12654 0/imm32/left:unused +12655 0/imm32/right:null 12656 0/imm32/right:null -12657 0/imm32/right:null -12658 -12659 Type-addr: # (payload tree type-id) -12660 0x11/imm32/alloc-id:fake:payload -12661 1/imm32/is-atom -12662 2/imm32/value:addr -12663 0/imm32/left:unused +12657 +12658 Type-literal: # (payload tree type-id) +12659 0x11/imm32/alloc-id:fake:payload +12660 1/imm32/is-atom +12661 0/imm32/value:literal +12662 0/imm32/left:unused +12663 0/imm32/right:null 12664 0/imm32/right:null -12665 0/imm32/right:null -12666 -12667 == code -12668 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive) -12669 # . prologue -12670 55/push-ebp -12671 89/<- %ebp 4/r32/esp -12672 # . save registers -12673 50/push-eax -12674 51/push-ecx -12675 # ecx = primitive -12676 8b/-> *(ebp+0x10) 1/r32/ecx -12677 # emit primitive name -12678 (emit-indent *(ebp+8) *Curr-block-depth) -12679 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax -12680 (write-buffered *(ebp+8) %eax) -12681 # emit rm32 if necessary -12682 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc)) # out, Primitive-subx-rm32, stmt -12683 # emit r32 if necessary -12684 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # out, Primitive-subx-r32, stmt -12685 # emit imm32 if necessary -12686 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # out, Primitive-subx-imm32, stmt -12687 # emit disp32 if necessary -12688 (emit-subx-disp32 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # out, Primitive-subx-disp32, stmt -12689 (write-buffered *(ebp+8) Newline) -12690 $emit-subx-primitive:end: -12691 # . restore registers -12692 59/pop-to-ecx -12693 58/pop-to-eax -12694 # . epilogue -12695 89/<- %esp 5/r32/ebp -12696 5d/pop-to-ebp -12697 c3/return -12698 -12699 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -12700 # . prologue -12701 55/push-ebp -12702 89/<- %ebp 4/r32/esp -12703 # . save registers -12704 50/push-eax -12705 # if (l == 0) return -12706 81 7/subop/compare *(ebp+0xc) 0/imm32 -12707 74/jump-if-= $emit-subx-rm32:end/disp8 -12708 # var v/eax: (addr stmt-var) -12709 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -12710 (emit-subx-var-as-rm32 *(ebp+8) %eax) -12711 $emit-subx-rm32:end: -12712 # . restore registers -12713 58/pop-to-eax -12714 # . epilogue -12715 89/<- %esp 5/r32/ebp -12716 5d/pop-to-ebp -12717 c3/return -12718 -12719 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location -> var/eax: (addr stmt-var) -12720 # . prologue -12721 55/push-ebp -12722 89/<- %ebp 4/r32/esp -12723 # . save registers -12724 51/push-ecx -12725 # eax = l -12726 8b/-> *(ebp+0xc) 0/r32/eax -12727 # ecx = stmt -12728 8b/-> *(ebp+8) 1/r32/ecx -12729 # if (l == 1) return stmt->inouts -12730 { -12731 3d/compare-eax-and 1/imm32 -12732 75/jump-if-!= break/disp8 -12733 $get-stmt-operand-from-arg-location:1: -12734 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12735 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -12736 } -12737 # if (l == 2) return stmt->inouts->next -12738 { -12739 3d/compare-eax-and 2/imm32 -12740 75/jump-if-!= break/disp8 -12741 $get-stmt-operand-from-arg-location:2: -12742 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12743 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12744 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -12745 } -12746 # if (l == 3) return stmt->outputs -12747 { -12748 3d/compare-eax-and 3/imm32 -12749 75/jump-if-!= break/disp8 -12750 $get-stmt-operand-from-arg-location:3: -12751 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -12752 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -12753 } -12754 # abort -12755 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 -12756 $get-stmt-operand-from-arg-location:end: -12757 # . restore registers -12758 59/pop-to-ecx -12759 # . epilogue -12760 89/<- %esp 5/r32/ebp -12761 5d/pop-to-ebp -12762 c3/return -12763 -12764 $get-stmt-operand-from-arg-location:abort: -12765 # error("invalid arg-location " eax) -12766 (write-buffered Stderr "invalid arg-location ") -12767 (print-int32-buffered Stderr %eax) -12768 (write-buffered Stderr Newline) -12769 (flush Stderr) -12770 # . syscall(exit, 1) -12771 bb/copy-to-ebx 1/imm32 -12772 b8/copy-to-eax 1/imm32/exit -12773 cd/syscall 0x80/imm8 -12774 # never gets here -12775 -12776 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -12777 # . prologue -12778 55/push-ebp -12779 89/<- %ebp 4/r32/esp -12780 # . save registers -12781 50/push-eax -12782 51/push-ecx -12783 # if (l == 0) return -12784 81 7/subop/compare *(ebp+0xc) 0/imm32 -12785 0f 84/jump-if-= $emit-subx-r32:end/disp32 -12786 # var v/eax: (addr stmt-var) -12787 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -12788 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12789 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -12790 (maybe-get Registers %eax 0xc) # => eax: (addr register-index) -12791 (write-buffered *(ebp+8) Space) -12792 (print-int32-buffered *(ebp+8) *eax) -12793 (write-buffered *(ebp+8) "/r32") -12794 $emit-subx-r32:end: -12795 # . restore registers -12796 59/pop-to-ecx -12797 58/pop-to-eax -12798 # . epilogue -12799 89/<- %esp 5/r32/ebp -12800 5d/pop-to-ebp -12801 c3/return -12802 -12803 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -12804 # . prologue -12805 55/push-ebp -12806 89/<- %ebp 4/r32/esp -12807 # . save registers -12808 50/push-eax -12809 51/push-ecx -12810 # if (l == 0) return -12811 81 7/subop/compare *(ebp+0xc) 0/imm32 -12812 0f 84/jump-if-= $emit-subx-imm32:end/disp32 -12813 # var v/eax: (handle var) -12814 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -12815 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12816 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12817 (write-buffered *(ebp+8) Space) -12818 (write-buffered *(ebp+8) %eax) -12819 (write-buffered *(ebp+8) "/imm32") -12820 $emit-subx-imm32:end: -12821 # . restore registers -12822 59/pop-to-ecx -12823 58/pop-to-eax -12824 # . epilogue -12825 89/<- %esp 5/r32/ebp -12826 5d/pop-to-ebp -12827 c3/return -12828 -12829 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -12830 # . prologue -12831 55/push-ebp -12832 89/<- %ebp 4/r32/esp -12833 # . save registers -12834 50/push-eax -12835 51/push-ecx -12836 # if (location == 0) return -12837 81 7/subop/compare *(ebp+0xc) 0/imm32 -12838 0f 84/jump-if-= $emit-subx-disp32:end/disp32 -12839 # var v/eax: (addr stmt-var) -12840 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -12841 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -12842 (lookup *eax *(eax+4)) # Var-name Var-name => eax -12843 (write-buffered *(ebp+8) Space) -12844 (write-buffered *(ebp+8) %eax) -12845 # hack: if instruction operation starts with "break", emit ":break" -12846 # var name/ecx: (addr array byte) = lookup(stmt->operation) -12847 8b/-> *(ebp+0x10) 0/r32/eax -12848 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -12849 89/<- %ecx 0/r32/eax -12850 { -12851 (string-starts-with? %ecx "break") # => eax -12852 3d/compare-eax-and 0/imm32/false -12853 74/jump-if-= break/disp8 -12854 (write-buffered *(ebp+8) ":break") -12855 } -12856 # hack: if instruction operation starts with "loop", emit ":loop" +12665 +12666 Type-addr: # (payload tree type-id) +12667 0x11/imm32/alloc-id:fake:payload +12668 1/imm32/is-atom +12669 2/imm32/value:addr +12670 0/imm32/left:unused +12671 0/imm32/right:null +12672 0/imm32/right:null +12673 +12674 == code +12675 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive) +12676 # . prologue +12677 55/push-ebp +12678 89/<- %ebp 4/r32/esp +12679 # . save registers +12680 50/push-eax +12681 51/push-ecx +12682 # ecx = primitive +12683 8b/-> *(ebp+0x10) 1/r32/ecx +12684 # emit primitive name +12685 (emit-indent *(ebp+8) *Curr-block-depth) +12686 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax +12687 (write-buffered *(ebp+8) %eax) +12688 # emit rm32 if necessary +12689 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc)) # out, Primitive-subx-rm32, stmt +12690 # emit r32 if necessary +12691 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # out, Primitive-subx-r32, stmt +12692 # emit imm32 if necessary +12693 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # out, Primitive-subx-imm32, stmt +12694 # emit disp32 if necessary +12695 (emit-subx-disp32 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # out, Primitive-subx-disp32, stmt +12696 (write-buffered *(ebp+8) Newline) +12697 $emit-subx-primitive:end: +12698 # . restore registers +12699 59/pop-to-ecx +12700 58/pop-to-eax +12701 # . epilogue +12702 89/<- %esp 5/r32/ebp +12703 5d/pop-to-ebp +12704 c3/return +12705 +12706 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +12707 # . prologue +12708 55/push-ebp +12709 89/<- %ebp 4/r32/esp +12710 # . save registers +12711 50/push-eax +12712 # if (l == 0) return +12713 81 7/subop/compare *(ebp+0xc) 0/imm32 +12714 74/jump-if-= $emit-subx-rm32:end/disp8 +12715 # var v/eax: (addr stmt-var) +12716 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +12717 (emit-subx-var-as-rm32 *(ebp+8) %eax) +12718 $emit-subx-rm32:end: +12719 # . restore registers +12720 58/pop-to-eax +12721 # . epilogue +12722 89/<- %esp 5/r32/ebp +12723 5d/pop-to-ebp +12724 c3/return +12725 +12726 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location -> var/eax: (addr stmt-var) +12727 # . prologue +12728 55/push-ebp +12729 89/<- %ebp 4/r32/esp +12730 # . save registers +12731 51/push-ecx +12732 # eax = l +12733 8b/-> *(ebp+0xc) 0/r32/eax +12734 # ecx = stmt +12735 8b/-> *(ebp+8) 1/r32/ecx +12736 # if (l == 1) return stmt->inouts +12737 { +12738 3d/compare-eax-and 1/imm32 +12739 75/jump-if-!= break/disp8 +12740 $get-stmt-operand-from-arg-location:1: +12741 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12742 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +12743 } +12744 # if (l == 2) return stmt->inouts->next +12745 { +12746 3d/compare-eax-and 2/imm32 +12747 75/jump-if-!= break/disp8 +12748 $get-stmt-operand-from-arg-location:2: +12749 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12750 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12751 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +12752 } +12753 # if (l == 3) return stmt->outputs +12754 { +12755 3d/compare-eax-and 3/imm32 +12756 75/jump-if-!= break/disp8 +12757 $get-stmt-operand-from-arg-location:3: +12758 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +12759 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +12760 } +12761 # abort +12762 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 +12763 $get-stmt-operand-from-arg-location:end: +12764 # . restore registers +12765 59/pop-to-ecx +12766 # . epilogue +12767 89/<- %esp 5/r32/ebp +12768 5d/pop-to-ebp +12769 c3/return +12770 +12771 $get-stmt-operand-from-arg-location:abort: +12772 # error("invalid arg-location " eax) +12773 (write-buffered Stderr "invalid arg-location ") +12774 (print-int32-buffered Stderr %eax) +12775 (write-buffered Stderr Newline) +12776 (flush Stderr) +12777 # . syscall(exit, 1) +12778 bb/copy-to-ebx 1/imm32 +12779 b8/copy-to-eax 1/imm32/exit +12780 cd/syscall 0x80/imm8 +12781 # never gets here +12782 +12783 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +12784 # . prologue +12785 55/push-ebp +12786 89/<- %ebp 4/r32/esp +12787 # . save registers +12788 50/push-eax +12789 51/push-ecx +12790 # if (l == 0) return +12791 81 7/subop/compare *(ebp+0xc) 0/imm32 +12792 0f 84/jump-if-= $emit-subx-r32:end/disp32 +12793 # var v/eax: (addr stmt-var) +12794 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +12795 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12796 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +12797 (maybe-get Registers %eax 0xc) # => eax: (addr register-index) +12798 (write-buffered *(ebp+8) Space) +12799 (print-int32-buffered *(ebp+8) *eax) +12800 (write-buffered *(ebp+8) "/r32") +12801 $emit-subx-r32:end: +12802 # . restore registers +12803 59/pop-to-ecx +12804 58/pop-to-eax +12805 # . epilogue +12806 89/<- %esp 5/r32/ebp +12807 5d/pop-to-ebp +12808 c3/return +12809 +12810 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +12811 # . prologue +12812 55/push-ebp +12813 89/<- %ebp 4/r32/esp +12814 # . save registers +12815 50/push-eax +12816 51/push-ecx +12817 # if (l == 0) return +12818 81 7/subop/compare *(ebp+0xc) 0/imm32 +12819 0f 84/jump-if-= $emit-subx-imm32:end/disp32 +12820 # var v/eax: (handle var) +12821 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +12822 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12823 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12824 (write-buffered *(ebp+8) Space) +12825 (write-buffered *(ebp+8) %eax) +12826 (write-buffered *(ebp+8) "/imm32") +12827 $emit-subx-imm32:end: +12828 # . restore registers +12829 59/pop-to-ecx +12830 58/pop-to-eax +12831 # . epilogue +12832 89/<- %esp 5/r32/ebp +12833 5d/pop-to-ebp +12834 c3/return +12835 +12836 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +12837 # . prologue +12838 55/push-ebp +12839 89/<- %ebp 4/r32/esp +12840 # . save registers +12841 50/push-eax +12842 51/push-ecx +12843 # if (location == 0) return +12844 81 7/subop/compare *(ebp+0xc) 0/imm32 +12845 0f 84/jump-if-= $emit-subx-disp32:end/disp32 +12846 # var v/eax: (addr stmt-var) +12847 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +12848 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +12849 (lookup *eax *(eax+4)) # Var-name Var-name => eax +12850 (write-buffered *(ebp+8) Space) +12851 (write-buffered *(ebp+8) %eax) +12852 # hack: if instruction operation starts with "break", emit ":break" +12853 # var name/ecx: (addr array byte) = lookup(stmt->operation) +12854 8b/-> *(ebp+0x10) 0/r32/eax +12855 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +12856 89/<- %ecx 0/r32/eax 12857 { -12858 (string-starts-with? %ecx "loop") # => eax +12858 (string-starts-with? %ecx "break") # => eax 12859 3d/compare-eax-and 0/imm32/false 12860 74/jump-if-= break/disp8 -12861 (write-buffered *(ebp+8) ":loop") +12861 (write-buffered *(ebp+8) ":break") 12862 } -12863 (write-buffered *(ebp+8) "/disp32") -12864 $emit-subx-disp32:end: -12865 # . restore registers -12866 59/pop-to-ecx -12867 58/pop-to-eax -12868 # . epilogue -12869 89/<- %esp 5/r32/ebp -12870 5d/pop-to-ebp -12871 c3/return -12872 -12873 emit-call: # out: (addr buffered-file), stmt: (addr stmt) -12874 # . prologue -12875 55/push-ebp -12876 89/<- %ebp 4/r32/esp -12877 # . save registers -12878 50/push-eax -12879 51/push-ecx -12880 # -12881 (emit-indent *(ebp+8) *Curr-block-depth) -12882 (write-buffered *(ebp+8) "(") -12883 # ecx = stmt -12884 8b/-> *(ebp+0xc) 1/r32/ecx -12885 # - emit function name -12886 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -12887 (write-buffered *(ebp+8) %eax) -12888 # - emit arguments -12889 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) -12890 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -12891 { -12892 # if (curr == null) break -12893 3d/compare-eax-and 0/imm32 -12894 74/jump-if-= break/disp8 -12895 # -12896 (emit-subx-call-operand *(ebp+8) %eax) -12897 # curr = lookup(curr->next) -12898 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -12899 eb/jump loop/disp8 -12900 } -12901 # -12902 (write-buffered *(ebp+8) ")\n") -12903 $emit-call:end: -12904 # . restore registers -12905 59/pop-to-ecx -12906 58/pop-to-eax -12907 # . epilogue -12908 89/<- %esp 5/r32/ebp -12909 5d/pop-to-ebp -12910 c3/return -12911 -12912 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) -12913 # shares code with emit-subx-var-as-rm32 -12914 # . prologue -12915 55/push-ebp -12916 89/<- %ebp 4/r32/esp -12917 # . save registers -12918 50/push-eax -12919 51/push-ecx -12920 56/push-esi -12921 # ecx = s -12922 8b/-> *(ebp+0xc) 1/r32/ecx -12923 # var operand/esi: (addr var) = lookup(s->value) -12924 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -12925 89/<- %esi 0/r32/eax -12926 # if (operand->register && !s->is-deref?) emit "%__" -12927 { -12928 $emit-subx-call-operand:check-for-register-direct: -12929 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -12930 74/jump-if-= break/disp8 -12931 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -12932 75/jump-if-!= break/disp8 -12933 $emit-subx-call-operand:register-direct: -12934 (write-buffered *(ebp+8) " %") -12935 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -12936 (write-buffered *(ebp+8) %eax) -12937 e9/jump $emit-subx-call-operand:end/disp32 -12938 } -12939 # else if (operand->register && s->is-deref?) emit "*__" -12940 { -12941 $emit-subx-call-operand:check-for-register-indirect: -12942 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -12943 74/jump-if-= break/disp8 -12944 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -12945 74/jump-if-= break/disp8 -12946 $emit-subx-call-operand:register-indirect: -12947 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) -12948 e9/jump $emit-subx-call-operand:end/disp32 -12949 } -12950 # else if (operand->stack-offset) emit "*(ebp+__)" -12951 { -12952 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -12953 74/jump-if-= break/disp8 -12954 $emit-subx-call-operand:stack: -12955 (emit-subx-call-operand-stack *(ebp+8) %esi) -12956 e9/jump $emit-subx-call-operand:end/disp32 -12957 } -12958 # else if (operand->type == literal) emit "__" -12959 { -12960 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -12961 81 7/subop/compare *(eax+4) 0/imm32 # Tree-left -12962 75/jump-if-!= break/disp8 -12963 $emit-subx-call-operand:literal: -12964 (write-buffered *(ebp+8) Space) -12965 (lookup *esi *(esi+4)) # Var-name Var-name => eax -12966 (write-buffered *(ebp+8) %eax) -12967 } -12968 $emit-subx-call-operand:end: -12969 # . restore registers -12970 5e/pop-to-esi -12971 59/pop-to-ecx -12972 58/pop-to-eax -12973 # . epilogue -12974 89/<- %esp 5/r32/ebp -12975 5d/pop-to-ebp -12976 c3/return -12977 -12978 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) -12979 # . prologue -12980 55/push-ebp -12981 89/<- %ebp 4/r32/esp -12982 # . save registers -12983 50/push-eax -12984 51/push-ecx -12985 56/push-esi -12986 # esi = v -12987 8b/-> *(ebp+0xc) 6/r32/esi -12988 # var size/ecx: int = size-of-deref(v) -12989 (size-of-deref %esi) # => eax -12990 89/<- %ecx 0/r32/eax -12991 # var reg-name/esi: (addr array byte) = lookup(v->register) -12992 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -12993 89/<- %esi 0/r32/eax -12994 # TODO: assert size is a multiple of 4 -12995 # var i/eax: int = 0 -12996 b8/copy-to-eax 0/imm32 -12997 { -12998 $emit-subx-call-operand-register-indirect:loop: -12999 # if (i >= size) break -13000 39/compare %eax 1/r32/ecx -13001 7d/jump-if->= break/disp8 -13002 # emit " *(" v->register "+" i ")" -13003 (write-buffered *(ebp+8) " *(") -13004 (write-buffered *(ebp+8) %esi) -13005 (write-buffered *(ebp+8) "+") -13006 (print-int32-buffered *(ebp+8) %eax) -13007 (write-buffered *(ebp+8) ")") -13008 # i += 4 -13009 05/add-to-eax 4/imm32 -13010 # -13011 eb/jump loop/disp8 -13012 } -13013 $emit-subx-call-operand-register-indirect:end: -13014 # . restore registers -13015 5e/pop-to-esi -13016 59/pop-to-ecx -13017 58/pop-to-eax -13018 # . epilogue -13019 89/<- %esp 5/r32/ebp -13020 5d/pop-to-ebp -13021 c3/return -13022 -13023 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) -13024 # . prologue -13025 55/push-ebp -13026 89/<- %ebp 4/r32/esp -13027 # . save registers -13028 50/push-eax -13029 51/push-ecx -13030 56/push-esi -13031 # esi = v -13032 8b/-> *(ebp+0xc) 6/r32/esi -13033 # var curr/ecx: int = v->offset -13034 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset -13035 # var max/eax: int = v->offset + size-of(v) -13036 (size-of %esi) # => eax -13037 # TODO: assert size is a multiple of 4 -13038 01/add-to %eax 1/r32/ecx -13039 { -13040 $emit-subx-call-operand-stack:loop: -13041 # if (curr >= max) break -13042 39/compare %ecx 0/r32/eax -13043 7d/jump-if->= break/disp8 -13044 # emit " *(ebp+" curr ")" -13045 (write-buffered *(ebp+8) " *(ebp+") -13046 (print-int32-buffered *(ebp+8) %ecx) -13047 (write-buffered *(ebp+8) ")") -13048 # i += 4 -13049 81 0/subop/add %ecx 4/imm32 -13050 # -13051 eb/jump loop/disp8 -13052 } -13053 $emit-subx-call-operand-stack:end: -13054 # . restore registers -13055 5e/pop-to-esi -13056 59/pop-to-ecx -13057 58/pop-to-eax -13058 # . epilogue -13059 89/<- %esp 5/r32/ebp -13060 5d/pop-to-ebp -13061 c3/return -13062 -13063 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) -13064 # . prologue -13065 55/push-ebp -13066 89/<- %ebp 4/r32/esp -13067 # . save registers -13068 50/push-eax -13069 51/push-ecx -13070 56/push-esi -13071 # ecx = s -13072 8b/-> *(ebp+0xc) 1/r32/ecx -13073 # var operand/esi: (addr var) = lookup(s->value) -13074 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -13075 89/<- %esi 0/r32/eax -13076 # if (operand->register && s->is-deref?) emit "*__" -13077 { -13078 $emit-subx-var-as-rm32:check-for-register-indirect: -13079 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -13080 74/jump-if-= break/disp8 -13081 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -13082 74/jump-if-= break/disp8 -13083 $emit-subx-var-as-rm32:register-indirect: -13084 (write-buffered *(ebp+8) " *") -13085 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -13086 (write-buffered *(ebp+8) %eax) -13087 e9/jump $emit-subx-var-as-rm32:end/disp32 -13088 } -13089 # if (operand->register && !s->is-deref?) emit "%__" -13090 { -13091 $emit-subx-var-as-rm32:check-for-register-direct: -13092 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -13093 74/jump-if-= break/disp8 -13094 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -13095 75/jump-if-!= break/disp8 -13096 $emit-subx-var-as-rm32:register-direct: -13097 (write-buffered *(ebp+8) " %") -13098 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -13099 (write-buffered *(ebp+8) %eax) -13100 e9/jump $emit-subx-var-as-rm32:end/disp32 -13101 } -13102 # else if (operand->stack-offset) emit "*(ebp+__)" -13103 { -13104 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -13105 74/jump-if-= break/disp8 -13106 $emit-subx-var-as-rm32:stack: -13107 (write-buffered *(ebp+8) Space) -13108 (write-buffered *(ebp+8) "*(ebp+") -13109 (print-int32-buffered *(ebp+8) *(esi+0x14)) # Var-offset -13110 (write-buffered *(ebp+8) ")") -13111 } -13112 $emit-subx-var-as-rm32:end: -13113 # . restore registers -13114 5e/pop-to-esi -13115 59/pop-to-ecx -13116 58/pop-to-eax -13117 # . epilogue -13118 89/<- %esp 5/r32/ebp -13119 5d/pop-to-ebp -13120 c3/return -13121 -13122 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) -13123 # . prologue -13124 55/push-ebp -13125 89/<- %ebp 4/r32/esp -13126 # . save registers -13127 51/push-ecx -13128 # var curr/ecx: (addr primitive) = primitives -13129 8b/-> *(ebp+8) 1/r32/ecx -13130 { -13131 $find-matching-primitive:loop: -13132 # if (curr == null) break -13133 81 7/subop/compare %ecx 0/imm32 -13134 0f 84/jump-if-= break/disp32 -13135 # if match(curr, stmt) return curr -13136 { -13137 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax -13138 3d/compare-eax-and 0/imm32/false -13139 74/jump-if-= break/disp8 -13140 89/<- %eax 1/r32/ecx -13141 eb/jump $find-matching-primitive:end/disp8 -13142 } -13143 $find-matching-primitive:next-primitive: -13144 # curr = curr->next -13145 (lookup *(ecx+0x34) *(ecx+0x38)) # Primitive-next Primitive-next => eax -13146 89/<- %ecx 0/r32/eax -13147 # -13148 e9/jump loop/disp32 -13149 } -13150 # return null -13151 b8/copy-to-eax 0/imm32 -13152 $find-matching-primitive:end: -13153 # . restore registers -13154 59/pop-to-ecx -13155 # . epilogue -13156 89/<- %esp 5/r32/ebp -13157 5d/pop-to-ebp -13158 c3/return -13159 -13160 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean -13161 # A mu stmt matches a primitive if the name matches, all the inout vars -13162 # match, and all the output vars match. -13163 # Vars match if types match and registers match. -13164 # In addition, a stmt output matches a primitive's output if types match -13165 # and the primitive has a wildcard register. -13166 # . prologue -13167 55/push-ebp -13168 89/<- %ebp 4/r32/esp -13169 # . save registers -13170 51/push-ecx -13171 52/push-edx -13172 53/push-ebx -13173 56/push-esi -13174 57/push-edi -13175 # ecx = stmt -13176 8b/-> *(ebp+8) 1/r32/ecx -13177 # edx = primitive -13178 8b/-> *(ebp+0xc) 2/r32/edx -13179 { -13180 $mu-stmt-matches-primitive?:check-name: -13181 # if (primitive->name != stmt->operation) return false -13182 # . var esi: (addr array byte) = lookup(stmt->operation) -13183 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -13184 89/<- %esi 0/r32/eax -13185 # . var edi: (addr array byte) = lookup(primitive->name) -13186 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax -13187 89/<- %edi 0/r32/eax -13188 (string-equal? %esi %edi) # => eax -13189 3d/compare-eax-and 0/imm32/false -13190 75/jump-if-!= break/disp8 -13191 b8/copy-to-eax 0/imm32 -13192 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13193 } -13194 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) -13195 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -13196 89/<- %esi 0/r32/eax -13197 # var curr2/edi: (addr list var) = lookup(primitive->inouts) -13198 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax -13199 89/<- %edi 0/r32/eax -13200 { -13201 $mu-stmt-matches-primitive?:inouts-loop: -13202 # if (curr == 0 && curr2 == 0) move on to check outputs -13203 { -13204 $mu-stmt-matches-primitive?:check-both-inouts-null: -13205 81 7/subop/compare %esi 0/imm32 -13206 75/jump-if-!= break/disp8 -13207 $mu-stmt-matches-primitive?:stmt-inout-null: -13208 81 7/subop/compare %edi 0/imm32 -13209 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 -13210 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: -13211 # return false -13212 b8/copy-to-eax 0/imm32/false -13213 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13214 } -13215 # if (curr2 == 0) return false -13216 { -13217 $mu-stmt-matches-primitive?:check-prim-inout-null: -13218 81 7/subop/compare %edi 0/imm32 -13219 75/jump-if-!= break/disp8 -13220 $mu-stmt-matches-primitive?:prim-inout-null: -13221 b8/copy-to-eax 0/imm32/false -13222 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13223 } -13224 # if (curr != curr2) return false -13225 { -13226 $mu-stmt-matches-primitive?:check-inouts-match: -13227 (lookup *edi *(edi+4)) # List-value List-value => eax -13228 (operand-matches-primitive? %esi %eax) # => eax -13229 3d/compare-eax-and 0/imm32/false -13230 75/jump-if-!= break/disp8 -13231 $mu-stmt-matches-primitive?:inouts-match: -13232 b8/copy-to-eax 0/imm32/false -13233 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13234 } -13235 $mu-stmt-matches-primitive?:next-inout: -13236 # curr = lookup(curr->next) -13237 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -13238 89/<- %esi 0/r32/eax -13239 # curr2 = lookup(curr2->next) -13240 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -13241 89/<- %edi 0/r32/eax -13242 # -13243 e9/jump loop/disp32 -13244 } -13245 $mu-stmt-matches-primitive?:check-outputs: -13246 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) -13247 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -13248 89/<- %esi 0/r32/eax -13249 # var curr2/edi: (addr list var) = lookup(primitive->outputs) -13250 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax -13251 89/<- %edi 0/r32/eax -13252 { -13253 $mu-stmt-matches-primitive?:outputs-loop: -13254 # if (curr == 0) return (curr2 == 0) -13255 { -13256 $mu-stmt-matches-primitive?:check-both-outputs-null: -13257 81 7/subop/compare %esi 0/imm32 -13258 75/jump-if-!= break/disp8 -13259 { -13260 $mu-stmt-matches-primitive?:stmt-output-null: -13261 81 7/subop/compare %edi 0/imm32 -13262 75/jump-if-!= break/disp8 -13263 $mu-stmt-matches-primitive?:both-outputs-null: -13264 # return true -13265 b8/copy-to-eax 1/imm32 -13266 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13267 } -13268 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: -13269 # return false -13270 b8/copy-to-eax 0/imm32 -13271 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13272 } -13273 # if (curr2 == 0) return false -13274 { -13275 $mu-stmt-matches-primitive?:check-prim-output-null: -13276 81 7/subop/compare %edi 0/imm32 -13277 75/jump-if-!= break/disp8 -13278 $mu-stmt-matches-primitive?:prim-output-is-null: -13279 b8/copy-to-eax 0/imm32 -13280 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13281 } -13282 # if (curr != curr2) return false -13283 { -13284 $mu-stmt-matches-primitive?:check-outputs-match: -13285 (lookup *edi *(edi+4)) # List-value List-value => eax -13286 (operand-matches-primitive? %esi %eax) # => eax -13287 3d/compare-eax-and 0/imm32/false -13288 75/jump-if-!= break/disp8 -13289 $mu-stmt-matches-primitive?:outputs-match: -13290 b8/copy-to-eax 0/imm32 -13291 e9/jump $mu-stmt-matches-primitive?:end/disp32 -13292 } -13293 $mu-stmt-matches-primitive?:next-output: -13294 # curr = lookup(curr->next) -13295 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -13296 89/<- %esi 0/r32/eax -13297 # curr2 = lookup(curr2->next) -13298 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -13299 89/<- %edi 0/r32/eax -13300 # -13301 e9/jump loop/disp32 -13302 } -13303 $mu-stmt-matches-primitive?:return-true: -13304 b8/copy-to-eax 1/imm32 -13305 $mu-stmt-matches-primitive?:end: -13306 # . restore registers -13307 5f/pop-to-edi -13308 5e/pop-to-esi -13309 5b/pop-to-ebx -13310 5a/pop-to-edx -13311 59/pop-to-ecx -13312 # . epilogue -13313 89/<- %esp 5/r32/ebp -13314 5d/pop-to-ebp -13315 c3/return -13316 -13317 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean -13318 # . prologue -13319 55/push-ebp -13320 89/<- %ebp 4/r32/esp -13321 # . save registers -13322 51/push-ecx -13323 52/push-edx -13324 53/push-ebx -13325 56/push-esi -13326 57/push-edi -13327 # ecx = s -13328 8b/-> *(ebp+8) 1/r32/ecx -13329 # var var/esi: (addr var) = lookup(s->value) -13330 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -13331 89/<- %esi 0/r32/eax -13332 # edi = prim-var -13333 8b/-> *(ebp+0xc) 7/r32/edi -13334 $operand-matches-primitive?:check-type: -13335 # if (var->type != prim-var->type) return false -13336 # . var vtype/ebx: (addr tree type-id) = lookup(var->type) -13337 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -13338 89/<- %ebx 0/r32/eax -13339 # . var ptype/eax: (addr tree type-id) = lookup(prim-var->type) -13340 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -13341 (subx-type-equal? %ebx %eax) # => eax -13342 3d/compare-eax-and 0/imm32/false -13343 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 -13344 { -13345 $operand-matches-primitive?:check-register: -13346 # if prim-var is in memory and var is in register but dereference, match -13347 { -13348 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -13349 0f 85/jump-if-!= break/disp32 -13350 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -13351 74/jump-if-= break/disp8 -13352 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -13353 74/jump-if-= break/disp8 -13354 $operand-matches-primitive?:var-deref-match: -13355 e9/jump $operand-matches-primitive?:return-true/disp32 -13356 } -13357 # if prim-var is in register and var is in register but dereference, no match -13358 { -13359 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -13360 0f 84/jump-if-= break/disp32 -13361 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -13362 0f 84/jump-if-= break/disp32 -13363 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -13364 74/jump-if-= break/disp8 -13365 $operand-matches-primitive?:var-deref-no-match: -13366 e9/jump $operand-matches-primitive?:return-false/disp32 -13367 } -13368 # return false if var->register doesn't match prim-var->register -13369 { -13370 # if register addresses are equal, it's a match -13371 # var vreg/ebx: (addr array byte) = lookup(var->register) -13372 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -13373 89/<- %ebx 0/r32/eax -13374 # var preg/ecx: (addr array byte) = lookup(prim-var->register) -13375 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -13376 89/<- %ecx 0/r32/eax -13377 # if (vreg == preg) break -13378 39/compare %ecx 3/r32/ebx -13379 74/jump-if-= break/disp8 -13380 $operand-matches-primitive?:var-register-no-match: -13381 # if either address is 0, return false -13382 81 7/subop/compare %ebx 0/imm32 -13383 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -13384 81 7/subop/compare %ecx 0/imm32 -13385 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -13386 # if prim-var->register is wildcard, it's a match -13387 (string-equal? %ecx "*") # Any-register => eax -13388 3d/compare-eax-and 0/imm32/false -13389 75/jump-if-!= break/disp8 -13390 $operand-matches-primitive?:wildcard-no-match: -13391 # if string contents aren't equal, return false -13392 (string-equal? %ecx %ebx) # => eax -13393 3d/compare-eax-and 0/imm32/false -13394 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -13395 } -13396 } -13397 $operand-matches-primitive?:return-true: -13398 b8/copy-to-eax 1/imm32/true -13399 eb/jump $operand-matches-primitive?:end/disp8 -13400 $operand-matches-primitive?:return-false: -13401 b8/copy-to-eax 0/imm32/false -13402 $operand-matches-primitive?:end: -13403 # . restore registers -13404 5f/pop-to-edi -13405 5e/pop-to-esi -13406 5b/pop-to-ebx -13407 5a/pop-to-edx -13408 59/pop-to-ecx -13409 # . epilogue -13410 89/<- %esp 5/r32/ebp -13411 5d/pop-to-ebp -13412 c3/return -13413 -13414 subx-type-equal?: # a: (addr tree type-id), b: (addr tree type-id) -> result/eax: boolean -13415 # . prologue -13416 55/push-ebp -13417 89/<- %ebp 4/r32/esp -13418 # . save registers -13419 51/push-ecx -13420 # var alit/ecx: boolean = is-literal-type?(a) -13421 (is-simple-mu-type? *(ebp+8) 0) # => eax -13422 89/<- %ecx 0/r32/eax -13423 # var blit/eax: boolean = is-literal-type?(b) -13424 (is-simple-mu-type? *(ebp+0xc) 0) # => eax -13425 # return alit == blit -13426 39/compare %eax 1/r32/ecx -13427 0f 94/set-byte-if-= %al -13428 81 4/subop/and %eax 0xff/imm32 -13429 $subx-type-equal?:end: -13430 # . restore registers -13431 59/pop-to-ecx -13432 # . epilogue -13433 89/<- %esp 5/r32/ebp -13434 5d/pop-to-ebp -13435 c3/return -13436 -13437 is-simple-mu-type?: # a: (addr tree type-id), n: type-id -> result/eax: boolean -13438 # . prologue -13439 55/push-ebp -13440 89/<- %ebp 4/r32/esp -13441 # . save registers -13442 51/push-ecx -13443 # ecx = n -13444 8b/-> *(ebp+0xc) 1/r32/ecx -13445 # return (a->value == n) -13446 8b/-> *(ebp+8) 0/r32/eax -13447 39/compare *(eax+4) 1/r32/ecx # Tree-value -13448 0f 94/set-byte-if-= %al -13449 81 4/subop/and %eax 0xff/imm32 -13450 $is-simple-mu-type?:end: -13451 # . restore registers -13452 59/pop-to-ecx -13453 # . epilogue -13454 89/<- %esp 5/r32/ebp -13455 5d/pop-to-ebp -13456 c3/return -13457 -13458 test-emit-subx-stmt-primitive: -13459 # Primitive operation on a variable on the stack. -13460 # increment foo -13461 # => -13462 # ff 0/subop/increment *(ebp-8) -13463 # -13464 # There's a variable on the var stack as follows: -13465 # name: 'foo' -13466 # type: int -13467 # stack-offset: -8 -13468 # -13469 # There's a primitive with this info: -13470 # name: 'increment' -13471 # inouts: int/mem -13472 # value: 'ff 0/subop/increment' -13473 # -13474 # . prologue -13475 55/push-ebp -13476 89/<- %ebp 4/r32/esp -13477 # setup -13478 (clear-stream _test-output-stream) -13479 (clear-stream $_test-output-buffered-file->buffer) -13480 # simulate allocated payloads starting with an initial fake alloc-id (0x11) -13481 $test-emit-subx-stmt-primitive:initialize-type: -13482 # var type/ecx: (payload tree type-id) = int -13483 68/push 0/imm32/right:null -13484 68/push 0/imm32/right:null -13485 68/push 0/imm32/left:unused -13486 68/push 1/imm32/value:int -13487 68/push 1/imm32/is-atom?:true -13488 68/push 0x11/imm32/alloc-id:fake:payload -13489 89/<- %ecx 4/r32/esp -13490 $test-emit-subx-stmt-primitive:initialize-var: -13491 # var var-foo/ecx: (payload var) = var(type) -13492 68/push 0/imm32/no-register -13493 68/push 0/imm32/no-register -13494 68/push -8/imm32/stack-offset -13495 68/push 1/imm32/block-depth -13496 51/push-ecx/type -13497 68/push 0x11/imm32/alloc-id:fake -13498 68/push 0/imm32/name -13499 68/push 0/imm32/name -13500 68/push 0x11/imm32/alloc-id:fake:payload -13501 89/<- %ecx 4/r32/esp -13502 $test-emit-subx-stmt-primitive:initialize-var-name: -13503 # var-foo->name = "foo" -13504 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -13505 (copy-array Heap "foo" %eax) -13506 $test-emit-subx-stmt-primitive:initialize-stmt-var: -13507 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -13508 68/push 0/imm32/is-deref:false -13509 68/push 0/imm32/next -13510 68/push 0/imm32/next -13511 51/push-ecx/var-foo -13512 68/push 0x11/imm32/alloc-id:fake -13513 68/push 0x11/imm32/alloc-id:fake:payload -13514 89/<- %ebx 4/r32/esp -13515 $test-emit-subx-stmt-primitive:initialize-stmt: -13516 # var stmt/esi: (addr statement) -13517 68/push 0/imm32/no-outputs -13518 68/push 0/imm32/no-outputs -13519 53/push-ebx/inouts -13520 68/push 0x11/imm32/alloc-id:fake -13521 68/push 0/imm32/operation -13522 68/push 0/imm32/operation -13523 68/push 1/imm32/tag -13524 89/<- %esi 4/r32/esp -13525 $test-emit-subx-stmt-primitive:initialize-stmt-operation: -13526 # stmt->operation = "increment" -13527 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -13528 (copy-array Heap "increment" %eax) -13529 $test-emit-subx-stmt-primitive:initialize-primitive: -13530 # var primitives/ebx: (addr primitive) -13531 68/push 0/imm32/next -13532 68/push 0/imm32/next -13533 68/push 0/imm32/output-is-write-only -13534 68/push 0/imm32/no-disp32 -13535 68/push 0/imm32/no-imm32 -13536 68/push 0/imm32/no-r32 -13537 68/push 1/imm32/rm32-is-first-inout -13538 68/push 0/imm32/subx-name -13539 68/push 0/imm32/subx-name -13540 68/push 0/imm32/no-outputs -13541 68/push 0/imm32/no-outputs -13542 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -13543 68/push 0x11/imm32/alloc-id:fake -13544 68/push 0/imm32/name -13545 68/push 0/imm32/name -13546 89/<- %ebx 4/r32/esp -13547 $test-emit-subx-stmt-primitive:initialize-primitive-name: -13548 # primitives->name = "increment" -13549 (copy-array Heap "increment" %ebx) # Primitive-name -13550 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: -13551 # primitives->subx-name = "ff 0/subop/increment" -13552 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -13553 (copy-array Heap "ff 0/subop/increment" %eax) -13554 # convert -13555 c7 0/subop/copy *Curr-block-depth 0/imm32 -13556 (emit-subx-stmt _test-output-buffered-file %esi %ebx) -13557 (flush _test-output-buffered-file) -13558 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -13564 # check output -13565 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") -13566 # . epilogue -13567 89/<- %esp 5/r32/ebp -13568 5d/pop-to-ebp -13569 c3/return -13570 -13571 test-emit-subx-stmt-primitive-register: -13572 # Primitive operation on a variable in a register. -13573 # foo <- increment -13574 # => -13575 # ff 0/subop/increment %eax # sub-optimal, but should suffice -13576 # -13577 # There's a variable on the var stack as follows: -13578 # name: 'foo' -13579 # type: int -13580 # register: 'eax' -13581 # -13582 # There's a primitive with this info: -13583 # name: 'increment' -13584 # out: int/reg -13585 # value: 'ff 0/subop/increment' -13586 # -13587 # . prologue -13588 55/push-ebp -13589 89/<- %ebp 4/r32/esp -13590 # setup -13591 (clear-stream _test-output-stream) -13592 (clear-stream $_test-output-buffered-file->buffer) -13593 $test-emit-subx-stmt-primitive-register:initialize-type: -13594 # var type/ecx: (payload tree type-id) = int -13595 68/push 0/imm32/right:null -13596 68/push 0/imm32/right:null -13597 68/push 0/imm32/left:unused -13598 68/push 1/imm32/value:int -13599 68/push 1/imm32/is-atom?:true -13600 68/push 0x11/imm32/alloc-id:fake:payload -13601 89/<- %ecx 4/r32/esp -13602 $test-emit-subx-stmt-primitive-register:initialize-var: -13603 # var var-foo/ecx: (payload var) -13604 68/push 0/imm32/register -13605 68/push 0/imm32/register -13606 68/push 0/imm32/no-stack-offset -13607 68/push 1/imm32/block-depth -13608 51/push-ecx -13609 68/push 0x11/imm32/alloc-id:fake -13610 68/push 0/imm32/name -13611 68/push 0/imm32/name -13612 68/push 0x11/imm32/alloc-id:fake:payload -13613 89/<- %ecx 4/r32/esp -13614 $test-emit-subx-stmt-primitive-register:initialize-var-name: -13615 # var-foo->name = "foo" -13616 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -13617 (copy-array Heap "foo" %eax) -13618 $test-emit-subx-stmt-primitive-register:initialize-var-register: -13619 # var-foo->register = "eax" -13620 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -13621 (copy-array Heap "eax" %eax) -13622 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: -13623 # var operand/ebx: (payload stmt-var) -13624 68/push 0/imm32/is-deref:false -13625 68/push 0/imm32/next -13626 68/push 0/imm32/next -13627 51/push-ecx/var-foo -13628 68/push 0x11/imm32/alloc-id:fake -13629 68/push 0x11/imm32/alloc-id:fake:payload -13630 89/<- %ebx 4/r32/esp -13631 $test-emit-subx-stmt-primitive-register:initialize-stmt: -13632 # var stmt/esi: (addr statement) -13633 53/push-ebx/outputs -13634 68/push 0x11/imm32/alloc-id:fake -13635 68/push 0/imm32/no-inouts -13636 68/push 0/imm32/no-inouts -13637 68/push 0/imm32/operation -13638 68/push 0/imm32/operation -13639 68/push 1/imm32 -13640 89/<- %esi 4/r32/esp -13641 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: -13642 # stmt->operation = "increment" -13643 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -13644 (copy-array Heap "increment" %eax) -13645 $test-emit-subx-stmt-primitive-register:initialize-formal-var: -13646 # var formal-var/ebx: (payload var) -13647 68/push 0/imm32/register -13648 68/push 0/imm32/register -13649 68/push 0/imm32/no-stack-offset -13650 68/push 1/imm32/block-depth -13651 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -13652 68/push 0x11/imm32/alloc-id:fake -13653 68/push 0/imm32/name -13654 68/push 0/imm32/name -13655 68/push 0x11/imm32/alloc-id:fake:payload -13656 89/<- %ebx 4/r32/esp -13657 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: -13658 # formal-var->name = "dummy" -13659 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -13660 (copy-array Heap "dummy" %eax) -13661 $test-emit-subx-stmt-primitive-register:initialize-formal-register: -13662 # formal-var->register = "*" -13663 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -13664 (copy-array Heap "*" %eax) # Any-register -13665 $test-emit-subx-stmt-primitive-register:initialize-var-list: -13666 # var formal-outputs/ebx: (payload list var) -13667 68/push 0/imm32/next -13668 68/push 0/imm32/next -13669 53/push-ebx/formal-var -13670 68/push 0x11/imm32/alloc-id:fake -13671 68/push 0x11/imm32/alloc-id:fake:payload -13672 89/<- %ebx 4/r32/esp -13673 $test-emit-subx-stmt-primitive-register:initialize-primitive: -13674 # var primitives/ebx: (addr primitive) +12863 # hack: if instruction operation starts with "loop", emit ":loop" +12864 { +12865 (string-starts-with? %ecx "loop") # => eax +12866 3d/compare-eax-and 0/imm32/false +12867 74/jump-if-= break/disp8 +12868 (write-buffered *(ebp+8) ":loop") +12869 } +12870 (write-buffered *(ebp+8) "/disp32") +12871 $emit-subx-disp32:end: +12872 # . restore registers +12873 59/pop-to-ecx +12874 58/pop-to-eax +12875 # . epilogue +12876 89/<- %esp 5/r32/ebp +12877 5d/pop-to-ebp +12878 c3/return +12879 +12880 emit-call: # out: (addr buffered-file), stmt: (addr stmt) +12881 # . prologue +12882 55/push-ebp +12883 89/<- %ebp 4/r32/esp +12884 # . save registers +12885 50/push-eax +12886 51/push-ecx +12887 # +12888 (emit-indent *(ebp+8) *Curr-block-depth) +12889 (write-buffered *(ebp+8) "(") +12890 # ecx = stmt +12891 8b/-> *(ebp+0xc) 1/r32/ecx +12892 # - emit function name +12893 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +12894 (write-buffered *(ebp+8) %eax) +12895 # - emit arguments +12896 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) +12897 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +12898 { +12899 # if (curr == null) break +12900 3d/compare-eax-and 0/imm32 +12901 74/jump-if-= break/disp8 +12902 # +12903 (emit-subx-call-operand *(ebp+8) %eax) +12904 # curr = lookup(curr->next) +12905 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +12906 eb/jump loop/disp8 +12907 } +12908 # +12909 (write-buffered *(ebp+8) ")\n") +12910 $emit-call:end: +12911 # . restore registers +12912 59/pop-to-ecx +12913 58/pop-to-eax +12914 # . epilogue +12915 89/<- %esp 5/r32/ebp +12916 5d/pop-to-ebp +12917 c3/return +12918 +12919 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) +12920 # shares code with emit-subx-var-as-rm32 +12921 # . prologue +12922 55/push-ebp +12923 89/<- %ebp 4/r32/esp +12924 # . save registers +12925 50/push-eax +12926 51/push-ecx +12927 56/push-esi +12928 # ecx = s +12929 8b/-> *(ebp+0xc) 1/r32/ecx +12930 # var operand/esi: (addr var) = lookup(s->value) +12931 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +12932 89/<- %esi 0/r32/eax +12933 # if (operand->register && !s->is-deref?) emit "%__" +12934 { +12935 $emit-subx-call-operand:check-for-register-direct: +12936 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +12937 74/jump-if-= break/disp8 +12938 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +12939 75/jump-if-!= break/disp8 +12940 $emit-subx-call-operand:register-direct: +12941 (write-buffered *(ebp+8) " %") +12942 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +12943 (write-buffered *(ebp+8) %eax) +12944 e9/jump $emit-subx-call-operand:end/disp32 +12945 } +12946 # else if (operand->register && s->is-deref?) emit "*__" +12947 { +12948 $emit-subx-call-operand:check-for-register-indirect: +12949 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +12950 74/jump-if-= break/disp8 +12951 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +12952 74/jump-if-= break/disp8 +12953 $emit-subx-call-operand:register-indirect: +12954 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) +12955 e9/jump $emit-subx-call-operand:end/disp32 +12956 } +12957 # else if (operand->stack-offset) emit "*(ebp+__)" +12958 { +12959 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +12960 74/jump-if-= break/disp8 +12961 $emit-subx-call-operand:stack: +12962 (emit-subx-call-operand-stack *(ebp+8) %esi) +12963 e9/jump $emit-subx-call-operand:end/disp32 +12964 } +12965 # else if (operand->type == literal) emit "__" +12966 { +12967 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +12968 81 7/subop/compare *(eax+4) 0/imm32 # Tree-left +12969 75/jump-if-!= break/disp8 +12970 $emit-subx-call-operand:literal: +12971 (write-buffered *(ebp+8) Space) +12972 (lookup *esi *(esi+4)) # Var-name Var-name => eax +12973 (write-buffered *(ebp+8) %eax) +12974 } +12975 $emit-subx-call-operand:end: +12976 # . restore registers +12977 5e/pop-to-esi +12978 59/pop-to-ecx +12979 58/pop-to-eax +12980 # . epilogue +12981 89/<- %esp 5/r32/ebp +12982 5d/pop-to-ebp +12983 c3/return +12984 +12985 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) +12986 # . prologue +12987 55/push-ebp +12988 89/<- %ebp 4/r32/esp +12989 # . save registers +12990 50/push-eax +12991 51/push-ecx +12992 56/push-esi +12993 # esi = v +12994 8b/-> *(ebp+0xc) 6/r32/esi +12995 # var size/ecx: int = size-of-deref(v) +12996 (size-of-deref %esi) # => eax +12997 89/<- %ecx 0/r32/eax +12998 # var reg-name/esi: (addr array byte) = lookup(v->register) +12999 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +13000 89/<- %esi 0/r32/eax +13001 # TODO: assert size is a multiple of 4 +13002 # var i/eax: int = 0 +13003 b8/copy-to-eax 0/imm32 +13004 { +13005 $emit-subx-call-operand-register-indirect:loop: +13006 # if (i >= size) break +13007 39/compare %eax 1/r32/ecx +13008 7d/jump-if->= break/disp8 +13009 # emit " *(" v->register "+" i ")" +13010 (write-buffered *(ebp+8) " *(") +13011 (write-buffered *(ebp+8) %esi) +13012 (write-buffered *(ebp+8) "+") +13013 (print-int32-buffered *(ebp+8) %eax) +13014 (write-buffered *(ebp+8) ")") +13015 # i += 4 +13016 05/add-to-eax 4/imm32 +13017 # +13018 eb/jump loop/disp8 +13019 } +13020 $emit-subx-call-operand-register-indirect:end: +13021 # . restore registers +13022 5e/pop-to-esi +13023 59/pop-to-ecx +13024 58/pop-to-eax +13025 # . epilogue +13026 89/<- %esp 5/r32/ebp +13027 5d/pop-to-ebp +13028 c3/return +13029 +13030 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) +13031 # . prologue +13032 55/push-ebp +13033 89/<- %ebp 4/r32/esp +13034 # . save registers +13035 50/push-eax +13036 51/push-ecx +13037 56/push-esi +13038 # esi = v +13039 8b/-> *(ebp+0xc) 6/r32/esi +13040 # var curr/ecx: int = v->offset +13041 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset +13042 # var max/eax: int = v->offset + size-of(v) +13043 (size-of %esi) # => eax +13044 # TODO: assert size is a multiple of 4 +13045 01/add-to %eax 1/r32/ecx +13046 { +13047 $emit-subx-call-operand-stack:loop: +13048 # if (curr >= max) break +13049 39/compare %ecx 0/r32/eax +13050 7d/jump-if->= break/disp8 +13051 # emit " *(ebp+" curr ")" +13052 (write-buffered *(ebp+8) " *(ebp+") +13053 (print-int32-buffered *(ebp+8) %ecx) +13054 (write-buffered *(ebp+8) ")") +13055 # i += 4 +13056 81 0/subop/add %ecx 4/imm32 +13057 # +13058 eb/jump loop/disp8 +13059 } +13060 $emit-subx-call-operand-stack:end: +13061 # . restore registers +13062 5e/pop-to-esi +13063 59/pop-to-ecx +13064 58/pop-to-eax +13065 # . epilogue +13066 89/<- %esp 5/r32/ebp +13067 5d/pop-to-ebp +13068 c3/return +13069 +13070 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) +13071 # . prologue +13072 55/push-ebp +13073 89/<- %ebp 4/r32/esp +13074 # . save registers +13075 50/push-eax +13076 51/push-ecx +13077 56/push-esi +13078 # ecx = s +13079 8b/-> *(ebp+0xc) 1/r32/ecx +13080 # var operand/esi: (addr var) = lookup(s->value) +13081 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +13082 89/<- %esi 0/r32/eax +13083 # if (operand->register && s->is-deref?) emit "*__" +13084 { +13085 $emit-subx-var-as-rm32:check-for-register-indirect: +13086 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +13087 74/jump-if-= break/disp8 +13088 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +13089 74/jump-if-= break/disp8 +13090 $emit-subx-var-as-rm32:register-indirect: +13091 (write-buffered *(ebp+8) " *") +13092 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +13093 (write-buffered *(ebp+8) %eax) +13094 e9/jump $emit-subx-var-as-rm32:end/disp32 +13095 } +13096 # if (operand->register && !s->is-deref?) emit "%__" +13097 { +13098 $emit-subx-var-as-rm32:check-for-register-direct: +13099 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +13100 74/jump-if-= break/disp8 +13101 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +13102 75/jump-if-!= break/disp8 +13103 $emit-subx-var-as-rm32:register-direct: +13104 (write-buffered *(ebp+8) " %") +13105 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +13106 (write-buffered *(ebp+8) %eax) +13107 e9/jump $emit-subx-var-as-rm32:end/disp32 +13108 } +13109 # else if (operand->stack-offset) emit "*(ebp+__)" +13110 { +13111 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +13112 74/jump-if-= break/disp8 +13113 $emit-subx-var-as-rm32:stack: +13114 (write-buffered *(ebp+8) Space) +13115 (write-buffered *(ebp+8) "*(ebp+") +13116 (print-int32-buffered *(ebp+8) *(esi+0x14)) # Var-offset +13117 (write-buffered *(ebp+8) ")") +13118 } +13119 $emit-subx-var-as-rm32:end: +13120 # . restore registers +13121 5e/pop-to-esi +13122 59/pop-to-ecx +13123 58/pop-to-eax +13124 # . epilogue +13125 89/<- %esp 5/r32/ebp +13126 5d/pop-to-ebp +13127 c3/return +13128 +13129 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) +13130 # . prologue +13131 55/push-ebp +13132 89/<- %ebp 4/r32/esp +13133 # . save registers +13134 51/push-ecx +13135 # var curr/ecx: (addr primitive) = primitives +13136 8b/-> *(ebp+8) 1/r32/ecx +13137 { +13138 $find-matching-primitive:loop: +13139 # if (curr == null) break +13140 81 7/subop/compare %ecx 0/imm32 +13141 0f 84/jump-if-= break/disp32 +13142 # if match(curr, stmt) return curr +13143 { +13144 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax +13145 3d/compare-eax-and 0/imm32/false +13146 74/jump-if-= break/disp8 +13147 89/<- %eax 1/r32/ecx +13148 eb/jump $find-matching-primitive:end/disp8 +13149 } +13150 $find-matching-primitive:next-primitive: +13151 # curr = curr->next +13152 (lookup *(ecx+0x34) *(ecx+0x38)) # Primitive-next Primitive-next => eax +13153 89/<- %ecx 0/r32/eax +13154 # +13155 e9/jump loop/disp32 +13156 } +13157 # return null +13158 b8/copy-to-eax 0/imm32 +13159 $find-matching-primitive:end: +13160 # . restore registers +13161 59/pop-to-ecx +13162 # . epilogue +13163 89/<- %esp 5/r32/ebp +13164 5d/pop-to-ebp +13165 c3/return +13166 +13167 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean +13168 # A mu stmt matches a primitive if the name matches, all the inout vars +13169 # match, and all the output vars match. +13170 # Vars match if types match and registers match. +13171 # In addition, a stmt output matches a primitive's output if types match +13172 # and the primitive has a wildcard register. +13173 # . prologue +13174 55/push-ebp +13175 89/<- %ebp 4/r32/esp +13176 # . save registers +13177 51/push-ecx +13178 52/push-edx +13179 53/push-ebx +13180 56/push-esi +13181 57/push-edi +13182 # ecx = stmt +13183 8b/-> *(ebp+8) 1/r32/ecx +13184 # edx = primitive +13185 8b/-> *(ebp+0xc) 2/r32/edx +13186 { +13187 $mu-stmt-matches-primitive?:check-name: +13188 # if (primitive->name != stmt->operation) return false +13189 # . var esi: (addr array byte) = lookup(stmt->operation) +13190 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +13191 89/<- %esi 0/r32/eax +13192 # . var edi: (addr array byte) = lookup(primitive->name) +13193 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax +13194 89/<- %edi 0/r32/eax +13195 (string-equal? %esi %edi) # => eax +13196 3d/compare-eax-and 0/imm32/false +13197 75/jump-if-!= break/disp8 +13198 b8/copy-to-eax 0/imm32 +13199 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13200 } +13201 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) +13202 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +13203 89/<- %esi 0/r32/eax +13204 # var curr2/edi: (addr list var) = lookup(primitive->inouts) +13205 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax +13206 89/<- %edi 0/r32/eax +13207 { +13208 $mu-stmt-matches-primitive?:inouts-loop: +13209 # if (curr == 0 && curr2 == 0) move on to check outputs +13210 { +13211 $mu-stmt-matches-primitive?:check-both-inouts-null: +13212 81 7/subop/compare %esi 0/imm32 +13213 75/jump-if-!= break/disp8 +13214 $mu-stmt-matches-primitive?:stmt-inout-null: +13215 81 7/subop/compare %edi 0/imm32 +13216 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 +13217 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: +13218 # return false +13219 b8/copy-to-eax 0/imm32/false +13220 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13221 } +13222 # if (curr2 == 0) return false +13223 { +13224 $mu-stmt-matches-primitive?:check-prim-inout-null: +13225 81 7/subop/compare %edi 0/imm32 +13226 75/jump-if-!= break/disp8 +13227 $mu-stmt-matches-primitive?:prim-inout-null: +13228 b8/copy-to-eax 0/imm32/false +13229 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13230 } +13231 # if (curr != curr2) return false +13232 { +13233 $mu-stmt-matches-primitive?:check-inouts-match: +13234 (lookup *edi *(edi+4)) # List-value List-value => eax +13235 (operand-matches-primitive? %esi %eax) # => eax +13236 3d/compare-eax-and 0/imm32/false +13237 75/jump-if-!= break/disp8 +13238 $mu-stmt-matches-primitive?:inouts-match: +13239 b8/copy-to-eax 0/imm32/false +13240 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13241 } +13242 $mu-stmt-matches-primitive?:next-inout: +13243 # curr = lookup(curr->next) +13244 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +13245 89/<- %esi 0/r32/eax +13246 # curr2 = lookup(curr2->next) +13247 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +13248 89/<- %edi 0/r32/eax +13249 # +13250 e9/jump loop/disp32 +13251 } +13252 $mu-stmt-matches-primitive?:check-outputs: +13253 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) +13254 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +13255 89/<- %esi 0/r32/eax +13256 # var curr2/edi: (addr list var) = lookup(primitive->outputs) +13257 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax +13258 89/<- %edi 0/r32/eax +13259 { +13260 $mu-stmt-matches-primitive?:outputs-loop: +13261 # if (curr == 0) return (curr2 == 0) +13262 { +13263 $mu-stmt-matches-primitive?:check-both-outputs-null: +13264 81 7/subop/compare %esi 0/imm32 +13265 75/jump-if-!= break/disp8 +13266 { +13267 $mu-stmt-matches-primitive?:stmt-output-null: +13268 81 7/subop/compare %edi 0/imm32 +13269 75/jump-if-!= break/disp8 +13270 $mu-stmt-matches-primitive?:both-outputs-null: +13271 # return true +13272 b8/copy-to-eax 1/imm32 +13273 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13274 } +13275 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: +13276 # return false +13277 b8/copy-to-eax 0/imm32 +13278 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13279 } +13280 # if (curr2 == 0) return false +13281 { +13282 $mu-stmt-matches-primitive?:check-prim-output-null: +13283 81 7/subop/compare %edi 0/imm32 +13284 75/jump-if-!= break/disp8 +13285 $mu-stmt-matches-primitive?:prim-output-is-null: +13286 b8/copy-to-eax 0/imm32 +13287 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13288 } +13289 # if (curr != curr2) return false +13290 { +13291 $mu-stmt-matches-primitive?:check-outputs-match: +13292 (lookup *edi *(edi+4)) # List-value List-value => eax +13293 (operand-matches-primitive? %esi %eax) # => eax +13294 3d/compare-eax-and 0/imm32/false +13295 75/jump-if-!= break/disp8 +13296 $mu-stmt-matches-primitive?:outputs-match: +13297 b8/copy-to-eax 0/imm32 +13298 e9/jump $mu-stmt-matches-primitive?:end/disp32 +13299 } +13300 $mu-stmt-matches-primitive?:next-output: +13301 # curr = lookup(curr->next) +13302 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +13303 89/<- %esi 0/r32/eax +13304 # curr2 = lookup(curr2->next) +13305 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +13306 89/<- %edi 0/r32/eax +13307 # +13308 e9/jump loop/disp32 +13309 } +13310 $mu-stmt-matches-primitive?:return-true: +13311 b8/copy-to-eax 1/imm32 +13312 $mu-stmt-matches-primitive?:end: +13313 # . restore registers +13314 5f/pop-to-edi +13315 5e/pop-to-esi +13316 5b/pop-to-ebx +13317 5a/pop-to-edx +13318 59/pop-to-ecx +13319 # . epilogue +13320 89/<- %esp 5/r32/ebp +13321 5d/pop-to-ebp +13322 c3/return +13323 +13324 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean +13325 # . prologue +13326 55/push-ebp +13327 89/<- %ebp 4/r32/esp +13328 # . save registers +13329 51/push-ecx +13330 52/push-edx +13331 53/push-ebx +13332 56/push-esi +13333 57/push-edi +13334 # ecx = s +13335 8b/-> *(ebp+8) 1/r32/ecx +13336 # var var/esi: (addr var) = lookup(s->value) +13337 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +13338 89/<- %esi 0/r32/eax +13339 # edi = prim-var +13340 8b/-> *(ebp+0xc) 7/r32/edi +13341 $operand-matches-primitive?:check-type: +13342 # if (var->type != prim-var->type) return false +13343 # . var vtype/ebx: (addr tree type-id) = lookup(var->type) +13344 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +13345 89/<- %ebx 0/r32/eax +13346 # . var ptype/eax: (addr tree type-id) = lookup(prim-var->type) +13347 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +13348 (subx-type-equal? %ebx %eax) # => eax +13349 3d/compare-eax-and 0/imm32/false +13350 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 +13351 { +13352 $operand-matches-primitive?:check-register: +13353 # if prim-var is in memory and var is in register but dereference, match +13354 { +13355 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +13356 0f 85/jump-if-!= break/disp32 +13357 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +13358 74/jump-if-= break/disp8 +13359 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +13360 74/jump-if-= break/disp8 +13361 $operand-matches-primitive?:var-deref-match: +13362 e9/jump $operand-matches-primitive?:return-true/disp32 +13363 } +13364 # if prim-var is in register and var is in register but dereference, no match +13365 { +13366 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +13367 0f 84/jump-if-= break/disp32 +13368 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +13369 0f 84/jump-if-= break/disp32 +13370 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +13371 74/jump-if-= break/disp8 +13372 $operand-matches-primitive?:var-deref-no-match: +13373 e9/jump $operand-matches-primitive?:return-false/disp32 +13374 } +13375 # return false if var->register doesn't match prim-var->register +13376 { +13377 # if register addresses are equal, it's a match +13378 # var vreg/ebx: (addr array byte) = lookup(var->register) +13379 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +13380 89/<- %ebx 0/r32/eax +13381 # var preg/ecx: (addr array byte) = lookup(prim-var->register) +13382 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +13383 89/<- %ecx 0/r32/eax +13384 # if (vreg == preg) break +13385 39/compare %ecx 3/r32/ebx +13386 74/jump-if-= break/disp8 +13387 $operand-matches-primitive?:var-register-no-match: +13388 # if either address is 0, return false +13389 81 7/subop/compare %ebx 0/imm32 +13390 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +13391 81 7/subop/compare %ecx 0/imm32 +13392 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +13393 # if prim-var->register is wildcard, it's a match +13394 (string-equal? %ecx "*") # Any-register => eax +13395 3d/compare-eax-and 0/imm32/false +13396 75/jump-if-!= break/disp8 +13397 $operand-matches-primitive?:wildcard-no-match: +13398 # if string contents aren't equal, return false +13399 (string-equal? %ecx %ebx) # => eax +13400 3d/compare-eax-and 0/imm32/false +13401 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +13402 } +13403 } +13404 $operand-matches-primitive?:return-true: +13405 b8/copy-to-eax 1/imm32/true +13406 eb/jump $operand-matches-primitive?:end/disp8 +13407 $operand-matches-primitive?:return-false: +13408 b8/copy-to-eax 0/imm32/false +13409 $operand-matches-primitive?:end: +13410 # . restore registers +13411 5f/pop-to-edi +13412 5e/pop-to-esi +13413 5b/pop-to-ebx +13414 5a/pop-to-edx +13415 59/pop-to-ecx +13416 # . epilogue +13417 89/<- %esp 5/r32/ebp +13418 5d/pop-to-ebp +13419 c3/return +13420 +13421 subx-type-equal?: # a: (addr tree type-id), b: (addr tree type-id) -> result/eax: boolean +13422 # . prologue +13423 55/push-ebp +13424 89/<- %ebp 4/r32/esp +13425 # . save registers +13426 51/push-ecx +13427 # var alit/ecx: boolean = is-literal-type?(a) +13428 (is-simple-mu-type? *(ebp+8) 0) # => eax +13429 89/<- %ecx 0/r32/eax +13430 # var blit/eax: boolean = is-literal-type?(b) +13431 (is-simple-mu-type? *(ebp+0xc) 0) # => eax +13432 # return alit == blit +13433 39/compare %eax 1/r32/ecx +13434 0f 94/set-byte-if-= %al +13435 81 4/subop/and %eax 0xff/imm32 +13436 $subx-type-equal?:end: +13437 # . restore registers +13438 59/pop-to-ecx +13439 # . epilogue +13440 89/<- %esp 5/r32/ebp +13441 5d/pop-to-ebp +13442 c3/return +13443 +13444 is-simple-mu-type?: # a: (addr tree type-id), n: type-id -> result/eax: boolean +13445 # . prologue +13446 55/push-ebp +13447 89/<- %ebp 4/r32/esp +13448 # . save registers +13449 51/push-ecx +13450 # ecx = n +13451 8b/-> *(ebp+0xc) 1/r32/ecx +13452 # return (a->value == n) +13453 8b/-> *(ebp+8) 0/r32/eax +13454 39/compare *(eax+4) 1/r32/ecx # Tree-value +13455 0f 94/set-byte-if-= %al +13456 81 4/subop/and %eax 0xff/imm32 +13457 $is-simple-mu-type?:end: +13458 # . restore registers +13459 59/pop-to-ecx +13460 # . epilogue +13461 89/<- %esp 5/r32/ebp +13462 5d/pop-to-ebp +13463 c3/return +13464 +13465 test-emit-subx-stmt-primitive: +13466 # Primitive operation on a variable on the stack. +13467 # increment foo +13468 # => +13469 # ff 0/subop/increment *(ebp-8) +13470 # +13471 # There's a variable on the var stack as follows: +13472 # name: 'foo' +13473 # type: int +13474 # stack-offset: -8 +13475 # +13476 # There's a primitive with this info: +13477 # name: 'increment' +13478 # inouts: int/mem +13479 # value: 'ff 0/subop/increment' +13480 # +13481 # . prologue +13482 55/push-ebp +13483 89/<- %ebp 4/r32/esp +13484 # setup +13485 (clear-stream _test-output-stream) +13486 (clear-stream $_test-output-buffered-file->buffer) +13487 # simulate allocated payloads starting with an initial fake alloc-id (0x11) +13488 $test-emit-subx-stmt-primitive:initialize-type: +13489 # var type/ecx: (payload tree type-id) = int +13490 68/push 0/imm32/right:null +13491 68/push 0/imm32/right:null +13492 68/push 0/imm32/left:unused +13493 68/push 1/imm32/value:int +13494 68/push 1/imm32/is-atom?:true +13495 68/push 0x11/imm32/alloc-id:fake:payload +13496 89/<- %ecx 4/r32/esp +13497 $test-emit-subx-stmt-primitive:initialize-var: +13498 # var var-foo/ecx: (payload var) = var(type) +13499 68/push 0/imm32/no-register +13500 68/push 0/imm32/no-register +13501 68/push -8/imm32/stack-offset +13502 68/push 1/imm32/block-depth +13503 51/push-ecx/type +13504 68/push 0x11/imm32/alloc-id:fake +13505 68/push 0/imm32/name +13506 68/push 0/imm32/name +13507 68/push 0x11/imm32/alloc-id:fake:payload +13508 89/<- %ecx 4/r32/esp +13509 $test-emit-subx-stmt-primitive:initialize-var-name: +13510 # var-foo->name = "foo" +13511 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +13512 (copy-array Heap "foo" %eax) +13513 $test-emit-subx-stmt-primitive:initialize-stmt-var: +13514 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +13515 68/push 0/imm32/is-deref:false +13516 68/push 0/imm32/next +13517 68/push 0/imm32/next +13518 51/push-ecx/var-foo +13519 68/push 0x11/imm32/alloc-id:fake +13520 68/push 0x11/imm32/alloc-id:fake:payload +13521 89/<- %ebx 4/r32/esp +13522 $test-emit-subx-stmt-primitive:initialize-stmt: +13523 # var stmt/esi: (addr statement) +13524 68/push 0/imm32/no-outputs +13525 68/push 0/imm32/no-outputs +13526 53/push-ebx/inouts +13527 68/push 0x11/imm32/alloc-id:fake +13528 68/push 0/imm32/operation +13529 68/push 0/imm32/operation +13530 68/push 1/imm32/tag +13531 89/<- %esi 4/r32/esp +13532 $test-emit-subx-stmt-primitive:initialize-stmt-operation: +13533 # stmt->operation = "increment" +13534 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +13535 (copy-array Heap "increment" %eax) +13536 $test-emit-subx-stmt-primitive:initialize-primitive: +13537 # var primitives/ebx: (addr primitive) +13538 68/push 0/imm32/next +13539 68/push 0/imm32/next +13540 68/push 0/imm32/output-is-write-only +13541 68/push 0/imm32/no-disp32 +13542 68/push 0/imm32/no-imm32 +13543 68/push 0/imm32/no-r32 +13544 68/push 1/imm32/rm32-is-first-inout +13545 68/push 0/imm32/subx-name +13546 68/push 0/imm32/subx-name +13547 68/push 0/imm32/no-outputs +13548 68/push 0/imm32/no-outputs +13549 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +13550 68/push 0x11/imm32/alloc-id:fake +13551 68/push 0/imm32/name +13552 68/push 0/imm32/name +13553 89/<- %ebx 4/r32/esp +13554 $test-emit-subx-stmt-primitive:initialize-primitive-name: +13555 # primitives->name = "increment" +13556 (copy-array Heap "increment" %ebx) # Primitive-name +13557 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: +13558 # primitives->subx-name = "ff 0/subop/increment" +13559 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +13560 (copy-array Heap "ff 0/subop/increment" %eax) +13561 # convert +13562 c7 0/subop/copy *Curr-block-depth 0/imm32 +13563 (emit-subx-stmt _test-output-buffered-file %esi %ebx) +13564 (flush _test-output-buffered-file) +13565 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13571 # check output +13572 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") +13573 # . epilogue +13574 89/<- %esp 5/r32/ebp +13575 5d/pop-to-ebp +13576 c3/return +13577 +13578 test-emit-subx-stmt-primitive-register: +13579 # Primitive operation on a variable in a register. +13580 # foo <- increment +13581 # => +13582 # ff 0/subop/increment %eax # sub-optimal, but should suffice +13583 # +13584 # There's a variable on the var stack as follows: +13585 # name: 'foo' +13586 # type: int +13587 # register: 'eax' +13588 # +13589 # There's a primitive with this info: +13590 # name: 'increment' +13591 # out: int/reg +13592 # value: 'ff 0/subop/increment' +13593 # +13594 # . prologue +13595 55/push-ebp +13596 89/<- %ebp 4/r32/esp +13597 # setup +13598 (clear-stream _test-output-stream) +13599 (clear-stream $_test-output-buffered-file->buffer) +13600 $test-emit-subx-stmt-primitive-register:initialize-type: +13601 # var type/ecx: (payload tree type-id) = int +13602 68/push 0/imm32/right:null +13603 68/push 0/imm32/right:null +13604 68/push 0/imm32/left:unused +13605 68/push 1/imm32/value:int +13606 68/push 1/imm32/is-atom?:true +13607 68/push 0x11/imm32/alloc-id:fake:payload +13608 89/<- %ecx 4/r32/esp +13609 $test-emit-subx-stmt-primitive-register:initialize-var: +13610 # var var-foo/ecx: (payload var) +13611 68/push 0/imm32/register +13612 68/push 0/imm32/register +13613 68/push 0/imm32/no-stack-offset +13614 68/push 1/imm32/block-depth +13615 51/push-ecx +13616 68/push 0x11/imm32/alloc-id:fake +13617 68/push 0/imm32/name +13618 68/push 0/imm32/name +13619 68/push 0x11/imm32/alloc-id:fake:payload +13620 89/<- %ecx 4/r32/esp +13621 $test-emit-subx-stmt-primitive-register:initialize-var-name: +13622 # var-foo->name = "foo" +13623 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +13624 (copy-array Heap "foo" %eax) +13625 $test-emit-subx-stmt-primitive-register:initialize-var-register: +13626 # var-foo->register = "eax" +13627 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +13628 (copy-array Heap "eax" %eax) +13629 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: +13630 # var operand/ebx: (payload stmt-var) +13631 68/push 0/imm32/is-deref:false +13632 68/push 0/imm32/next +13633 68/push 0/imm32/next +13634 51/push-ecx/var-foo +13635 68/push 0x11/imm32/alloc-id:fake +13636 68/push 0x11/imm32/alloc-id:fake:payload +13637 89/<- %ebx 4/r32/esp +13638 $test-emit-subx-stmt-primitive-register:initialize-stmt: +13639 # var stmt/esi: (addr statement) +13640 53/push-ebx/outputs +13641 68/push 0x11/imm32/alloc-id:fake +13642 68/push 0/imm32/no-inouts +13643 68/push 0/imm32/no-inouts +13644 68/push 0/imm32/operation +13645 68/push 0/imm32/operation +13646 68/push 1/imm32 +13647 89/<- %esi 4/r32/esp +13648 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: +13649 # stmt->operation = "increment" +13650 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +13651 (copy-array Heap "increment" %eax) +13652 $test-emit-subx-stmt-primitive-register:initialize-formal-var: +13653 # var formal-var/ebx: (payload var) +13654 68/push 0/imm32/register +13655 68/push 0/imm32/register +13656 68/push 0/imm32/no-stack-offset +13657 68/push 1/imm32/block-depth +13658 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +13659 68/push 0x11/imm32/alloc-id:fake +13660 68/push 0/imm32/name +13661 68/push 0/imm32/name +13662 68/push 0x11/imm32/alloc-id:fake:payload +13663 89/<- %ebx 4/r32/esp +13664 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: +13665 # formal-var->name = "dummy" +13666 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +13667 (copy-array Heap "dummy" %eax) +13668 $test-emit-subx-stmt-primitive-register:initialize-formal-register: +13669 # formal-var->register = "*" +13670 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +13671 (copy-array Heap "*" %eax) # Any-register +13672 $test-emit-subx-stmt-primitive-register:initialize-var-list: +13673 # var formal-outputs/ebx: (payload list var) +13674 68/push 0/imm32/next 13675 68/push 0/imm32/next -13676 68/push 0/imm32/next -13677 68/push 0/imm32/output-is-write-only -13678 68/push 0/imm32/no-disp32 -13679 68/push 0/imm32/no-imm32 -13680 68/push 0/imm32/no-r32 -13681 68/push 3/imm32/rm32-is-first-output -13682 68/push 0/imm32/subx-name -13683 68/push 0/imm32/subx-name -13684 53/push-ebx/outputs -13685 68/push 0x11/imm32/alloc-id:fake -13686 68/push 0/imm32/no-inouts -13687 68/push 0/imm32/no-inouts -13688 68/push 0/imm32/name -13689 68/push 0/imm32/name -13690 89/<- %ebx 4/r32/esp -13691 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: -13692 # primitives->name = "increment" -13693 (copy-array Heap "increment" %ebx) # Primitive-name -13694 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: -13695 # primitives->subx-name = "ff 0/subop/increment" -13696 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -13697 (copy-array Heap "ff 0/subop/increment" %eax) -13698 # convert -13699 c7 0/subop/copy *Curr-block-depth 0/imm32 -13700 (emit-subx-stmt _test-output-buffered-file %esi %ebx) -13701 (flush _test-output-buffered-file) -13702 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -13708 # check output -13709 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") -13710 # . epilogue -13711 89/<- %esp 5/r32/ebp -13712 5d/pop-to-ebp -13713 c3/return -13714 -13715 test-emit-subx-stmt-select-primitive: -13716 # Select the right primitive between overloads. -13717 # foo <- increment -13718 # => -13719 # ff 0/subop/increment %eax # sub-optimal, but should suffice -13720 # -13721 # There's a variable on the var stack as follows: -13722 # name: 'foo' -13723 # type: int -13724 # register: 'eax' -13725 # -13726 # There's two primitives, as follows: -13727 # - name: 'increment' -13728 # out: int/reg -13729 # value: 'ff 0/subop/increment' -13730 # - name: 'increment' -13731 # inout: int/mem -13732 # value: 'ff 0/subop/increment' -13733 # -13734 # . prologue -13735 55/push-ebp -13736 89/<- %ebp 4/r32/esp -13737 # setup -13738 (clear-stream _test-output-stream) -13739 (clear-stream $_test-output-buffered-file->buffer) -13740 $test-emit-subx-stmt-select-primitive:initialize-type: -13741 # var type/ecx: (payload tree type-id) = int -13742 68/push 0/imm32/right:null -13743 68/push 0/imm32/right:null -13744 68/push 0/imm32/left:unused -13745 68/push 1/imm32/value:int -13746 68/push 1/imm32/is-atom?:true -13747 68/push 0x11/imm32/alloc-id:fake:payload -13748 89/<- %ecx 4/r32/esp -13749 $test-emit-subx-stmt-select-primitive:initialize-var: -13750 # var var-foo/ecx: (payload var) -13751 68/push 0/imm32/register -13752 68/push 0/imm32/register -13753 68/push 0/imm32/no-stack-offset -13754 68/push 1/imm32/block-depth -13755 51/push-ecx -13756 68/push 0x11/imm32/alloc-id:fake -13757 68/push 0/imm32/name -13758 68/push 0/imm32/name -13759 68/push 0x11/imm32/alloc-id:fake:payload -13760 89/<- %ecx 4/r32/esp -13761 $test-emit-subx-stmt-select-primitive:initialize-var-name: -13762 # var-foo->name = "foo" -13763 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -13764 (copy-array Heap "foo" %eax) -13765 $test-emit-subx-stmt-select-primitive:initialize-var-register: -13766 # var-foo->register = "eax" -13767 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -13768 (copy-array Heap "eax" %eax) -13769 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: -13770 # var operand/ebx: (payload stmt-var) -13771 68/push 0/imm32/is-deref:false -13772 68/push 0/imm32/next -13773 68/push 0/imm32/next -13774 51/push-ecx/var-foo -13775 68/push 0x11/imm32/alloc-id:fake -13776 68/push 0x11/imm32/alloc-id:fake:payload -13777 89/<- %ebx 4/r32/esp -13778 $test-emit-subx-stmt-select-primitive:initialize-stmt: -13779 # var stmt/esi: (addr statement) -13780 53/push-ebx/outputs -13781 68/push 0x11/imm32/alloc-id:fake -13782 68/push 0/imm32/no-inouts -13783 68/push 0/imm32/no-inouts -13784 68/push 0/imm32/operation -13785 68/push 0/imm32/operation -13786 68/push 1/imm32 -13787 89/<- %esi 4/r32/esp -13788 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: -13789 # stmt->operation = "increment" -13790 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -13791 (copy-array Heap "increment" %eax) -13792 $test-emit-subx-stmt-select-primitive:initialize-formal-var: -13793 # var formal-var/ebx: (payload var) -13794 68/push 0/imm32/register -13795 68/push 0/imm32/register -13796 68/push 0/imm32/no-stack-offset -13797 68/push 1/imm32/block-depth -13798 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -13799 68/push 0x11/imm32/alloc-id:fake -13800 68/push 0/imm32/name -13801 68/push 0/imm32/name -13802 68/push 0x11/imm32/alloc-id:fake:payload -13803 89/<- %ebx 4/r32/esp -13804 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: -13805 # formal-var->name = "dummy" -13806 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -13807 (copy-array Heap "dummy" %eax) -13808 $test-emit-subx-stmt-select-primitive:initialize-formal-register: -13809 # formal-var->register = "*" -13810 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -13811 (copy-array Heap "*" %eax) # Any-register -13812 $test-emit-subx-stmt-select-primitive:initialize-var-list: -13813 # var formal-outputs/ebx: (payload list var) -13814 68/push 0/imm32/next -13815 68/push 0/imm32/next -13816 53/push-ebx/formal-var -13817 68/push 0x11/imm32/alloc-id:fake -13818 68/push 0x11/imm32/alloc-id:fake:payload -13819 89/<- %ebx 4/r32/esp -13820 $test-emit-subx-stmt-select-primitive:initialize-primitive2: -13821 # var primitive2/edi: (payload primitive) +13676 53/push-ebx/formal-var +13677 68/push 0x11/imm32/alloc-id:fake +13678 68/push 0x11/imm32/alloc-id:fake:payload +13679 89/<- %ebx 4/r32/esp +13680 $test-emit-subx-stmt-primitive-register:initialize-primitive: +13681 # var primitives/ebx: (addr primitive) +13682 68/push 0/imm32/next +13683 68/push 0/imm32/next +13684 68/push 0/imm32/output-is-write-only +13685 68/push 0/imm32/no-disp32 +13686 68/push 0/imm32/no-imm32 +13687 68/push 0/imm32/no-r32 +13688 68/push 3/imm32/rm32-is-first-output +13689 68/push 0/imm32/subx-name +13690 68/push 0/imm32/subx-name +13691 53/push-ebx/outputs +13692 68/push 0x11/imm32/alloc-id:fake +13693 68/push 0/imm32/no-inouts +13694 68/push 0/imm32/no-inouts +13695 68/push 0/imm32/name +13696 68/push 0/imm32/name +13697 89/<- %ebx 4/r32/esp +13698 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: +13699 # primitives->name = "increment" +13700 (copy-array Heap "increment" %ebx) # Primitive-name +13701 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: +13702 # primitives->subx-name = "ff 0/subop/increment" +13703 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +13704 (copy-array Heap "ff 0/subop/increment" %eax) +13705 # convert +13706 c7 0/subop/copy *Curr-block-depth 0/imm32 +13707 (emit-subx-stmt _test-output-buffered-file %esi %ebx) +13708 (flush _test-output-buffered-file) +13709 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13715 # check output +13716 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") +13717 # . epilogue +13718 89/<- %esp 5/r32/ebp +13719 5d/pop-to-ebp +13720 c3/return +13721 +13722 test-emit-subx-stmt-select-primitive: +13723 # Select the right primitive between overloads. +13724 # foo <- increment +13725 # => +13726 # ff 0/subop/increment %eax # sub-optimal, but should suffice +13727 # +13728 # There's a variable on the var stack as follows: +13729 # name: 'foo' +13730 # type: int +13731 # register: 'eax' +13732 # +13733 # There's two primitives, as follows: +13734 # - name: 'increment' +13735 # out: int/reg +13736 # value: 'ff 0/subop/increment' +13737 # - name: 'increment' +13738 # inout: int/mem +13739 # value: 'ff 0/subop/increment' +13740 # +13741 # . prologue +13742 55/push-ebp +13743 89/<- %ebp 4/r32/esp +13744 # setup +13745 (clear-stream _test-output-stream) +13746 (clear-stream $_test-output-buffered-file->buffer) +13747 $test-emit-subx-stmt-select-primitive:initialize-type: +13748 # var type/ecx: (payload tree type-id) = int +13749 68/push 0/imm32/right:null +13750 68/push 0/imm32/right:null +13751 68/push 0/imm32/left:unused +13752 68/push 1/imm32/value:int +13753 68/push 1/imm32/is-atom?:true +13754 68/push 0x11/imm32/alloc-id:fake:payload +13755 89/<- %ecx 4/r32/esp +13756 $test-emit-subx-stmt-select-primitive:initialize-var: +13757 # var var-foo/ecx: (payload var) +13758 68/push 0/imm32/register +13759 68/push 0/imm32/register +13760 68/push 0/imm32/no-stack-offset +13761 68/push 1/imm32/block-depth +13762 51/push-ecx +13763 68/push 0x11/imm32/alloc-id:fake +13764 68/push 0/imm32/name +13765 68/push 0/imm32/name +13766 68/push 0x11/imm32/alloc-id:fake:payload +13767 89/<- %ecx 4/r32/esp +13768 $test-emit-subx-stmt-select-primitive:initialize-var-name: +13769 # var-foo->name = "foo" +13770 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +13771 (copy-array Heap "foo" %eax) +13772 $test-emit-subx-stmt-select-primitive:initialize-var-register: +13773 # var-foo->register = "eax" +13774 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +13775 (copy-array Heap "eax" %eax) +13776 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: +13777 # var operand/ebx: (payload stmt-var) +13778 68/push 0/imm32/is-deref:false +13779 68/push 0/imm32/next +13780 68/push 0/imm32/next +13781 51/push-ecx/var-foo +13782 68/push 0x11/imm32/alloc-id:fake +13783 68/push 0x11/imm32/alloc-id:fake:payload +13784 89/<- %ebx 4/r32/esp +13785 $test-emit-subx-stmt-select-primitive:initialize-stmt: +13786 # var stmt/esi: (addr statement) +13787 53/push-ebx/outputs +13788 68/push 0x11/imm32/alloc-id:fake +13789 68/push 0/imm32/no-inouts +13790 68/push 0/imm32/no-inouts +13791 68/push 0/imm32/operation +13792 68/push 0/imm32/operation +13793 68/push 1/imm32 +13794 89/<- %esi 4/r32/esp +13795 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: +13796 # stmt->operation = "increment" +13797 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +13798 (copy-array Heap "increment" %eax) +13799 $test-emit-subx-stmt-select-primitive:initialize-formal-var: +13800 # var formal-var/ebx: (payload var) +13801 68/push 0/imm32/register +13802 68/push 0/imm32/register +13803 68/push 0/imm32/no-stack-offset +13804 68/push 1/imm32/block-depth +13805 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +13806 68/push 0x11/imm32/alloc-id:fake +13807 68/push 0/imm32/name +13808 68/push 0/imm32/name +13809 68/push 0x11/imm32/alloc-id:fake:payload +13810 89/<- %ebx 4/r32/esp +13811 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: +13812 # formal-var->name = "dummy" +13813 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +13814 (copy-array Heap "dummy" %eax) +13815 $test-emit-subx-stmt-select-primitive:initialize-formal-register: +13816 # formal-var->register = "*" +13817 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +13818 (copy-array Heap "*" %eax) # Any-register +13819 $test-emit-subx-stmt-select-primitive:initialize-var-list: +13820 # var formal-outputs/ebx: (payload list var) +13821 68/push 0/imm32/next 13822 68/push 0/imm32/next -13823 68/push 0/imm32/next -13824 68/push 0/imm32/output-is-write-only -13825 68/push 0/imm32/no-disp32 -13826 68/push 0/imm32/no-imm32 -13827 68/push 0/imm32/no-r32 -13828 68/push 3/imm32/rm32-is-first-output -13829 68/push 0/imm32/subx-name -13830 68/push 0/imm32/subx-name -13831 53/push-ebx/outputs -13832 68/push 0x11/imm32/alloc-id:fake -13833 68/push 0/imm32/no-inouts -13834 68/push 0/imm32/no-inouts -13835 68/push 0/imm32/name -13836 68/push 0/imm32/name -13837 68/push 0x11/imm32/alloc-id:fake:payload -13838 89/<- %edi 4/r32/esp -13839 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: -13840 # primitives->name = "increment" -13841 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -13842 (copy-array Heap "increment" %eax) -13843 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: -13844 # primitives->subx-name = "ff 0/subop/increment" -13845 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -13846 (copy-array Heap "ff 0/subop/increment" %eax) -13847 $test-emit-subx-stmt-select-primitive:initialize-primitive: -13848 # var primitives/ebx: (addr primitive) -13849 57/push-edi -13850 68/push 0x11/imm32/alloc-id:fake -13851 68/push 0/imm32/output-is-write-only -13852 68/push 0/imm32/no-disp32 -13853 68/push 0/imm32/no-imm32 -13854 68/push 0/imm32/no-r32 -13855 68/push 1/imm32/rm32-is-first-inout -13856 68/push 0/imm32/subx-name -13857 68/push 0/imm32/subx-name -13858 68/push 0/imm32/no-outputs -13859 68/push 0/imm32/no-outputs -13860 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -13861 68/push 0x11/imm32/alloc-id:fake -13862 68/push 0/imm32/name -13863 68/push 0/imm32/name -13864 89/<- %ebx 4/r32/esp -13865 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: -13866 # primitives->name = "increment" -13867 (copy-array Heap "increment" %ebx) # Primitive-name -13868 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: -13869 # primitives->subx-name = "ff 0/subop/increment" -13870 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -13871 (copy-array Heap "ff 0/subop/increment" %eax) -13872 # convert -13873 c7 0/subop/copy *Curr-block-depth 0/imm32 -13874 (emit-subx-stmt _test-output-buffered-file %esi %ebx) -13875 (flush _test-output-buffered-file) -13876 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -13882 # check output -13883 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") -13884 # . epilogue -13885 89/<- %esp 5/r32/ebp -13886 5d/pop-to-ebp -13887 c3/return -13888 -13889 test-emit-subx-stmt-select-primitive-2: -13890 # Select the right primitive between overloads. -13891 # increment foo -13892 # => -13893 # ff 0/subop/increment %eax # sub-optimal, but should suffice -13894 # -13895 # There's a variable on the var stack as follows: -13896 # name: 'foo' -13897 # type: int -13898 # register: 'eax' -13899 # -13900 # There's two primitives, as follows: -13901 # - name: 'increment' -13902 # out: int/reg -13903 # value: 'ff 0/subop/increment' -13904 # - name: 'increment' -13905 # inout: int/mem -13906 # value: 'ff 0/subop/increment' -13907 # -13908 # . prologue -13909 55/push-ebp -13910 89/<- %ebp 4/r32/esp -13911 # setup -13912 (clear-stream _test-output-stream) -13913 (clear-stream $_test-output-buffered-file->buffer) -13914 $test-emit-subx-stmt-select-primitive-2:initialize-type: -13915 # var type/ecx: (payload tree type-id) = int -13916 68/push 0/imm32/right:null -13917 68/push 0/imm32/right:null -13918 68/push 0/imm32/left:unused -13919 68/push 1/imm32/value:int -13920 68/push 1/imm32/is-atom?:true -13921 68/push 0x11/imm32/alloc-id:fake:payload -13922 89/<- %ecx 4/r32/esp -13923 $test-emit-subx-stmt-select-primitive-2:initialize-var: -13924 # var var-foo/ecx: (payload var) -13925 68/push 0/imm32/register -13926 68/push 0/imm32/register -13927 68/push 0/imm32/no-stack-offset -13928 68/push 1/imm32/block-depth -13929 51/push-ecx -13930 68/push 0x11/imm32/alloc-id:fake -13931 68/push 0/imm32/name -13932 68/push 0/imm32/name -13933 68/push 0x11/imm32/alloc-id:fake:payload -13934 89/<- %ecx 4/r32/esp -13935 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: -13936 # var-foo->name = "foo" -13937 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -13938 (copy-array Heap "foo" %eax) -13939 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: -13940 # var-foo->register = "eax" -13941 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -13942 (copy-array Heap "eax" %eax) -13943 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: -13944 # var operand/ebx: (payload stmt-var) -13945 68/push 0/imm32/is-deref:false -13946 68/push 0/imm32/next -13947 68/push 0/imm32/next -13948 51/push-ecx/var-foo -13949 68/push 0x11/imm32/alloc-id:fake -13950 68/push 0x11/imm32/alloc-id:fake:payload -13951 89/<- %ebx 4/r32/esp -13952 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: -13953 # var stmt/esi: (addr statement) -13954 68/push 0/imm32/no-outputs -13955 68/push 0/imm32/no-outputs -13956 53/push-ebx/inouts -13957 68/push 0x11/imm32/alloc-id:fake -13958 68/push 0/imm32/operation -13959 68/push 0/imm32/operation -13960 68/push 1/imm32 -13961 89/<- %esi 4/r32/esp -13962 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: -13963 # stmt->operation = "increment" -13964 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -13965 (copy-array Heap "increment" %eax) -13966 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: -13967 # var formal-var/ebx: (payload var) -13968 68/push 0/imm32/register -13969 68/push 0/imm32/register -13970 68/push 0/imm32/no-stack-offset -13971 68/push 1/imm32/block-depth -13972 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -13973 68/push 0x11/imm32/alloc-id:fake -13974 68/push 0/imm32/name -13975 68/push 0/imm32/name -13976 68/push 0x11/imm32/alloc-id:fake:payload -13977 89/<- %ebx 4/r32/esp -13978 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: -13979 # formal-var->name = "dummy" -13980 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -13981 (copy-array Heap "dummy" %eax) -13982 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: -13983 # formal-var->register = "*" -13984 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -13985 (copy-array Heap "*" %eax) # Any-register -13986 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: -13987 # var formal-outputs/ebx: (payload list stmt-var) -13988 68/push 0/imm32/next -13989 68/push 0/imm32/next -13990 53/push-ebx/formal-var -13991 68/push 0x11/imm32/alloc-id:fake -13992 68/push 0x11/imm32/alloc-id:fake:payload -13993 89/<- %ebx 4/r32/esp -13994 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: -13995 # var primitive2/edi: (payload primitive) +13823 53/push-ebx/formal-var +13824 68/push 0x11/imm32/alloc-id:fake +13825 68/push 0x11/imm32/alloc-id:fake:payload +13826 89/<- %ebx 4/r32/esp +13827 $test-emit-subx-stmt-select-primitive:initialize-primitive2: +13828 # var primitive2/edi: (payload primitive) +13829 68/push 0/imm32/next +13830 68/push 0/imm32/next +13831 68/push 0/imm32/output-is-write-only +13832 68/push 0/imm32/no-disp32 +13833 68/push 0/imm32/no-imm32 +13834 68/push 0/imm32/no-r32 +13835 68/push 3/imm32/rm32-is-first-output +13836 68/push 0/imm32/subx-name +13837 68/push 0/imm32/subx-name +13838 53/push-ebx/outputs +13839 68/push 0x11/imm32/alloc-id:fake +13840 68/push 0/imm32/no-inouts +13841 68/push 0/imm32/no-inouts +13842 68/push 0/imm32/name +13843 68/push 0/imm32/name +13844 68/push 0x11/imm32/alloc-id:fake:payload +13845 89/<- %edi 4/r32/esp +13846 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: +13847 # primitives->name = "increment" +13848 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +13849 (copy-array Heap "increment" %eax) +13850 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: +13851 # primitives->subx-name = "ff 0/subop/increment" +13852 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +13853 (copy-array Heap "ff 0/subop/increment" %eax) +13854 $test-emit-subx-stmt-select-primitive:initialize-primitive: +13855 # var primitives/ebx: (addr primitive) +13856 57/push-edi +13857 68/push 0x11/imm32/alloc-id:fake +13858 68/push 0/imm32/output-is-write-only +13859 68/push 0/imm32/no-disp32 +13860 68/push 0/imm32/no-imm32 +13861 68/push 0/imm32/no-r32 +13862 68/push 1/imm32/rm32-is-first-inout +13863 68/push 0/imm32/subx-name +13864 68/push 0/imm32/subx-name +13865 68/push 0/imm32/no-outputs +13866 68/push 0/imm32/no-outputs +13867 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +13868 68/push 0x11/imm32/alloc-id:fake +13869 68/push 0/imm32/name +13870 68/push 0/imm32/name +13871 89/<- %ebx 4/r32/esp +13872 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: +13873 # primitives->name = "increment" +13874 (copy-array Heap "increment" %ebx) # Primitive-name +13875 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: +13876 # primitives->subx-name = "ff 0/subop/increment" +13877 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +13878 (copy-array Heap "ff 0/subop/increment" %eax) +13879 # convert +13880 c7 0/subop/copy *Curr-block-depth 0/imm32 +13881 (emit-subx-stmt _test-output-buffered-file %esi %ebx) +13882 (flush _test-output-buffered-file) +13883 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13889 # check output +13890 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") +13891 # . epilogue +13892 89/<- %esp 5/r32/ebp +13893 5d/pop-to-ebp +13894 c3/return +13895 +13896 test-emit-subx-stmt-select-primitive-2: +13897 # Select the right primitive between overloads. +13898 # increment foo +13899 # => +13900 # ff 0/subop/increment %eax # sub-optimal, but should suffice +13901 # +13902 # There's a variable on the var stack as follows: +13903 # name: 'foo' +13904 # type: int +13905 # register: 'eax' +13906 # +13907 # There's two primitives, as follows: +13908 # - name: 'increment' +13909 # out: int/reg +13910 # value: 'ff 0/subop/increment' +13911 # - name: 'increment' +13912 # inout: int/mem +13913 # value: 'ff 0/subop/increment' +13914 # +13915 # . prologue +13916 55/push-ebp +13917 89/<- %ebp 4/r32/esp +13918 # setup +13919 (clear-stream _test-output-stream) +13920 (clear-stream $_test-output-buffered-file->buffer) +13921 $test-emit-subx-stmt-select-primitive-2:initialize-type: +13922 # var type/ecx: (payload tree type-id) = int +13923 68/push 0/imm32/right:null +13924 68/push 0/imm32/right:null +13925 68/push 0/imm32/left:unused +13926 68/push 1/imm32/value:int +13927 68/push 1/imm32/is-atom?:true +13928 68/push 0x11/imm32/alloc-id:fake:payload +13929 89/<- %ecx 4/r32/esp +13930 $test-emit-subx-stmt-select-primitive-2:initialize-var: +13931 # var var-foo/ecx: (payload var) +13932 68/push 0/imm32/register +13933 68/push 0/imm32/register +13934 68/push 0/imm32/no-stack-offset +13935 68/push 1/imm32/block-depth +13936 51/push-ecx +13937 68/push 0x11/imm32/alloc-id:fake +13938 68/push 0/imm32/name +13939 68/push 0/imm32/name +13940 68/push 0x11/imm32/alloc-id:fake:payload +13941 89/<- %ecx 4/r32/esp +13942 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: +13943 # var-foo->name = "foo" +13944 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +13945 (copy-array Heap "foo" %eax) +13946 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: +13947 # var-foo->register = "eax" +13948 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +13949 (copy-array Heap "eax" %eax) +13950 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: +13951 # var operand/ebx: (payload stmt-var) +13952 68/push 0/imm32/is-deref:false +13953 68/push 0/imm32/next +13954 68/push 0/imm32/next +13955 51/push-ecx/var-foo +13956 68/push 0x11/imm32/alloc-id:fake +13957 68/push 0x11/imm32/alloc-id:fake:payload +13958 89/<- %ebx 4/r32/esp +13959 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: +13960 # var stmt/esi: (addr statement) +13961 68/push 0/imm32/no-outputs +13962 68/push 0/imm32/no-outputs +13963 53/push-ebx/inouts +13964 68/push 0x11/imm32/alloc-id:fake +13965 68/push 0/imm32/operation +13966 68/push 0/imm32/operation +13967 68/push 1/imm32 +13968 89/<- %esi 4/r32/esp +13969 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: +13970 # stmt->operation = "increment" +13971 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +13972 (copy-array Heap "increment" %eax) +13973 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: +13974 # var formal-var/ebx: (payload var) +13975 68/push 0/imm32/register +13976 68/push 0/imm32/register +13977 68/push 0/imm32/no-stack-offset +13978 68/push 1/imm32/block-depth +13979 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +13980 68/push 0x11/imm32/alloc-id:fake +13981 68/push 0/imm32/name +13982 68/push 0/imm32/name +13983 68/push 0x11/imm32/alloc-id:fake:payload +13984 89/<- %ebx 4/r32/esp +13985 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: +13986 # formal-var->name = "dummy" +13987 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +13988 (copy-array Heap "dummy" %eax) +13989 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: +13990 # formal-var->register = "*" +13991 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +13992 (copy-array Heap "*" %eax) # Any-register +13993 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: +13994 # var formal-outputs/ebx: (payload list stmt-var) +13995 68/push 0/imm32/next 13996 68/push 0/imm32/next -13997 68/push 0/imm32/next -13998 68/push 0/imm32/output-is-write-only -13999 68/push 0/imm32/no-disp32 -14000 68/push 0/imm32/no-imm32 -14001 68/push 0/imm32/no-r32 -14002 68/push 3/imm32/rm32-is-first-output -14003 68/push 0/imm32/subx-name -14004 68/push 0/imm32/subx-name -14005 53/push-ebx/outputs -14006 68/push 0x11/imm32/alloc-id:fake -14007 68/push 0/imm32/no-inouts -14008 68/push 0/imm32/no-inouts -14009 68/push 0/imm32/name -14010 68/push 0/imm32/name -14011 68/push 0x11/imm32/alloc-id:fake:payload -14012 89/<- %edi 4/r32/esp -14013 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: -14014 # primitives->name = "increment" -14015 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -14016 (copy-array Heap "increment" %eax) -14017 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: -14018 # primitives->subx-name = "ff 0/subop/increment" -14019 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -14020 (copy-array Heap "ff 0/subop/increment" %eax) -14021 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: -14022 # var primitives/ebx: (addr primitive) -14023 57/push-edi -14024 68/push 0x11/imm32/alloc-id:fake -14025 68/push 0/imm32/output-is-write-only -14026 68/push 0/imm32/no-disp32 -14027 68/push 0/imm32/no-imm32 -14028 68/push 0/imm32/no-r32 -14029 68/push 1/imm32/rm32-is-first-inout -14030 68/push 0/imm32/subx-name -14031 68/push 0/imm32/subx-name -14032 68/push 0/imm32/no-outputs -14033 68/push 0/imm32/no-outputs -14034 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -14035 68/push 0x11/imm32/alloc-id:fake -14036 68/push 0/imm32/name -14037 68/push 0/imm32/name -14038 89/<- %ebx 4/r32/esp -14039 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: -14040 # primitives->name = "increment" -14041 (copy-array Heap "increment" %ebx) # Primitive-name -14042 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: -14043 # primitives->subx-name = "ff 0/subop/increment" -14044 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -14045 (copy-array Heap "ff 0/subop/increment" %eax) -14046 # convert -14047 c7 0/subop/copy *Curr-block-depth 0/imm32 -14048 (emit-subx-stmt _test-output-buffered-file %esi %ebx) -14049 (flush _test-output-buffered-file) -14050 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14056 # check output -14057 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") -14058 # . epilogue -14059 89/<- %esp 5/r32/ebp -14060 5d/pop-to-ebp -14061 c3/return -14062 -14063 test-increment-register: -14064 # Select the right register between overloads. -14065 # foo <- increment -14066 # => -14067 # 50/increment-eax -14068 # -14069 # There's a variable on the var stack as follows: -14070 # name: 'foo' -14071 # type: int -14072 # register: 'eax' -14073 # -14074 # Primitives are the global definitions. +13997 53/push-ebx/formal-var +13998 68/push 0x11/imm32/alloc-id:fake +13999 68/push 0x11/imm32/alloc-id:fake:payload +14000 89/<- %ebx 4/r32/esp +14001 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: +14002 # var primitive2/edi: (payload primitive) +14003 68/push 0/imm32/next +14004 68/push 0/imm32/next +14005 68/push 0/imm32/output-is-write-only +14006 68/push 0/imm32/no-disp32 +14007 68/push 0/imm32/no-imm32 +14008 68/push 0/imm32/no-r32 +14009 68/push 3/imm32/rm32-is-first-output +14010 68/push 0/imm32/subx-name +14011 68/push 0/imm32/subx-name +14012 53/push-ebx/outputs +14013 68/push 0x11/imm32/alloc-id:fake +14014 68/push 0/imm32/no-inouts +14015 68/push 0/imm32/no-inouts +14016 68/push 0/imm32/name +14017 68/push 0/imm32/name +14018 68/push 0x11/imm32/alloc-id:fake:payload +14019 89/<- %edi 4/r32/esp +14020 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: +14021 # primitives->name = "increment" +14022 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +14023 (copy-array Heap "increment" %eax) +14024 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: +14025 # primitives->subx-name = "ff 0/subop/increment" +14026 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +14027 (copy-array Heap "ff 0/subop/increment" %eax) +14028 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: +14029 # var primitives/ebx: (addr primitive) +14030 57/push-edi +14031 68/push 0x11/imm32/alloc-id:fake +14032 68/push 0/imm32/output-is-write-only +14033 68/push 0/imm32/no-disp32 +14034 68/push 0/imm32/no-imm32 +14035 68/push 0/imm32/no-r32 +14036 68/push 1/imm32/rm32-is-first-inout +14037 68/push 0/imm32/subx-name +14038 68/push 0/imm32/subx-name +14039 68/push 0/imm32/no-outputs +14040 68/push 0/imm32/no-outputs +14041 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +14042 68/push 0x11/imm32/alloc-id:fake +14043 68/push 0/imm32/name +14044 68/push 0/imm32/name +14045 89/<- %ebx 4/r32/esp +14046 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: +14047 # primitives->name = "increment" +14048 (copy-array Heap "increment" %ebx) # Primitive-name +14049 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: +14050 # primitives->subx-name = "ff 0/subop/increment" +14051 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +14052 (copy-array Heap "ff 0/subop/increment" %eax) +14053 # convert +14054 c7 0/subop/copy *Curr-block-depth 0/imm32 +14055 (emit-subx-stmt _test-output-buffered-file %esi %ebx) +14056 (flush _test-output-buffered-file) +14057 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14063 # check output +14064 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") +14065 # . epilogue +14066 89/<- %esp 5/r32/ebp +14067 5d/pop-to-ebp +14068 c3/return +14069 +14070 test-increment-register: +14071 # Select the right register between overloads. +14072 # foo <- increment +14073 # => +14074 # 50/increment-eax 14075 # -14076 # . prologue -14077 55/push-ebp -14078 89/<- %ebp 4/r32/esp -14079 # setup -14080 (clear-stream _test-output-stream) -14081 (clear-stream $_test-output-buffered-file->buffer) -14082 $test-increment-register:initialize-type: -14083 # var type/ecx: (payload tree type-id) = int -14084 68/push 0/imm32/right:null -14085 68/push 0/imm32/right:null -14086 68/push 0/imm32/left:unused -14087 68/push 1/imm32/value:int -14088 68/push 1/imm32/is-atom?:true -14089 68/push 0x11/imm32/alloc-id:fake:payload -14090 89/<- %ecx 4/r32/esp -14091 $test-increment-register:initialize-var: -14092 # var var-foo/ecx: (payload var) -14093 68/push 0/imm32/register -14094 68/push 0/imm32/register -14095 68/push 0/imm32/no-stack-offset -14096 68/push 1/imm32/block-depth -14097 51/push-ecx -14098 68/push 0x11/imm32/alloc-id:fake -14099 68/push 0/imm32/name -14100 68/push 0/imm32/name -14101 68/push 0x11/imm32/alloc-id:fake:payload -14102 89/<- %ecx 4/r32/esp -14103 $test-increment-register:initialize-var-name: -14104 # var-foo->name = "foo" -14105 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14106 (copy-array Heap "foo" %eax) -14107 $test-increment-register:initialize-var-register: -14108 # var-foo->register = "eax" -14109 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14110 (copy-array Heap "eax" %eax) -14111 $test-increment-register:initialize-stmt-var: -14112 # var operand/ebx: (payload stmt-var) -14113 68/push 0/imm32/is-deref:false -14114 68/push 0/imm32/next -14115 68/push 0/imm32/next -14116 51/push-ecx/var-foo -14117 68/push 0x11/imm32/alloc-id:fake -14118 68/push 0x11/imm32/alloc-id:fake:payload -14119 89/<- %ebx 4/r32/esp -14120 $test-increment-register:initialize-stmt: -14121 # var stmt/esi: (addr statement) -14122 53/push-ebx/outputs -14123 68/push 0x11/imm32/alloc-id:fake -14124 68/push 0/imm32/no-inouts -14125 68/push 0/imm32/no-inouts -14126 68/push 0/imm32/operation -14127 68/push 0/imm32/operation -14128 68/push 1/imm32 -14129 89/<- %esi 4/r32/esp -14130 $test-increment-register:initialize-stmt-operation: -14131 # stmt->operation = "increment" -14132 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14133 (copy-array Heap "increment" %eax) -14134 # convert -14135 c7 0/subop/copy *Curr-block-depth 0/imm32 -14136 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14137 (flush _test-output-buffered-file) -14138 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14144 # check output -14145 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") -14146 # . epilogue -14147 89/<- %esp 5/r32/ebp -14148 5d/pop-to-ebp -14149 c3/return -14150 -14151 test-add-reg-to-reg: -14152 # var1/reg <- add var2/reg -14153 # => -14154 # 01/add-to %var1 var2 -14155 # -14156 # . prologue -14157 55/push-ebp -14158 89/<- %ebp 4/r32/esp -14159 # setup -14160 (clear-stream _test-output-stream) -14161 (clear-stream $_test-output-buffered-file->buffer) -14162 $test-add-reg-to-reg:initialize-type: -14163 # var type/ecx: (payload tree type-id) = int -14164 68/push 0/imm32/right:null -14165 68/push 0/imm32/right:null -14166 68/push 0/imm32/left:unused -14167 68/push 1/imm32/value:int -14168 68/push 1/imm32/is-atom?:true -14169 68/push 0x11/imm32/alloc-id:fake:payload -14170 89/<- %ecx 4/r32/esp -14171 $test-add-reg-to-reg:initialize-var1: -14172 # var var1/ecx: (payload var) -14173 68/push 0/imm32/register -14174 68/push 0/imm32/register -14175 68/push 0/imm32/no-stack-offset -14176 68/push 1/imm32/block-depth -14177 51/push-ecx -14178 68/push 0x11/imm32/alloc-id:fake -14179 68/push 0/imm32/name -14180 68/push 0/imm32/name -14181 68/push 0x11/imm32/alloc-id:fake:payload -14182 89/<- %ecx 4/r32/esp -14183 $test-add-reg-to-reg:initialize-var1-name: -14184 # var1->name = "var1" -14185 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14186 (copy-array Heap "var1" %eax) -14187 $test-add-reg-to-reg:initialize-var1-register: -14188 # var1->register = "eax" -14189 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14190 (copy-array Heap "eax" %eax) -14191 $test-add-reg-to-reg:initialize-var2: -14192 # var var2/edx: (payload var) -14193 68/push 0/imm32/register -14194 68/push 0/imm32/register -14195 68/push 0/imm32/no-stack-offset -14196 68/push 1/imm32/block-depth -14197 ff 6/subop/push *(ecx+0x10) -14198 68/push 0x11/imm32/alloc-id:fake -14199 68/push 0/imm32/name -14200 68/push 0/imm32/name -14201 68/push 0x11/imm32/alloc-id:fake:payload -14202 89/<- %edx 4/r32/esp -14203 $test-add-reg-to-reg:initialize-var2-name: -14204 # var2->name = "var2" -14205 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14206 (copy-array Heap "var2" %eax) -14207 $test-add-reg-to-reg:initialize-var2-register: -14208 # var2->register = "ecx" -14209 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -14210 (copy-array Heap "ecx" %eax) -14211 $test-add-reg-to-reg:initialize-inouts: -14212 # var inouts/esi: (payload stmt-var) = [var2] -14213 68/push 0/imm32/is-deref:false -14214 68/push 0/imm32/next -14215 68/push 0/imm32/next -14216 52/push-edx/var2 -14217 68/push 0x11/imm32/alloc-id:fake -14218 68/push 0x11/imm32/alloc-id:fake:payload -14219 89/<- %esi 4/r32/esp -14220 $test-add-reg-to-reg:initialize-outputs: -14221 # var outputs/edi: (payload stmt-var) = [var1] -14222 68/push 0/imm32/is-deref:false -14223 68/push 0/imm32/next -14224 68/push 0/imm32/next -14225 51/push-ecx/var1 -14226 68/push 0x11/imm32/alloc-id:fake -14227 68/push 0x11/imm32/alloc-id:fake:payload -14228 89/<- %edi 4/r32/esp -14229 $test-add-reg-to-reg:initialize-stmt: -14230 # var stmt/esi: (addr statement) +14076 # There's a variable on the var stack as follows: +14077 # name: 'foo' +14078 # type: int +14079 # register: 'eax' +14080 # +14081 # Primitives are the global definitions. +14082 # +14083 # . prologue +14084 55/push-ebp +14085 89/<- %ebp 4/r32/esp +14086 # setup +14087 (clear-stream _test-output-stream) +14088 (clear-stream $_test-output-buffered-file->buffer) +14089 $test-increment-register:initialize-type: +14090 # var type/ecx: (payload tree type-id) = int +14091 68/push 0/imm32/right:null +14092 68/push 0/imm32/right:null +14093 68/push 0/imm32/left:unused +14094 68/push 1/imm32/value:int +14095 68/push 1/imm32/is-atom?:true +14096 68/push 0x11/imm32/alloc-id:fake:payload +14097 89/<- %ecx 4/r32/esp +14098 $test-increment-register:initialize-var: +14099 # var var-foo/ecx: (payload var) +14100 68/push 0/imm32/register +14101 68/push 0/imm32/register +14102 68/push 0/imm32/no-stack-offset +14103 68/push 1/imm32/block-depth +14104 51/push-ecx +14105 68/push 0x11/imm32/alloc-id:fake +14106 68/push 0/imm32/name +14107 68/push 0/imm32/name +14108 68/push 0x11/imm32/alloc-id:fake:payload +14109 89/<- %ecx 4/r32/esp +14110 $test-increment-register:initialize-var-name: +14111 # var-foo->name = "foo" +14112 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14113 (copy-array Heap "foo" %eax) +14114 $test-increment-register:initialize-var-register: +14115 # var-foo->register = "eax" +14116 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14117 (copy-array Heap "eax" %eax) +14118 $test-increment-register:initialize-stmt-var: +14119 # var operand/ebx: (payload stmt-var) +14120 68/push 0/imm32/is-deref:false +14121 68/push 0/imm32/next +14122 68/push 0/imm32/next +14123 51/push-ecx/var-foo +14124 68/push 0x11/imm32/alloc-id:fake +14125 68/push 0x11/imm32/alloc-id:fake:payload +14126 89/<- %ebx 4/r32/esp +14127 $test-increment-register:initialize-stmt: +14128 # var stmt/esi: (addr statement) +14129 53/push-ebx/outputs +14130 68/push 0x11/imm32/alloc-id:fake +14131 68/push 0/imm32/no-inouts +14132 68/push 0/imm32/no-inouts +14133 68/push 0/imm32/operation +14134 68/push 0/imm32/operation +14135 68/push 1/imm32 +14136 89/<- %esi 4/r32/esp +14137 $test-increment-register:initialize-stmt-operation: +14138 # stmt->operation = "increment" +14139 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14140 (copy-array Heap "increment" %eax) +14141 # convert +14142 c7 0/subop/copy *Curr-block-depth 0/imm32 +14143 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14144 (flush _test-output-buffered-file) +14145 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14151 # check output +14152 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") +14153 # . epilogue +14154 89/<- %esp 5/r32/ebp +14155 5d/pop-to-ebp +14156 c3/return +14157 +14158 test-add-reg-to-reg: +14159 # var1/reg <- add var2/reg +14160 # => +14161 # 01/add-to %var1 var2 +14162 # +14163 # . prologue +14164 55/push-ebp +14165 89/<- %ebp 4/r32/esp +14166 # setup +14167 (clear-stream _test-output-stream) +14168 (clear-stream $_test-output-buffered-file->buffer) +14169 $test-add-reg-to-reg:initialize-type: +14170 # var type/ecx: (payload tree type-id) = int +14171 68/push 0/imm32/right:null +14172 68/push 0/imm32/right:null +14173 68/push 0/imm32/left:unused +14174 68/push 1/imm32/value:int +14175 68/push 1/imm32/is-atom?:true +14176 68/push 0x11/imm32/alloc-id:fake:payload +14177 89/<- %ecx 4/r32/esp +14178 $test-add-reg-to-reg:initialize-var1: +14179 # var var1/ecx: (payload var) +14180 68/push 0/imm32/register +14181 68/push 0/imm32/register +14182 68/push 0/imm32/no-stack-offset +14183 68/push 1/imm32/block-depth +14184 51/push-ecx +14185 68/push 0x11/imm32/alloc-id:fake +14186 68/push 0/imm32/name +14187 68/push 0/imm32/name +14188 68/push 0x11/imm32/alloc-id:fake:payload +14189 89/<- %ecx 4/r32/esp +14190 $test-add-reg-to-reg:initialize-var1-name: +14191 # var1->name = "var1" +14192 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14193 (copy-array Heap "var1" %eax) +14194 $test-add-reg-to-reg:initialize-var1-register: +14195 # var1->register = "eax" +14196 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14197 (copy-array Heap "eax" %eax) +14198 $test-add-reg-to-reg:initialize-var2: +14199 # var var2/edx: (payload var) +14200 68/push 0/imm32/register +14201 68/push 0/imm32/register +14202 68/push 0/imm32/no-stack-offset +14203 68/push 1/imm32/block-depth +14204 ff 6/subop/push *(ecx+0x10) +14205 68/push 0x11/imm32/alloc-id:fake +14206 68/push 0/imm32/name +14207 68/push 0/imm32/name +14208 68/push 0x11/imm32/alloc-id:fake:payload +14209 89/<- %edx 4/r32/esp +14210 $test-add-reg-to-reg:initialize-var2-name: +14211 # var2->name = "var2" +14212 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14213 (copy-array Heap "var2" %eax) +14214 $test-add-reg-to-reg:initialize-var2-register: +14215 # var2->register = "ecx" +14216 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +14217 (copy-array Heap "ecx" %eax) +14218 $test-add-reg-to-reg:initialize-inouts: +14219 # var inouts/esi: (payload stmt-var) = [var2] +14220 68/push 0/imm32/is-deref:false +14221 68/push 0/imm32/next +14222 68/push 0/imm32/next +14223 52/push-edx/var2 +14224 68/push 0x11/imm32/alloc-id:fake +14225 68/push 0x11/imm32/alloc-id:fake:payload +14226 89/<- %esi 4/r32/esp +14227 $test-add-reg-to-reg:initialize-outputs: +14228 # var outputs/edi: (payload stmt-var) = [var1] +14229 68/push 0/imm32/is-deref:false +14230 68/push 0/imm32/next 14231 68/push 0/imm32/next -14232 68/push 0/imm32/next -14233 57/push-edi/outputs -14234 68/push 0x11/imm32/alloc-id:fake -14235 56/push-esi/inouts -14236 68/push 0x11/imm32/alloc-id:fake -14237 68/push 0/imm32/operation -14238 68/push 0/imm32/operation -14239 68/push 1/imm32/tag:stmt1 -14240 89/<- %esi 4/r32/esp -14241 $test-add-reg-to-reg:initialize-stmt-operation: -14242 # stmt->operation = "add" -14243 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14244 (copy-array Heap "add" %eax) -14245 # convert -14246 c7 0/subop/copy *Curr-block-depth 0/imm32 -14247 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14248 (flush _test-output-buffered-file) -14249 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14255 # check output -14256 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") -14257 # . epilogue -14258 89/<- %esp 5/r32/ebp -14259 5d/pop-to-ebp -14260 c3/return -14261 -14262 test-add-reg-to-mem: -14263 # add-to var1 var2/reg -14264 # => -14265 # 01/add-to *(ebp+__) var2 -14266 # -14267 # . prologue -14268 55/push-ebp -14269 89/<- %ebp 4/r32/esp -14270 # setup -14271 (clear-stream _test-output-stream) -14272 (clear-stream $_test-output-buffered-file->buffer) -14273 $test-add-reg-to-mem:initialize-type: -14274 # var type/ecx: (payload tree type-id) = int -14275 68/push 0/imm32/right:null -14276 68/push 0/imm32/right:null -14277 68/push 0/imm32/left:unused -14278 68/push 1/imm32/value:int -14279 68/push 1/imm32/is-atom?:true -14280 68/push 0x11/imm32/alloc-id:fake:payload -14281 89/<- %ecx 4/r32/esp -14282 $test-add-reg-to-mem:initialize-var1: -14283 # var var1/ecx: (payload var) -14284 68/push 0/imm32/register -14285 68/push 0/imm32/register -14286 68/push 8/imm32/stack-offset -14287 68/push 1/imm32/block-depth -14288 51/push-ecx -14289 68/push 0x11/imm32/alloc-id:fake -14290 68/push 0/imm32/name -14291 68/push 0/imm32/name -14292 68/push 0x11/imm32/alloc-id:fake:payload -14293 89/<- %ecx 4/r32/esp -14294 $test-add-reg-to-mem:initialize-var1-name: -14295 # var1->name = "var1" -14296 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14297 (copy-array Heap "var1" %eax) -14298 $test-add-reg-to-mem:initialize-var2: -14299 # var var2/edx: (payload var) -14300 68/push 0/imm32/register -14301 68/push 0/imm32/register -14302 68/push 0/imm32/no-stack-offset -14303 68/push 1/imm32/block-depth -14304 ff 6/subop/push *(ecx+0x10) -14305 68/push 0x11/imm32/alloc-id:fake -14306 68/push 0/imm32/name -14307 68/push 0/imm32/name -14308 68/push 0x11/imm32/alloc-id:fake:payload -14309 89/<- %edx 4/r32/esp -14310 $test-add-reg-to-mem:initialize-var2-name: -14311 # var2->name = "var2" -14312 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14313 (copy-array Heap "var2" %eax) -14314 $test-add-reg-to-mem:initialize-var2-register: -14315 # var2->register = "ecx" -14316 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -14317 (copy-array Heap "ecx" %eax) -14318 $test-add-reg-to-mem:initialize-inouts: -14319 # var inouts/esi: (payload stmt-var) = [var2] -14320 68/push 0/imm32/is-deref:false -14321 68/push 0/imm32/next -14322 68/push 0/imm32/next -14323 52/push-edx/var2 -14324 68/push 0x11/imm32/alloc-id:fake -14325 68/push 0x11/imm32/alloc-id:fake:payload -14326 89/<- %esi 4/r32/esp -14327 # inouts = [var1, var2] -14328 68/push 0/imm32/is-deref:false -14329 56/push-esi/next -14330 68/push 0x11/imm32/alloc-id:fake -14331 51/push-ecx/var1 -14332 68/push 0x11/imm32/alloc-id:fake -14333 68/push 0x11/imm32/alloc-id:fake:payload -14334 89/<- %esi 4/r32/esp -14335 $test-add-reg-to-mem:initialize-stmt: -14336 # var stmt/esi: (addr statement) -14337 68/push 0/imm32/next -14338 68/push 0/imm32/next -14339 68/push 0/imm32/outputs -14340 68/push 0/imm32/outputs -14341 56/push-esi/inouts -14342 68/push 0x11/imm32/alloc-id:fake -14343 68/push 0/imm32/operation -14344 68/push 0/imm32/operation -14345 68/push 1/imm32/tag:stmt1 -14346 89/<- %esi 4/r32/esp -14347 $test-add-reg-to-mem:initialize-stmt-operation: -14348 # stmt->operation = "add-to" -14349 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14350 (copy-array Heap "add-to" %eax) -14351 # convert -14352 c7 0/subop/copy *Curr-block-depth 0/imm32 -14353 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14354 (flush _test-output-buffered-file) -14355 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14361 # check output -14362 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") -14363 # . epilogue -14364 89/<- %esp 5/r32/ebp -14365 5d/pop-to-ebp -14366 c3/return -14367 -14368 test-add-mem-to-reg: -14369 # var1/reg <- add var2 -14370 # => -14371 # 03/add *(ebp+__) var1 -14372 # -14373 # . prologue -14374 55/push-ebp -14375 89/<- %ebp 4/r32/esp -14376 # setup -14377 (clear-stream _test-output-stream) -14378 (clear-stream $_test-output-buffered-file->buffer) -14379 $test-add-mem-to-reg:initialize-type: -14380 # var type/ecx: (payload tree type-id) = int -14381 68/push 0/imm32/right:null -14382 68/push 0/imm32/right:null -14383 68/push 0/imm32/left:unused -14384 68/push 1/imm32/value:int -14385 68/push 1/imm32/is-atom?:true -14386 68/push 0x11/imm32/alloc-id:fake:payload -14387 89/<- %ecx 4/r32/esp -14388 $test-add-mem-to-reg:initialize-var: -14389 # var var1/ecx: (payload var) -14390 68/push 0/imm32/register -14391 68/push 0/imm32/register -14392 68/push 0/imm32/no-stack-offset -14393 68/push 1/imm32/block-depth -14394 51/push-ecx -14395 68/push 0x11/imm32/alloc-id:fake -14396 68/push 0/imm32/name -14397 68/push 0/imm32/name -14398 68/push 0x11/imm32/alloc-id:fake:payload -14399 89/<- %ecx 4/r32/esp -14400 $test-add-mem-to-reg:initialize-var-name: -14401 # var1->name = "foo" -14402 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14403 (copy-array Heap "var1" %eax) -14404 $test-add-mem-to-reg:initialize-var-register: -14405 # var1->register = "eax" -14406 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14407 (copy-array Heap "eax" %eax) -14408 $test-add-mem-to-reg:initialize-var2: -14409 # var var2/edx: (payload var) -14410 68/push 0/imm32/register -14411 68/push 0/imm32/register -14412 68/push 8/imm32/stack-offset -14413 68/push 1/imm32/block-depth -14414 ff 6/subop/push *(ecx+0x10) -14415 68/push 0x11/imm32/alloc-id:fake -14416 68/push 0/imm32/name -14417 68/push 0/imm32/name -14418 68/push 0x11/imm32/alloc-id:fake:payload -14419 89/<- %edx 4/r32/esp -14420 $test-add-mem-to-reg:initialize-var2-name: -14421 # var2->name = "var2" -14422 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14423 (copy-array Heap "var2" %eax) -14424 $test-add-mem-to-reg:initialize-inouts: -14425 # var inouts/esi: (payload stmt-var) = [var2] -14426 68/push 0/imm32/is-deref:false -14427 68/push 0/imm32/next -14428 68/push 0/imm32/next -14429 52/push-edx/var2 -14430 68/push 0x11/imm32/alloc-id:fake -14431 68/push 0x11/imm32/alloc-id:fake:payload -14432 89/<- %esi 4/r32/esp -14433 $test-add-mem-to-reg:initialize-outputs: -14434 # var outputs/edi: (payload stmt-var) = [var1] -14435 68/push 0/imm32/is-deref:false -14436 68/push 0/imm32/next -14437 68/push 0/imm32/next -14438 51/push-ecx/var1 -14439 68/push 0x11/imm32/alloc-id:fake -14440 68/push 0x11/imm32/alloc-id:fake:payload -14441 89/<- %edi 4/r32/esp -14442 $test-add-mem-to-reg:initialize-stmt: -14443 # var stmt/esi: (addr statement) +14232 51/push-ecx/var1 +14233 68/push 0x11/imm32/alloc-id:fake +14234 68/push 0x11/imm32/alloc-id:fake:payload +14235 89/<- %edi 4/r32/esp +14236 $test-add-reg-to-reg:initialize-stmt: +14237 # var stmt/esi: (addr statement) +14238 68/push 0/imm32/next +14239 68/push 0/imm32/next +14240 57/push-edi/outputs +14241 68/push 0x11/imm32/alloc-id:fake +14242 56/push-esi/inouts +14243 68/push 0x11/imm32/alloc-id:fake +14244 68/push 0/imm32/operation +14245 68/push 0/imm32/operation +14246 68/push 1/imm32/tag:stmt1 +14247 89/<- %esi 4/r32/esp +14248 $test-add-reg-to-reg:initialize-stmt-operation: +14249 # stmt->operation = "add" +14250 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14251 (copy-array Heap "add" %eax) +14252 # convert +14253 c7 0/subop/copy *Curr-block-depth 0/imm32 +14254 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14255 (flush _test-output-buffered-file) +14256 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14262 # check output +14263 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") +14264 # . epilogue +14265 89/<- %esp 5/r32/ebp +14266 5d/pop-to-ebp +14267 c3/return +14268 +14269 test-add-reg-to-mem: +14270 # add-to var1 var2/reg +14271 # => +14272 # 01/add-to *(ebp+__) var2 +14273 # +14274 # . prologue +14275 55/push-ebp +14276 89/<- %ebp 4/r32/esp +14277 # setup +14278 (clear-stream _test-output-stream) +14279 (clear-stream $_test-output-buffered-file->buffer) +14280 $test-add-reg-to-mem:initialize-type: +14281 # var type/ecx: (payload tree type-id) = int +14282 68/push 0/imm32/right:null +14283 68/push 0/imm32/right:null +14284 68/push 0/imm32/left:unused +14285 68/push 1/imm32/value:int +14286 68/push 1/imm32/is-atom?:true +14287 68/push 0x11/imm32/alloc-id:fake:payload +14288 89/<- %ecx 4/r32/esp +14289 $test-add-reg-to-mem:initialize-var1: +14290 # var var1/ecx: (payload var) +14291 68/push 0/imm32/register +14292 68/push 0/imm32/register +14293 68/push 8/imm32/stack-offset +14294 68/push 1/imm32/block-depth +14295 51/push-ecx +14296 68/push 0x11/imm32/alloc-id:fake +14297 68/push 0/imm32/name +14298 68/push 0/imm32/name +14299 68/push 0x11/imm32/alloc-id:fake:payload +14300 89/<- %ecx 4/r32/esp +14301 $test-add-reg-to-mem:initialize-var1-name: +14302 # var1->name = "var1" +14303 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14304 (copy-array Heap "var1" %eax) +14305 $test-add-reg-to-mem:initialize-var2: +14306 # var var2/edx: (payload var) +14307 68/push 0/imm32/register +14308 68/push 0/imm32/register +14309 68/push 0/imm32/no-stack-offset +14310 68/push 1/imm32/block-depth +14311 ff 6/subop/push *(ecx+0x10) +14312 68/push 0x11/imm32/alloc-id:fake +14313 68/push 0/imm32/name +14314 68/push 0/imm32/name +14315 68/push 0x11/imm32/alloc-id:fake:payload +14316 89/<- %edx 4/r32/esp +14317 $test-add-reg-to-mem:initialize-var2-name: +14318 # var2->name = "var2" +14319 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14320 (copy-array Heap "var2" %eax) +14321 $test-add-reg-to-mem:initialize-var2-register: +14322 # var2->register = "ecx" +14323 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +14324 (copy-array Heap "ecx" %eax) +14325 $test-add-reg-to-mem:initialize-inouts: +14326 # var inouts/esi: (payload stmt-var) = [var2] +14327 68/push 0/imm32/is-deref:false +14328 68/push 0/imm32/next +14329 68/push 0/imm32/next +14330 52/push-edx/var2 +14331 68/push 0x11/imm32/alloc-id:fake +14332 68/push 0x11/imm32/alloc-id:fake:payload +14333 89/<- %esi 4/r32/esp +14334 # inouts = [var1, var2] +14335 68/push 0/imm32/is-deref:false +14336 56/push-esi/next +14337 68/push 0x11/imm32/alloc-id:fake +14338 51/push-ecx/var1 +14339 68/push 0x11/imm32/alloc-id:fake +14340 68/push 0x11/imm32/alloc-id:fake:payload +14341 89/<- %esi 4/r32/esp +14342 $test-add-reg-to-mem:initialize-stmt: +14343 # var stmt/esi: (addr statement) +14344 68/push 0/imm32/next +14345 68/push 0/imm32/next +14346 68/push 0/imm32/outputs +14347 68/push 0/imm32/outputs +14348 56/push-esi/inouts +14349 68/push 0x11/imm32/alloc-id:fake +14350 68/push 0/imm32/operation +14351 68/push 0/imm32/operation +14352 68/push 1/imm32/tag:stmt1 +14353 89/<- %esi 4/r32/esp +14354 $test-add-reg-to-mem:initialize-stmt-operation: +14355 # stmt->operation = "add-to" +14356 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14357 (copy-array Heap "add-to" %eax) +14358 # convert +14359 c7 0/subop/copy *Curr-block-depth 0/imm32 +14360 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14361 (flush _test-output-buffered-file) +14362 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14368 # check output +14369 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") +14370 # . epilogue +14371 89/<- %esp 5/r32/ebp +14372 5d/pop-to-ebp +14373 c3/return +14374 +14375 test-add-mem-to-reg: +14376 # var1/reg <- add var2 +14377 # => +14378 # 03/add *(ebp+__) var1 +14379 # +14380 # . prologue +14381 55/push-ebp +14382 89/<- %ebp 4/r32/esp +14383 # setup +14384 (clear-stream _test-output-stream) +14385 (clear-stream $_test-output-buffered-file->buffer) +14386 $test-add-mem-to-reg:initialize-type: +14387 # var type/ecx: (payload tree type-id) = int +14388 68/push 0/imm32/right:null +14389 68/push 0/imm32/right:null +14390 68/push 0/imm32/left:unused +14391 68/push 1/imm32/value:int +14392 68/push 1/imm32/is-atom?:true +14393 68/push 0x11/imm32/alloc-id:fake:payload +14394 89/<- %ecx 4/r32/esp +14395 $test-add-mem-to-reg:initialize-var: +14396 # var var1/ecx: (payload var) +14397 68/push 0/imm32/register +14398 68/push 0/imm32/register +14399 68/push 0/imm32/no-stack-offset +14400 68/push 1/imm32/block-depth +14401 51/push-ecx +14402 68/push 0x11/imm32/alloc-id:fake +14403 68/push 0/imm32/name +14404 68/push 0/imm32/name +14405 68/push 0x11/imm32/alloc-id:fake:payload +14406 89/<- %ecx 4/r32/esp +14407 $test-add-mem-to-reg:initialize-var-name: +14408 # var1->name = "foo" +14409 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14410 (copy-array Heap "var1" %eax) +14411 $test-add-mem-to-reg:initialize-var-register: +14412 # var1->register = "eax" +14413 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14414 (copy-array Heap "eax" %eax) +14415 $test-add-mem-to-reg:initialize-var2: +14416 # var var2/edx: (payload var) +14417 68/push 0/imm32/register +14418 68/push 0/imm32/register +14419 68/push 8/imm32/stack-offset +14420 68/push 1/imm32/block-depth +14421 ff 6/subop/push *(ecx+0x10) +14422 68/push 0x11/imm32/alloc-id:fake +14423 68/push 0/imm32/name +14424 68/push 0/imm32/name +14425 68/push 0x11/imm32/alloc-id:fake:payload +14426 89/<- %edx 4/r32/esp +14427 $test-add-mem-to-reg:initialize-var2-name: +14428 # var2->name = "var2" +14429 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14430 (copy-array Heap "var2" %eax) +14431 $test-add-mem-to-reg:initialize-inouts: +14432 # var inouts/esi: (payload stmt-var) = [var2] +14433 68/push 0/imm32/is-deref:false +14434 68/push 0/imm32/next +14435 68/push 0/imm32/next +14436 52/push-edx/var2 +14437 68/push 0x11/imm32/alloc-id:fake +14438 68/push 0x11/imm32/alloc-id:fake:payload +14439 89/<- %esi 4/r32/esp +14440 $test-add-mem-to-reg:initialize-outputs: +14441 # var outputs/edi: (payload stmt-var) = [var1] +14442 68/push 0/imm32/is-deref:false +14443 68/push 0/imm32/next 14444 68/push 0/imm32/next -14445 68/push 0/imm32/next -14446 57/push-edi/outputs -14447 68/push 0x11/imm32/alloc-id:fake -14448 56/push-esi/inouts -14449 68/push 0x11/imm32/alloc-id:fake -14450 68/push 0/imm32/operation -14451 68/push 0/imm32/operation -14452 68/push 1/imm32/tag:stmt1 -14453 89/<- %esi 4/r32/esp -14454 $test-add-mem-to-reg:initialize-stmt-operation: -14455 # stmt->operation = "add" -14456 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14457 (copy-array Heap "add" %eax) -14458 # convert -14459 c7 0/subop/copy *Curr-block-depth 0/imm32 -14460 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14461 (flush _test-output-buffered-file) -14462 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14468 # check output -14469 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") -14470 # . epilogue -14471 89/<- %esp 5/r32/ebp -14472 5d/pop-to-ebp -14473 c3/return -14474 -14475 test-add-literal-to-eax: -14476 # var1/eax <- add 0x34 -14477 # => -14478 # 05/add-to-eax 0x34/imm32 -14479 # -14480 # . prologue -14481 55/push-ebp -14482 89/<- %ebp 4/r32/esp -14483 # setup -14484 (clear-stream _test-output-stream) -14485 (clear-stream $_test-output-buffered-file->buffer) -14486 $test-add-literal-to-eax:initialize-var-type: -14487 # var type/ecx: (payload tree type-id) = int -14488 68/push 0/imm32/right:null -14489 68/push 0/imm32/right:null -14490 68/push 0/imm32/left:unused -14491 68/push 1/imm32/value:int -14492 68/push 1/imm32/is-atom?:true -14493 68/push 0x11/imm32/alloc-id:fake:payload -14494 89/<- %ecx 4/r32/esp -14495 $test-add-literal-to-eax:initialize-var: -14496 # var v/ecx: (payload var) -14497 68/push 0/imm32/register -14498 68/push 0/imm32/register -14499 68/push 0/imm32/no-stack-offset -14500 68/push 1/imm32/block-depth -14501 51/push-ecx -14502 68/push 0x11/imm32/alloc-id:fake -14503 68/push 0/imm32/name -14504 68/push 0/imm32/name -14505 68/push 0x11/imm32/alloc-id:fake:payload -14506 89/<- %ecx 4/r32/esp -14507 $test-add-literal-to-eax:initialize-var-name: -14508 # v->name = "v" -14509 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14510 (copy-array Heap "v" %eax) -14511 $test-add-literal-to-eax:initialize-var-register: -14512 # v->register = "eax" -14513 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14514 (copy-array Heap "eax" %eax) -14515 $test-add-literal-to-eax:initialize-literal-type: -14516 # var type/edx: (payload tree type-id) = literal -14517 68/push 0/imm32/right:null -14518 68/push 0/imm32/right:null -14519 68/push 0/imm32/left:unused -14520 68/push 0/imm32/value:literal -14521 68/push 1/imm32/is-atom?:true -14522 68/push 0x11/imm32/alloc-id:fake:payload -14523 89/<- %edx 4/r32/esp -14524 $test-add-literal-to-eax:initialize-literal: -14525 # var l/edx: (payload var) -14526 68/push 0/imm32/register -14527 68/push 0/imm32/register -14528 68/push 0/imm32/no-stack-offset -14529 68/push 1/imm32/block-depth -14530 52/push-edx -14531 68/push 0x11/imm32/alloc-id:fake -14532 68/push 0/imm32/name -14533 68/push 0/imm32/name -14534 68/push 0x11/imm32/alloc-id:fake:payload -14535 89/<- %edx 4/r32/esp -14536 $test-add-literal-to-eax:initialize-literal-value: -14537 # l->name = "0x34" -14538 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14539 (copy-array Heap "0x34" %eax) -14540 $test-add-literal-to-eax:initialize-inouts: -14541 # var inouts/esi: (payload stmt-var) = [l] -14542 68/push 0/imm32/is-deref:false -14543 68/push 0/imm32/next -14544 68/push 0/imm32/next -14545 52/push-edx/l -14546 68/push 0x11/imm32/alloc-id:fake -14547 68/push 0x11/imm32/alloc-id:fake:payload -14548 89/<- %esi 4/r32/esp -14549 $test-add-literal-to-eax:initialize-outputs: -14550 # var outputs/edi: (payload stmt-var) = [v] -14551 68/push 0/imm32/is-deref:false -14552 68/push 0/imm32/next -14553 68/push 0/imm32/next -14554 51/push-ecx/v -14555 68/push 0x11/imm32/alloc-id:fake -14556 68/push 0x11/imm32/alloc-id:fake:payload -14557 89/<- %edi 4/r32/esp -14558 $test-add-literal-to-eax:initialize-stmt: -14559 # var stmt/esi: (addr statement) +14445 51/push-ecx/var1 +14446 68/push 0x11/imm32/alloc-id:fake +14447 68/push 0x11/imm32/alloc-id:fake:payload +14448 89/<- %edi 4/r32/esp +14449 $test-add-mem-to-reg:initialize-stmt: +14450 # var stmt/esi: (addr statement) +14451 68/push 0/imm32/next +14452 68/push 0/imm32/next +14453 57/push-edi/outputs +14454 68/push 0x11/imm32/alloc-id:fake +14455 56/push-esi/inouts +14456 68/push 0x11/imm32/alloc-id:fake +14457 68/push 0/imm32/operation +14458 68/push 0/imm32/operation +14459 68/push 1/imm32/tag:stmt1 +14460 89/<- %esi 4/r32/esp +14461 $test-add-mem-to-reg:initialize-stmt-operation: +14462 # stmt->operation = "add" +14463 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14464 (copy-array Heap "add" %eax) +14465 # convert +14466 c7 0/subop/copy *Curr-block-depth 0/imm32 +14467 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14468 (flush _test-output-buffered-file) +14469 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14475 # check output +14476 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") +14477 # . epilogue +14478 89/<- %esp 5/r32/ebp +14479 5d/pop-to-ebp +14480 c3/return +14481 +14482 test-add-literal-to-eax: +14483 # var1/eax <- add 0x34 +14484 # => +14485 # 05/add-to-eax 0x34/imm32 +14486 # +14487 # . prologue +14488 55/push-ebp +14489 89/<- %ebp 4/r32/esp +14490 # setup +14491 (clear-stream _test-output-stream) +14492 (clear-stream $_test-output-buffered-file->buffer) +14493 $test-add-literal-to-eax:initialize-var-type: +14494 # var type/ecx: (payload tree type-id) = int +14495 68/push 0/imm32/right:null +14496 68/push 0/imm32/right:null +14497 68/push 0/imm32/left:unused +14498 68/push 1/imm32/value:int +14499 68/push 1/imm32/is-atom?:true +14500 68/push 0x11/imm32/alloc-id:fake:payload +14501 89/<- %ecx 4/r32/esp +14502 $test-add-literal-to-eax:initialize-var: +14503 # var v/ecx: (payload var) +14504 68/push 0/imm32/register +14505 68/push 0/imm32/register +14506 68/push 0/imm32/no-stack-offset +14507 68/push 1/imm32/block-depth +14508 51/push-ecx +14509 68/push 0x11/imm32/alloc-id:fake +14510 68/push 0/imm32/name +14511 68/push 0/imm32/name +14512 68/push 0x11/imm32/alloc-id:fake:payload +14513 89/<- %ecx 4/r32/esp +14514 $test-add-literal-to-eax:initialize-var-name: +14515 # v->name = "v" +14516 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14517 (copy-array Heap "v" %eax) +14518 $test-add-literal-to-eax:initialize-var-register: +14519 # v->register = "eax" +14520 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14521 (copy-array Heap "eax" %eax) +14522 $test-add-literal-to-eax:initialize-literal-type: +14523 # var type/edx: (payload tree type-id) = literal +14524 68/push 0/imm32/right:null +14525 68/push 0/imm32/right:null +14526 68/push 0/imm32/left:unused +14527 68/push 0/imm32/value:literal +14528 68/push 1/imm32/is-atom?:true +14529 68/push 0x11/imm32/alloc-id:fake:payload +14530 89/<- %edx 4/r32/esp +14531 $test-add-literal-to-eax:initialize-literal: +14532 # var l/edx: (payload var) +14533 68/push 0/imm32/register +14534 68/push 0/imm32/register +14535 68/push 0/imm32/no-stack-offset +14536 68/push 1/imm32/block-depth +14537 52/push-edx +14538 68/push 0x11/imm32/alloc-id:fake +14539 68/push 0/imm32/name +14540 68/push 0/imm32/name +14541 68/push 0x11/imm32/alloc-id:fake:payload +14542 89/<- %edx 4/r32/esp +14543 $test-add-literal-to-eax:initialize-literal-value: +14544 # l->name = "0x34" +14545 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14546 (copy-array Heap "0x34" %eax) +14547 $test-add-literal-to-eax:initialize-inouts: +14548 # var inouts/esi: (payload stmt-var) = [l] +14549 68/push 0/imm32/is-deref:false +14550 68/push 0/imm32/next +14551 68/push 0/imm32/next +14552 52/push-edx/l +14553 68/push 0x11/imm32/alloc-id:fake +14554 68/push 0x11/imm32/alloc-id:fake:payload +14555 89/<- %esi 4/r32/esp +14556 $test-add-literal-to-eax:initialize-outputs: +14557 # var outputs/edi: (payload stmt-var) = [v] +14558 68/push 0/imm32/is-deref:false +14559 68/push 0/imm32/next 14560 68/push 0/imm32/next -14561 68/push 0/imm32/next -14562 57/push-edi/outputs -14563 68/push 0x11/imm32/alloc-id:fake -14564 56/push-esi/inouts -14565 68/push 0x11/imm32/alloc-id:fake -14566 68/push 0/imm32/operation -14567 68/push 0/imm32/operation -14568 68/push 1/imm32/tag:stmt1 -14569 89/<- %esi 4/r32/esp -14570 $test-add-literal-to-eax:initialize-stmt-operation: -14571 # stmt->operation = "add" -14572 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14573 (copy-array Heap "add" %eax) -14574 # convert -14575 c7 0/subop/copy *Curr-block-depth 0/imm32 -14576 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14577 (flush _test-output-buffered-file) -14578 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14584 # check output -14585 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") -14586 # . epilogue -14587 89/<- %esp 5/r32/ebp -14588 5d/pop-to-ebp -14589 c3/return -14590 -14591 test-add-literal-to-reg: -14592 # var1/ecx <- add 0x34 -14593 # => -14594 # 81 0/subop/add %ecx 0x34/imm32 -14595 # -14596 # . prologue -14597 55/push-ebp -14598 89/<- %ebp 4/r32/esp -14599 # setup -14600 (clear-stream _test-output-stream) -14601 (clear-stream $_test-output-buffered-file->buffer) -14602 $test-add-literal-to-reg:initialize-var-type: -14603 # var type/ecx: (payload tree type-id) = int -14604 68/push 0/imm32/right:null -14605 68/push 0/imm32/right:null -14606 68/push 0/imm32/left:unused -14607 68/push 1/imm32/value:int -14608 68/push 1/imm32/is-atom?:true -14609 68/push 0x11/imm32/alloc-id:fake:payload -14610 89/<- %ecx 4/r32/esp -14611 $test-add-literal-to-reg:initialize-var: -14612 # var v/ecx: (payload var) -14613 68/push 0/imm32/register -14614 68/push 0/imm32/register -14615 68/push 0/imm32/no-stack-offset -14616 68/push 1/imm32/block-depth -14617 51/push-ecx -14618 68/push 0x11/imm32/alloc-id:fake -14619 68/push 0/imm32/name -14620 68/push 0/imm32/name -14621 68/push 0x11/imm32/alloc-id:fake:payload -14622 89/<- %ecx 4/r32/esp -14623 $test-add-literal-to-reg:initialize-var-name: -14624 # v->name = "v" -14625 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14626 (copy-array Heap "v" %eax) -14627 $test-add-literal-to-reg:initialize-var-register: -14628 # v->register = "ecx" -14629 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14630 (copy-array Heap "ecx" %eax) -14631 $test-add-literal-to-reg:initialize-literal-type: -14632 # var type/edx: (payload tree type-id) = literal -14633 68/push 0/imm32/right:null -14634 68/push 0/imm32/right:null -14635 68/push 0/imm32/left:unused -14636 68/push 0/imm32/value:literal -14637 68/push 1/imm32/is-atom?:true -14638 68/push 0x11/imm32/alloc-id:fake:payload -14639 89/<- %edx 4/r32/esp -14640 $test-add-literal-to-reg:initialize-literal: -14641 # var l/edx: (payload var) -14642 68/push 0/imm32/register -14643 68/push 0/imm32/register -14644 68/push 0/imm32/no-stack-offset -14645 68/push 1/imm32/block-depth -14646 52/push-edx -14647 68/push 0x11/imm32/alloc-id:fake -14648 68/push 0/imm32/name -14649 68/push 0/imm32/name -14650 68/push 0x11/imm32/alloc-id:fake:payload -14651 89/<- %edx 4/r32/esp -14652 $test-add-literal-to-reg:initialize-literal-value: -14653 # l->name = "0x34" -14654 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14655 (copy-array Heap "0x34" %eax) -14656 $test-add-literal-to-reg:initialize-inouts: -14657 # var inouts/esi: (payload stmt-var) = [l] -14658 68/push 0/imm32/is-deref:false -14659 68/push 0/imm32/next -14660 68/push 0/imm32/next -14661 52/push-edx/l -14662 68/push 0x11/imm32/alloc-id:fake -14663 68/push 0x11/imm32/alloc-id:fake:payload -14664 89/<- %esi 4/r32/esp -14665 $test-add-literal-to-reg:initialize-outputs: -14666 # var outputs/edi: (payload stmt-var) = [v] -14667 68/push 0/imm32/is-deref:false -14668 68/push 0/imm32/next -14669 68/push 0/imm32/next -14670 51/push-ecx/v -14671 68/push 0x11/imm32/alloc-id:fake -14672 68/push 0x11/imm32/alloc-id:fake:payload -14673 89/<- %edi 4/r32/esp -14674 $test-add-literal-to-reg:initialize-stmt: -14675 # var stmt/esi: (addr statement) +14561 51/push-ecx/v +14562 68/push 0x11/imm32/alloc-id:fake +14563 68/push 0x11/imm32/alloc-id:fake:payload +14564 89/<- %edi 4/r32/esp +14565 $test-add-literal-to-eax:initialize-stmt: +14566 # var stmt/esi: (addr statement) +14567 68/push 0/imm32/next +14568 68/push 0/imm32/next +14569 57/push-edi/outputs +14570 68/push 0x11/imm32/alloc-id:fake +14571 56/push-esi/inouts +14572 68/push 0x11/imm32/alloc-id:fake +14573 68/push 0/imm32/operation +14574 68/push 0/imm32/operation +14575 68/push 1/imm32/tag:stmt1 +14576 89/<- %esi 4/r32/esp +14577 $test-add-literal-to-eax:initialize-stmt-operation: +14578 # stmt->operation = "add" +14579 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14580 (copy-array Heap "add" %eax) +14581 # convert +14582 c7 0/subop/copy *Curr-block-depth 0/imm32 +14583 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14584 (flush _test-output-buffered-file) +14585 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14591 # check output +14592 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") +14593 # . epilogue +14594 89/<- %esp 5/r32/ebp +14595 5d/pop-to-ebp +14596 c3/return +14597 +14598 test-add-literal-to-reg: +14599 # var1/ecx <- add 0x34 +14600 # => +14601 # 81 0/subop/add %ecx 0x34/imm32 +14602 # +14603 # . prologue +14604 55/push-ebp +14605 89/<- %ebp 4/r32/esp +14606 # setup +14607 (clear-stream _test-output-stream) +14608 (clear-stream $_test-output-buffered-file->buffer) +14609 $test-add-literal-to-reg:initialize-var-type: +14610 # var type/ecx: (payload tree type-id) = int +14611 68/push 0/imm32/right:null +14612 68/push 0/imm32/right:null +14613 68/push 0/imm32/left:unused +14614 68/push 1/imm32/value:int +14615 68/push 1/imm32/is-atom?:true +14616 68/push 0x11/imm32/alloc-id:fake:payload +14617 89/<- %ecx 4/r32/esp +14618 $test-add-literal-to-reg:initialize-var: +14619 # var v/ecx: (payload var) +14620 68/push 0/imm32/register +14621 68/push 0/imm32/register +14622 68/push 0/imm32/no-stack-offset +14623 68/push 1/imm32/block-depth +14624 51/push-ecx +14625 68/push 0x11/imm32/alloc-id:fake +14626 68/push 0/imm32/name +14627 68/push 0/imm32/name +14628 68/push 0x11/imm32/alloc-id:fake:payload +14629 89/<- %ecx 4/r32/esp +14630 $test-add-literal-to-reg:initialize-var-name: +14631 # v->name = "v" +14632 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14633 (copy-array Heap "v" %eax) +14634 $test-add-literal-to-reg:initialize-var-register: +14635 # v->register = "ecx" +14636 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14637 (copy-array Heap "ecx" %eax) +14638 $test-add-literal-to-reg:initialize-literal-type: +14639 # var type/edx: (payload tree type-id) = literal +14640 68/push 0/imm32/right:null +14641 68/push 0/imm32/right:null +14642 68/push 0/imm32/left:unused +14643 68/push 0/imm32/value:literal +14644 68/push 1/imm32/is-atom?:true +14645 68/push 0x11/imm32/alloc-id:fake:payload +14646 89/<- %edx 4/r32/esp +14647 $test-add-literal-to-reg:initialize-literal: +14648 # var l/edx: (payload var) +14649 68/push 0/imm32/register +14650 68/push 0/imm32/register +14651 68/push 0/imm32/no-stack-offset +14652 68/push 1/imm32/block-depth +14653 52/push-edx +14654 68/push 0x11/imm32/alloc-id:fake +14655 68/push 0/imm32/name +14656 68/push 0/imm32/name +14657 68/push 0x11/imm32/alloc-id:fake:payload +14658 89/<- %edx 4/r32/esp +14659 $test-add-literal-to-reg:initialize-literal-value: +14660 # l->name = "0x34" +14661 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14662 (copy-array Heap "0x34" %eax) +14663 $test-add-literal-to-reg:initialize-inouts: +14664 # var inouts/esi: (payload stmt-var) = [l] +14665 68/push 0/imm32/is-deref:false +14666 68/push 0/imm32/next +14667 68/push 0/imm32/next +14668 52/push-edx/l +14669 68/push 0x11/imm32/alloc-id:fake +14670 68/push 0x11/imm32/alloc-id:fake:payload +14671 89/<- %esi 4/r32/esp +14672 $test-add-literal-to-reg:initialize-outputs: +14673 # var outputs/edi: (payload stmt-var) = [v] +14674 68/push 0/imm32/is-deref:false +14675 68/push 0/imm32/next 14676 68/push 0/imm32/next -14677 68/push 0/imm32/next -14678 57/push-edi/outputs -14679 68/push 0x11/imm32/alloc-id:fake -14680 56/push-esi/inouts -14681 68/push 0x11/imm32/alloc-id:fake -14682 68/push 0/imm32/operation -14683 68/push 0/imm32/operation -14684 68/push 1/imm32/tag:stmt1 -14685 89/<- %esi 4/r32/esp -14686 $test-add-literal-to-reg:initialize-stmt-operation: -14687 # stmt->operation = "add" -14688 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14689 (copy-array Heap "add" %eax) -14690 # convert -14691 c7 0/subop/copy *Curr-block-depth 0/imm32 -14692 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14693 (flush _test-output-buffered-file) -14694 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14700 # check output -14701 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") -14702 # . epilogue -14703 89/<- %esp 5/r32/ebp -14704 5d/pop-to-ebp -14705 c3/return -14706 -14707 test-add-literal-to-mem: -14708 # add-to var1, 0x34 -14709 # => -14710 # 81 0/subop/add %eax 0x34/imm32 -14711 # -14712 # . prologue -14713 55/push-ebp -14714 89/<- %ebp 4/r32/esp -14715 # setup -14716 (clear-stream _test-output-stream) -14717 (clear-stream $_test-output-buffered-file->buffer) -14718 $test-add-literal-to-mem:initialize-type: -14719 # var type/ecx: (payload tree type-id) = int -14720 68/push 0/imm32/right:null -14721 68/push 0/imm32/right:null -14722 68/push 0/imm32/left:unused -14723 68/push 1/imm32/value:int -14724 68/push 1/imm32/is-atom?:true -14725 68/push 0x11/imm32/alloc-id:fake:payload -14726 89/<- %ecx 4/r32/esp -14727 $test-add-literal-to-mem:initialize-var1: -14728 # var var1/ecx: (payload var) -14729 68/push 0/imm32/register -14730 68/push 0/imm32/register -14731 68/push 8/imm32/stack-offset -14732 68/push 1/imm32/block-depth -14733 51/push-ecx -14734 68/push 0x11/imm32/alloc-id:fake -14735 68/push 0/imm32/name -14736 68/push 0/imm32/name -14737 68/push 0x11/imm32/alloc-id:fake:payload -14738 89/<- %ecx 4/r32/esp -14739 $test-add-literal-to-mem:initialize-var1-name: -14740 # var1->name = "var1" -14741 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14742 (copy-array Heap "var1" %eax) -14743 $test-add-literal-to-mem:initialize-literal-type: -14744 # var type/edx: (payload tree type-id) = literal -14745 68/push 0/imm32/right:null -14746 68/push 0/imm32/right:null -14747 68/push 0/imm32/left:unused -14748 68/push 0/imm32/value:literal -14749 68/push 1/imm32/is-atom?:true -14750 68/push 0x11/imm32/alloc-id:fake:payload -14751 89/<- %edx 4/r32/esp -14752 $test-add-literal-to-mem:initialize-literal: -14753 # var l/edx: (payload var) -14754 68/push 0/imm32/register -14755 68/push 0/imm32/register -14756 68/push 0/imm32/no-stack-offset -14757 68/push 1/imm32/block-depth -14758 52/push-edx -14759 68/push 0x11/imm32/alloc-id:fake -14760 68/push 0/imm32/name -14761 68/push 0/imm32/name -14762 68/push 0x11/imm32/alloc-id:fake:payload -14763 89/<- %edx 4/r32/esp -14764 $test-add-literal-to-mem:initialize-literal-value: -14765 # l->name = "0x34" -14766 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14767 (copy-array Heap "0x34" %eax) -14768 $test-add-literal-to-mem:initialize-inouts: -14769 # var inouts/esi: (payload stmt-var) = [l] -14770 68/push 0/imm32/is-deref:false -14771 68/push 0/imm32/next -14772 68/push 0/imm32/next -14773 52/push-edx/l -14774 68/push 0x11/imm32/alloc-id:fake -14775 68/push 0x11/imm32/alloc-id:fake:payload -14776 89/<- %esi 4/r32/esp -14777 # var inouts = (handle stmt-var) = [var1, var2] -14778 68/push 0/imm32/is-deref:false -14779 56/push-esi/next -14780 68/push 0x11/imm32/alloc-id:fake -14781 51/push-ecx/var1 -14782 68/push 0x11/imm32/alloc-id:fake -14783 68/push 0x11/imm32/alloc-id:fake:payload -14784 89/<- %esi 4/r32/esp -14785 $test-add-literal-to-mem:initialize-stmt: -14786 # var stmt/esi: (addr statement) -14787 68/push 0/imm32/next -14788 68/push 0/imm32/next -14789 68/push 0/imm32/outputs -14790 68/push 0/imm32/outputs -14791 56/push-esi/inouts -14792 68/push 0x11/imm32/alloc-id:fake -14793 68/push 0/imm32/operation -14794 68/push 0/imm32/operation -14795 68/push 1/imm32/tag:stmt1 -14796 89/<- %esi 4/r32/esp -14797 $test-add-literal-to-mem:initialize-stmt-operation: -14798 # stmt->operation = "add-to" -14799 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14800 (copy-array Heap "add-to" %eax) -14801 # convert -14802 c7 0/subop/copy *Curr-block-depth 0/imm32 -14803 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14804 (flush _test-output-buffered-file) -14805 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14811 # check output -14812 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") -14813 # . epilogue -14814 89/<- %esp 5/r32/ebp -14815 5d/pop-to-ebp -14816 c3/return -14817 -14818 test-compare-mem-with-reg: -14819 # compare var1, var2/eax -14820 # => -14821 # 39/compare *(ebp+___) 0/r32/eax -14822 # -14823 # . prologue -14824 55/push-ebp -14825 89/<- %ebp 4/r32/esp -14826 # setup -14827 (clear-stream _test-output-stream) -14828 (clear-stream $_test-output-buffered-file->buffer) -14829 $test-compare-mem-with-reg:initialize-type: -14830 # var type/ecx: (payload tree type-id) = int -14831 68/push 0/imm32/right:null -14832 68/push 0/imm32/right:null -14833 68/push 0/imm32/left:unused -14834 68/push 1/imm32/value:int -14835 68/push 1/imm32/is-atom?:true -14836 68/push 0x11/imm32/alloc-id:fake:payload -14837 89/<- %ecx 4/r32/esp -14838 $test-compare-mem-with-reg:initialize-var1: -14839 # var var1/ecx: (payload var) -14840 68/push 0/imm32/register -14841 68/push 0/imm32/register -14842 68/push 8/imm32/stack-offset -14843 68/push 1/imm32/block-depth -14844 51/push-ecx -14845 68/push 0x11/imm32/alloc-id:fake -14846 68/push 0/imm32/name -14847 68/push 0/imm32/name -14848 68/push 0x11/imm32/alloc-id:fake:payload -14849 89/<- %ecx 4/r32/esp -14850 $test-compare-mem-with-reg:initialize-var1-name: -14851 # var1->name = "var1" -14852 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14853 (copy-array Heap "var1" %eax) -14854 $test-compare-mem-with-reg:initialize-var2: -14855 # var var2/edx: (payload var) -14856 68/push 0/imm32/register -14857 68/push 0/imm32/register -14858 68/push 0/imm32/no-stack-offset -14859 68/push 1/imm32/block-depth -14860 ff 6/subop/push *(ecx+0x10) -14861 68/push 0x11/imm32/alloc-id:fake -14862 68/push 0/imm32/name -14863 68/push 0/imm32/name -14864 68/push 0x11/imm32/alloc-id:fake:payload -14865 89/<- %edx 4/r32/esp -14866 $test-compare-mem-with-reg:initialize-var2-name: -14867 # var2->name = "var2" -14868 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14869 (copy-array Heap "var2" %eax) -14870 $test-compare-mem-with-reg:initialize-var2-register: -14871 # var2->register = "eax" -14872 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -14873 (copy-array Heap "eax" %eax) -14874 $test-compare-mem-with-reg:initialize-inouts: -14875 # var inouts/esi: (payload stmt-var) = [var2] -14876 68/push 0/imm32/is-deref:false -14877 68/push 0/imm32/next -14878 68/push 0/imm32/next -14879 52/push-edx/var2 -14880 68/push 0x11/imm32/alloc-id:fake -14881 68/push 0x11/imm32/alloc-id:fake:payload -14882 89/<- %esi 4/r32/esp -14883 # inouts = [var1, var2] -14884 68/push 0/imm32/is-deref:false -14885 56/push-esi/next -14886 68/push 0x11/imm32/alloc-id:fake -14887 51/push-ecx/var1 -14888 68/push 0x11/imm32/alloc-id:fake -14889 68/push 0x11/imm32/alloc-id:fake:payload -14890 89/<- %esi 4/r32/esp -14891 $test-compare-mem-with-reg:initialize-stmt: -14892 # var stmt/esi: (addr statement) -14893 68/push 0/imm32/next -14894 68/push 0/imm32/next -14895 68/push 0/imm32/outputs -14896 68/push 0/imm32/outputs -14897 56/push-esi/inouts -14898 68/push 0x11/imm32/alloc-id:fake -14899 68/push 0/imm32/operation -14900 68/push 0/imm32/operation -14901 68/push 1/imm32/tag:stmt1 -14902 89/<- %esi 4/r32/esp -14903 $test-compare-mem-with-reg:initialize-stmt-operation: -14904 # stmt->operation = "compare" -14905 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -14906 (copy-array Heap "compare" %eax) -14907 # convert -14908 c7 0/subop/copy *Curr-block-depth 0/imm32 -14909 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -14910 (flush _test-output-buffered-file) -14911 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -14917 # check output -14918 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") -14919 # . epilogue -14920 89/<- %esp 5/r32/ebp -14921 5d/pop-to-ebp -14922 c3/return -14923 -14924 test-compare-reg-with-mem: -14925 # compare var1/eax, var2 -14926 # => -14927 # 3b/compare<- *(ebp+___) 0/r32/eax -14928 # -14929 # . prologue -14930 55/push-ebp -14931 89/<- %ebp 4/r32/esp -14932 # setup -14933 (clear-stream _test-output-stream) -14934 (clear-stream $_test-output-buffered-file->buffer) -14935 $test-compare-reg-with-mem:initialize-type: -14936 # var type/ecx: (payload tree type-id) = int -14937 68/push 0/imm32/right:null -14938 68/push 0/imm32/right:null -14939 68/push 0/imm32/left:unused -14940 68/push 1/imm32/value:int -14941 68/push 1/imm32/is-atom?:true -14942 68/push 0x11/imm32/alloc-id:fake:payload -14943 89/<- %ecx 4/r32/esp -14944 $test-compare-reg-with-mem:initialize-var1: -14945 # var var1/ecx: (payload var) -14946 68/push 0/imm32/register -14947 68/push 0/imm32/register -14948 68/push 0/imm32/no-stack-offset -14949 68/push 1/imm32/block-depth -14950 51/push-ecx -14951 68/push 0x11/imm32/alloc-id:fake -14952 68/push 0/imm32/name -14953 68/push 0/imm32/name -14954 68/push 0x11/imm32/alloc-id:fake:payload -14955 89/<- %ecx 4/r32/esp -14956 $test-compare-reg-with-mem:initialize-var1-name: -14957 # var1->name = "var1" -14958 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -14959 (copy-array Heap "var1" %eax) -14960 $test-compare-reg-with-mem:initialize-var1-register: -14961 # var1->register = "eax" -14962 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -14963 (copy-array Heap "eax" %eax) -14964 $test-compare-reg-with-mem:initialize-var2: -14965 # var var2/edx: (payload var) -14966 68/push 0/imm32/register -14967 68/push 0/imm32/register -14968 68/push 8/imm32/stack-offset -14969 68/push 1/imm32/block-depth -14970 ff 6/subop/push *(ecx+0x10) -14971 68/push 0x11/imm32/alloc-id:fake -14972 68/push 0/imm32/name -14973 68/push 0/imm32/name -14974 68/push 0x11/imm32/alloc-id:fake:payload -14975 89/<- %edx 4/r32/esp -14976 $test-compare-reg-with-mem:initialize-var2-name: -14977 # var2->name = "var2" -14978 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -14979 (copy-array Heap "var2" %eax) -14980 $test-compare-reg-with-mem:initialize-inouts: -14981 # var inouts/esi: (payload stmt-var) = [var2] -14982 68/push 0/imm32/is-deref:false -14983 68/push 0/imm32/next -14984 68/push 0/imm32/next -14985 52/push-edx/var2 -14986 68/push 0x11/imm32/alloc-id:fake -14987 68/push 0x11/imm32/alloc-id:fake:payload -14988 89/<- %esi 4/r32/esp -14989 # inouts = [var1, var2] -14990 68/push 0/imm32/is-deref:false -14991 56/push-esi/next -14992 68/push 0x11/imm32/alloc-id:fake -14993 51/push-ecx/var1 -14994 68/push 0x11/imm32/alloc-id:fake -14995 68/push 0x11/imm32/alloc-id:fake:payload -14996 89/<- %esi 4/r32/esp -14997 $test-compare-reg-with-mem:initialize-stmt: -14998 # var stmt/esi: (addr statement) -14999 68/push 0/imm32/next -15000 68/push 0/imm32/next -15001 68/push 0/imm32/outputs -15002 68/push 0/imm32/outputs -15003 56/push-esi/inouts -15004 68/push 0x11/imm32/alloc-id:fake -15005 68/push 0/imm32/operation -15006 68/push 0/imm32/operation -15007 68/push 1/imm32/tag:stmt1 -15008 89/<- %esi 4/r32/esp -15009 $test-compare-reg-with-mem:initialize-stmt-operation: -15010 # stmt->operation = "compare" -15011 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15012 (copy-array Heap "compare" %eax) -15013 # convert -15014 c7 0/subop/copy *Curr-block-depth 0/imm32 -15015 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -15016 (flush _test-output-buffered-file) -15017 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15023 # check output -15024 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") -15025 # . epilogue -15026 89/<- %esp 5/r32/ebp -15027 5d/pop-to-ebp -15028 c3/return -15029 -15030 test-compare-mem-with-literal: -15031 # compare var1, 0x34 -15032 # => -15033 # 81 7/subop/compare *(ebp+___) 0x34/imm32 -15034 # -15035 # . prologue -15036 55/push-ebp -15037 89/<- %ebp 4/r32/esp -15038 # setup -15039 (clear-stream _test-output-stream) -15040 (clear-stream $_test-output-buffered-file->buffer) -15041 $test-compare-mem-with-literal:initialize-type: -15042 # var type/ecx: (payload tree type-id) = int -15043 68/push 0/imm32/right:null -15044 68/push 0/imm32/right:null -15045 68/push 0/imm32/left:unused -15046 68/push 1/imm32/value:int -15047 68/push 1/imm32/is-atom?:true -15048 68/push 0x11/imm32/alloc-id:fake:payload -15049 89/<- %ecx 4/r32/esp -15050 $test-compare-mem-with-literal:initialize-var1: -15051 # var var1/ecx: (payload var) -15052 68/push 0/imm32/register -15053 68/push 0/imm32/register -15054 68/push 8/imm32/stack-offset -15055 68/push 1/imm32/block-depth -15056 51/push-ecx -15057 68/push 0x11/imm32/alloc-id:fake -15058 68/push 0/imm32/name -15059 68/push 0/imm32/name -15060 68/push 0x11/imm32/alloc-id:fake:payload -15061 89/<- %ecx 4/r32/esp -15062 $test-compare-mem-with-literal:initialize-var1-name: -15063 # var1->name = "var1" -15064 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -15065 (copy-array Heap "var1" %eax) -15066 $test-compare-mem-with-literal:initialize-literal-type: -15067 # var type/edx: (payload tree type-id) = literal -15068 68/push 0/imm32/right:null -15069 68/push 0/imm32/right:null -15070 68/push 0/imm32/left:unused -15071 68/push 0/imm32/value:literal -15072 68/push 1/imm32/is-atom?:true -15073 68/push 0x11/imm32/alloc-id:fake:payload -15074 89/<- %edx 4/r32/esp -15075 $test-compare-mem-with-literal:initialize-literal: -15076 # var l/edx: (payload var) -15077 68/push 0/imm32/register -15078 68/push 0/imm32/register -15079 68/push 0/imm32/no-stack-offset -15080 68/push 1/imm32/block-depth -15081 52/push-edx -15082 68/push 0x11/imm32/alloc-id:fake -15083 68/push 0/imm32/name -15084 68/push 0/imm32/name -15085 68/push 0x11/imm32/alloc-id:fake:payload -15086 89/<- %edx 4/r32/esp -15087 $test-compare-mem-with-literal:initialize-literal-value: -15088 # l->name = "0x34" -15089 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -15090 (copy-array Heap "0x34" %eax) -15091 $test-compare-mem-with-literal:initialize-inouts: -15092 # var inouts/esi: (payload stmt-var) = [l] -15093 68/push 0/imm32/is-deref:false -15094 68/push 0/imm32/next -15095 68/push 0/imm32/next -15096 52/push-edx/l -15097 68/push 0x11/imm32/alloc-id:fake -15098 68/push 0x11/imm32/alloc-id:fake:payload -15099 89/<- %esi 4/r32/esp -15100 # var inouts = (handle stmt-var) = [var1, var2] -15101 68/push 0/imm32/is-deref:false -15102 56/push-esi/next -15103 68/push 0x11/imm32/alloc-id:fake -15104 51/push-ecx/var1 -15105 68/push 0x11/imm32/alloc-id:fake -15106 68/push 0x11/imm32/alloc-id:fake:payload -15107 89/<- %esi 4/r32/esp -15108 $test-compare-mem-with-literal:initialize-stmt: -15109 # var stmt/esi: (addr statement) -15110 68/push 0/imm32/next -15111 68/push 0/imm32/next -15112 68/push 0/imm32/outputs -15113 68/push 0/imm32/outputs -15114 56/push-esi/inouts -15115 68/push 0x11/imm32/alloc-id:fake -15116 68/push 0/imm32/operation -15117 68/push 0/imm32/operation -15118 68/push 1/imm32/tag:stmt1 -15119 89/<- %esi 4/r32/esp -15120 $test-compare-mem-with-literal:initialize-stmt-operation: -15121 # stmt->operation = "compare" -15122 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15123 (copy-array Heap "compare" %eax) -15124 # convert -15125 c7 0/subop/copy *Curr-block-depth 0/imm32 -15126 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -15127 (flush _test-output-buffered-file) -15128 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15134 # check output -15135 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") -15136 # . epilogue -15137 89/<- %esp 5/r32/ebp -15138 5d/pop-to-ebp -15139 c3/return -15140 -15141 test-compare-eax-with-literal: -15142 # compare var1/eax 0x34 -15143 # => -15144 # 3d/compare-eax-with 0x34/imm32 -15145 # -15146 # . prologue -15147 55/push-ebp -15148 89/<- %ebp 4/r32/esp -15149 # setup -15150 (clear-stream _test-output-stream) -15151 (clear-stream $_test-output-buffered-file->buffer) -15152 $test-compare-eax-with-literal:initialize-type: -15153 # var type/ecx: (payload tree type-id) = int -15154 68/push 0/imm32/right:null -15155 68/push 0/imm32/right:null -15156 68/push 0/imm32/left:unused -15157 68/push 1/imm32/value:int -15158 68/push 1/imm32/is-atom?:true -15159 68/push 0x11/imm32/alloc-id:fake:payload -15160 89/<- %ecx 4/r32/esp -15161 $test-compare-eax-with-literal:initialize-var1: -15162 # var var1/ecx: (payload var) -15163 68/push 0/imm32/register -15164 68/push 0/imm32/register -15165 68/push 0/imm32/no-stack-offset -15166 68/push 1/imm32/block-depth -15167 51/push-ecx -15168 68/push 0x11/imm32/alloc-id:fake -15169 68/push 0/imm32/name -15170 68/push 0/imm32/name -15171 68/push 0x11/imm32/alloc-id:fake:payload -15172 89/<- %ecx 4/r32/esp -15173 $test-compare-eax-with-literal:initialize-var1-name: -15174 # var1->name = "var1" -15175 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -15176 (copy-array Heap "var1" %eax) -15177 $test-compare-eax-with-literal:initialize-var1-register: -15178 # v->register = "eax" -15179 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -15180 (copy-array Heap "eax" %eax) -15181 $test-compare-eax-with-literal:initialize-literal-type: -15182 # var type/edx: (payload tree type-id) = literal -15183 68/push 0/imm32/right:null -15184 68/push 0/imm32/right:null -15185 68/push 0/imm32/left:unused -15186 68/push 0/imm32/value:literal -15187 68/push 1/imm32/is-atom?:true -15188 68/push 0x11/imm32/alloc-id:fake:payload -15189 89/<- %edx 4/r32/esp -15190 $test-compare-eax-with-literal:initialize-literal: -15191 # var l/edx: (payload var) -15192 68/push 0/imm32/register -15193 68/push 0/imm32/register -15194 68/push 0/imm32/no-stack-offset -15195 68/push 1/imm32/block-depth -15196 52/push-edx -15197 68/push 0x11/imm32/alloc-id:fake -15198 68/push 0/imm32/name -15199 68/push 0/imm32/name -15200 68/push 0x11/imm32/alloc-id:fake:payload -15201 89/<- %edx 4/r32/esp -15202 $test-compare-eax-with-literal:initialize-literal-value: -15203 # l->name = "0x34" -15204 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -15205 (copy-array Heap "0x34" %eax) -15206 $test-compare-eax-with-literal:initialize-inouts: -15207 # var inouts/esi: (payload stmt-var) = [l] -15208 68/push 0/imm32/is-deref:false -15209 68/push 0/imm32/next -15210 68/push 0/imm32/next -15211 52/push-edx/l -15212 68/push 0x11/imm32/alloc-id:fake -15213 68/push 0x11/imm32/alloc-id:fake:payload -15214 89/<- %esi 4/r32/esp -15215 # var inouts = (handle stmt-var) = [var1, var2] -15216 68/push 0/imm32/is-deref:false -15217 56/push-esi/next -15218 68/push 0x11/imm32/alloc-id:fake -15219 51/push-ecx/var1 -15220 68/push 0x11/imm32/alloc-id:fake -15221 68/push 0x11/imm32/alloc-id:fake:payload -15222 89/<- %esi 4/r32/esp -15223 $test-compare-eax-with-literal:initialize-stmt: -15224 # var stmt/esi: (addr statement) -15225 68/push 0/imm32/next -15226 68/push 0/imm32/next -15227 68/push 0/imm32/outputs -15228 68/push 0/imm32/outputs -15229 56/push-esi/inouts -15230 68/push 0x11/imm32/alloc-id:fake -15231 68/push 0/imm32/operation -15232 68/push 0/imm32/operation -15233 68/push 1/imm32/tag:stmt1 -15234 89/<- %esi 4/r32/esp -15235 $test-compare-eax-with-literal:initialize-stmt-operation: -15236 # stmt->operation = "compare" -15237 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15238 (copy-array Heap "compare" %eax) -15239 # convert -15240 c7 0/subop/copy *Curr-block-depth 0/imm32 -15241 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -15242 (flush _test-output-buffered-file) -15243 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15249 # check output -15250 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") -15251 # . epilogue -15252 89/<- %esp 5/r32/ebp -15253 5d/pop-to-ebp -15254 c3/return -15255 -15256 test-compare-reg-with-literal: -15257 # compare var1/ecx 0x34 -15258 # => -15259 # 81 7/subop/compare %ecx 0x34/imm32 -15260 # -15261 # . prologue -15262 55/push-ebp -15263 89/<- %ebp 4/r32/esp -15264 # setup -15265 (clear-stream _test-output-stream) -15266 (clear-stream $_test-output-buffered-file->buffer) -15267 $test-compare-reg-with-literal:initialize-type: -15268 # var type/ecx: (payload tree type-id) = int -15269 68/push 0/imm32/right:null -15270 68/push 0/imm32/right:null -15271 68/push 0/imm32/left:unused -15272 68/push 1/imm32/value:int -15273 68/push 1/imm32/is-atom?:true -15274 68/push 0x11/imm32/alloc-id:fake:payload -15275 89/<- %ecx 4/r32/esp -15276 $test-compare-reg-with-literal:initialize-var1: -15277 # var var1/ecx: (payload var) -15278 68/push 0/imm32/register -15279 68/push 0/imm32/register -15280 68/push 0/imm32/no-stack-offset -15281 68/push 1/imm32/block-depth -15282 51/push-ecx -15283 68/push 0x11/imm32/alloc-id:fake -15284 68/push 0/imm32/name -15285 68/push 0/imm32/name -15286 68/push 0x11/imm32/alloc-id:fake:payload -15287 89/<- %ecx 4/r32/esp -15288 $test-compare-reg-with-literal:initialize-var1-name: -15289 # var1->name = "var1" -15290 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -15291 (copy-array Heap "var1" %eax) -15292 $test-compare-reg-with-literal:initialize-var1-register: -15293 # v->register = "ecx" -15294 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -15295 (copy-array Heap "ecx" %eax) -15296 $test-compare-reg-with-literal:initialize-literal-type: -15297 # var type/edx: (payload tree type-id) = literal -15298 68/push 0/imm32/right:null -15299 68/push 0/imm32/right:null -15300 68/push 0/imm32/left:unused -15301 68/push 0/imm32/value:literal -15302 68/push 1/imm32/is-atom?:true -15303 68/push 0x11/imm32/alloc-id:fake:payload -15304 89/<- %edx 4/r32/esp -15305 $test-compare-reg-with-literal:initialize-literal: -15306 # var l/edx: (payload var) -15307 68/push 0/imm32/register -15308 68/push 0/imm32/register -15309 68/push 0/imm32/no-stack-offset -15310 68/push 1/imm32/block-depth -15311 52/push-edx -15312 68/push 0x11/imm32/alloc-id:fake -15313 68/push 0/imm32/name -15314 68/push 0/imm32/name -15315 68/push 0x11/imm32/alloc-id:fake:payload -15316 89/<- %edx 4/r32/esp -15317 $test-compare-reg-with-literal:initialize-literal-value: -15318 # l->name = "0x34" -15319 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -15320 (copy-array Heap "0x34" %eax) -15321 $test-compare-reg-with-literal:initialize-inouts: -15322 # var inouts/esi: (payload stmt-var) = [l] -15323 68/push 0/imm32/is-deref:false -15324 68/push 0/imm32/next -15325 68/push 0/imm32/next -15326 52/push-edx/l -15327 68/push 0x11/imm32/alloc-id:fake -15328 68/push 0x11/imm32/alloc-id:fake:payload -15329 89/<- %esi 4/r32/esp -15330 # var inouts = (handle stmt-var) = [var1, var2] -15331 68/push 0/imm32/is-deref:false -15332 56/push-esi/next -15333 68/push 0x11/imm32/alloc-id:fake -15334 51/push-ecx/var1 -15335 68/push 0x11/imm32/alloc-id:fake -15336 68/push 0x11/imm32/alloc-id:fake:payload -15337 89/<- %esi 4/r32/esp -15338 $test-compare-reg-with-literal:initialize-stmt: -15339 # var stmt/esi: (addr statement) -15340 68/push 0/imm32/next -15341 68/push 0/imm32/next -15342 68/push 0/imm32/outputs -15343 68/push 0/imm32/outputs -15344 56/push-esi/inouts -15345 68/push 0x11/imm32/alloc-id:fake -15346 68/push 0/imm32/operation -15347 68/push 0/imm32/operation -15348 68/push 1/imm32/tag:stmt1 -15349 89/<- %esi 4/r32/esp -15350 $test-compare-reg-with-literal:initialize-stmt-operation: -15351 # stmt->operation = "compare" -15352 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15353 (copy-array Heap "compare" %eax) -15354 # convert -15355 c7 0/subop/copy *Curr-block-depth 0/imm32 -15356 (emit-subx-stmt _test-output-buffered-file %esi Primitives) -15357 (flush _test-output-buffered-file) -15358 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15364 # check output -15365 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") -15366 # . epilogue -15367 89/<- %esp 5/r32/ebp -15368 5d/pop-to-ebp -15369 c3/return -15370 -15371 test-emit-subx-stmt-function-call: -15372 # Call a function on a variable on the stack. -15373 # f foo -15374 # => -15375 # (f *(ebp-8)) -15376 # (Changing the function name supports overloading in general, but here it -15377 # just serves to help disambiguate things.) -15378 # -15379 # There's a variable on the var stack as follows: -15380 # name: 'foo' -15381 # type: int -15382 # stack-offset: -8 -15383 # -15384 # There's nothing in primitives. +14677 51/push-ecx/v +14678 68/push 0x11/imm32/alloc-id:fake +14679 68/push 0x11/imm32/alloc-id:fake:payload +14680 89/<- %edi 4/r32/esp +14681 $test-add-literal-to-reg:initialize-stmt: +14682 # var stmt/esi: (addr statement) +14683 68/push 0/imm32/next +14684 68/push 0/imm32/next +14685 57/push-edi/outputs +14686 68/push 0x11/imm32/alloc-id:fake +14687 56/push-esi/inouts +14688 68/push 0x11/imm32/alloc-id:fake +14689 68/push 0/imm32/operation +14690 68/push 0/imm32/operation +14691 68/push 1/imm32/tag:stmt1 +14692 89/<- %esi 4/r32/esp +14693 $test-add-literal-to-reg:initialize-stmt-operation: +14694 # stmt->operation = "add" +14695 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14696 (copy-array Heap "add" %eax) +14697 # convert +14698 c7 0/subop/copy *Curr-block-depth 0/imm32 +14699 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14700 (flush _test-output-buffered-file) +14701 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14707 # check output +14708 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") +14709 # . epilogue +14710 89/<- %esp 5/r32/ebp +14711 5d/pop-to-ebp +14712 c3/return +14713 +14714 test-add-literal-to-mem: +14715 # add-to var1, 0x34 +14716 # => +14717 # 81 0/subop/add %eax 0x34/imm32 +14718 # +14719 # . prologue +14720 55/push-ebp +14721 89/<- %ebp 4/r32/esp +14722 # setup +14723 (clear-stream _test-output-stream) +14724 (clear-stream $_test-output-buffered-file->buffer) +14725 $test-add-literal-to-mem:initialize-type: +14726 # var type/ecx: (payload tree type-id) = int +14727 68/push 0/imm32/right:null +14728 68/push 0/imm32/right:null +14729 68/push 0/imm32/left:unused +14730 68/push 1/imm32/value:int +14731 68/push 1/imm32/is-atom?:true +14732 68/push 0x11/imm32/alloc-id:fake:payload +14733 89/<- %ecx 4/r32/esp +14734 $test-add-literal-to-mem:initialize-var1: +14735 # var var1/ecx: (payload var) +14736 68/push 0/imm32/register +14737 68/push 0/imm32/register +14738 68/push 8/imm32/stack-offset +14739 68/push 1/imm32/block-depth +14740 51/push-ecx +14741 68/push 0x11/imm32/alloc-id:fake +14742 68/push 0/imm32/name +14743 68/push 0/imm32/name +14744 68/push 0x11/imm32/alloc-id:fake:payload +14745 89/<- %ecx 4/r32/esp +14746 $test-add-literal-to-mem:initialize-var1-name: +14747 # var1->name = "var1" +14748 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14749 (copy-array Heap "var1" %eax) +14750 $test-add-literal-to-mem:initialize-literal-type: +14751 # var type/edx: (payload tree type-id) = literal +14752 68/push 0/imm32/right:null +14753 68/push 0/imm32/right:null +14754 68/push 0/imm32/left:unused +14755 68/push 0/imm32/value:literal +14756 68/push 1/imm32/is-atom?:true +14757 68/push 0x11/imm32/alloc-id:fake:payload +14758 89/<- %edx 4/r32/esp +14759 $test-add-literal-to-mem:initialize-literal: +14760 # var l/edx: (payload var) +14761 68/push 0/imm32/register +14762 68/push 0/imm32/register +14763 68/push 0/imm32/no-stack-offset +14764 68/push 1/imm32/block-depth +14765 52/push-edx +14766 68/push 0x11/imm32/alloc-id:fake +14767 68/push 0/imm32/name +14768 68/push 0/imm32/name +14769 68/push 0x11/imm32/alloc-id:fake:payload +14770 89/<- %edx 4/r32/esp +14771 $test-add-literal-to-mem:initialize-literal-value: +14772 # l->name = "0x34" +14773 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14774 (copy-array Heap "0x34" %eax) +14775 $test-add-literal-to-mem:initialize-inouts: +14776 # var inouts/esi: (payload stmt-var) = [l] +14777 68/push 0/imm32/is-deref:false +14778 68/push 0/imm32/next +14779 68/push 0/imm32/next +14780 52/push-edx/l +14781 68/push 0x11/imm32/alloc-id:fake +14782 68/push 0x11/imm32/alloc-id:fake:payload +14783 89/<- %esi 4/r32/esp +14784 # var inouts = (handle stmt-var) = [var1, var2] +14785 68/push 0/imm32/is-deref:false +14786 56/push-esi/next +14787 68/push 0x11/imm32/alloc-id:fake +14788 51/push-ecx/var1 +14789 68/push 0x11/imm32/alloc-id:fake +14790 68/push 0x11/imm32/alloc-id:fake:payload +14791 89/<- %esi 4/r32/esp +14792 $test-add-literal-to-mem:initialize-stmt: +14793 # var stmt/esi: (addr statement) +14794 68/push 0/imm32/next +14795 68/push 0/imm32/next +14796 68/push 0/imm32/outputs +14797 68/push 0/imm32/outputs +14798 56/push-esi/inouts +14799 68/push 0x11/imm32/alloc-id:fake +14800 68/push 0/imm32/operation +14801 68/push 0/imm32/operation +14802 68/push 1/imm32/tag:stmt1 +14803 89/<- %esi 4/r32/esp +14804 $test-add-literal-to-mem:initialize-stmt-operation: +14805 # stmt->operation = "add-to" +14806 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14807 (copy-array Heap "add-to" %eax) +14808 # convert +14809 c7 0/subop/copy *Curr-block-depth 0/imm32 +14810 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14811 (flush _test-output-buffered-file) +14812 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14818 # check output +14819 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") +14820 # . epilogue +14821 89/<- %esp 5/r32/ebp +14822 5d/pop-to-ebp +14823 c3/return +14824 +14825 test-compare-mem-with-reg: +14826 # compare var1, var2/eax +14827 # => +14828 # 39/compare *(ebp+___) 0/r32/eax +14829 # +14830 # . prologue +14831 55/push-ebp +14832 89/<- %ebp 4/r32/esp +14833 # setup +14834 (clear-stream _test-output-stream) +14835 (clear-stream $_test-output-buffered-file->buffer) +14836 $test-compare-mem-with-reg:initialize-type: +14837 # var type/ecx: (payload tree type-id) = int +14838 68/push 0/imm32/right:null +14839 68/push 0/imm32/right:null +14840 68/push 0/imm32/left:unused +14841 68/push 1/imm32/value:int +14842 68/push 1/imm32/is-atom?:true +14843 68/push 0x11/imm32/alloc-id:fake:payload +14844 89/<- %ecx 4/r32/esp +14845 $test-compare-mem-with-reg:initialize-var1: +14846 # var var1/ecx: (payload var) +14847 68/push 0/imm32/register +14848 68/push 0/imm32/register +14849 68/push 8/imm32/stack-offset +14850 68/push 1/imm32/block-depth +14851 51/push-ecx +14852 68/push 0x11/imm32/alloc-id:fake +14853 68/push 0/imm32/name +14854 68/push 0/imm32/name +14855 68/push 0x11/imm32/alloc-id:fake:payload +14856 89/<- %ecx 4/r32/esp +14857 $test-compare-mem-with-reg:initialize-var1-name: +14858 # var1->name = "var1" +14859 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14860 (copy-array Heap "var1" %eax) +14861 $test-compare-mem-with-reg:initialize-var2: +14862 # var var2/edx: (payload var) +14863 68/push 0/imm32/register +14864 68/push 0/imm32/register +14865 68/push 0/imm32/no-stack-offset +14866 68/push 1/imm32/block-depth +14867 ff 6/subop/push *(ecx+0x10) +14868 68/push 0x11/imm32/alloc-id:fake +14869 68/push 0/imm32/name +14870 68/push 0/imm32/name +14871 68/push 0x11/imm32/alloc-id:fake:payload +14872 89/<- %edx 4/r32/esp +14873 $test-compare-mem-with-reg:initialize-var2-name: +14874 # var2->name = "var2" +14875 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14876 (copy-array Heap "var2" %eax) +14877 $test-compare-mem-with-reg:initialize-var2-register: +14878 # var2->register = "eax" +14879 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +14880 (copy-array Heap "eax" %eax) +14881 $test-compare-mem-with-reg:initialize-inouts: +14882 # var inouts/esi: (payload stmt-var) = [var2] +14883 68/push 0/imm32/is-deref:false +14884 68/push 0/imm32/next +14885 68/push 0/imm32/next +14886 52/push-edx/var2 +14887 68/push 0x11/imm32/alloc-id:fake +14888 68/push 0x11/imm32/alloc-id:fake:payload +14889 89/<- %esi 4/r32/esp +14890 # inouts = [var1, var2] +14891 68/push 0/imm32/is-deref:false +14892 56/push-esi/next +14893 68/push 0x11/imm32/alloc-id:fake +14894 51/push-ecx/var1 +14895 68/push 0x11/imm32/alloc-id:fake +14896 68/push 0x11/imm32/alloc-id:fake:payload +14897 89/<- %esi 4/r32/esp +14898 $test-compare-mem-with-reg:initialize-stmt: +14899 # var stmt/esi: (addr statement) +14900 68/push 0/imm32/next +14901 68/push 0/imm32/next +14902 68/push 0/imm32/outputs +14903 68/push 0/imm32/outputs +14904 56/push-esi/inouts +14905 68/push 0x11/imm32/alloc-id:fake +14906 68/push 0/imm32/operation +14907 68/push 0/imm32/operation +14908 68/push 1/imm32/tag:stmt1 +14909 89/<- %esi 4/r32/esp +14910 $test-compare-mem-with-reg:initialize-stmt-operation: +14911 # stmt->operation = "compare" +14912 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +14913 (copy-array Heap "compare" %eax) +14914 # convert +14915 c7 0/subop/copy *Curr-block-depth 0/imm32 +14916 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +14917 (flush _test-output-buffered-file) +14918 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14924 # check output +14925 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") +14926 # . epilogue +14927 89/<- %esp 5/r32/ebp +14928 5d/pop-to-ebp +14929 c3/return +14930 +14931 test-compare-reg-with-mem: +14932 # compare var1/eax, var2 +14933 # => +14934 # 3b/compare<- *(ebp+___) 0/r32/eax +14935 # +14936 # . prologue +14937 55/push-ebp +14938 89/<- %ebp 4/r32/esp +14939 # setup +14940 (clear-stream _test-output-stream) +14941 (clear-stream $_test-output-buffered-file->buffer) +14942 $test-compare-reg-with-mem:initialize-type: +14943 # var type/ecx: (payload tree type-id) = int +14944 68/push 0/imm32/right:null +14945 68/push 0/imm32/right:null +14946 68/push 0/imm32/left:unused +14947 68/push 1/imm32/value:int +14948 68/push 1/imm32/is-atom?:true +14949 68/push 0x11/imm32/alloc-id:fake:payload +14950 89/<- %ecx 4/r32/esp +14951 $test-compare-reg-with-mem:initialize-var1: +14952 # var var1/ecx: (payload var) +14953 68/push 0/imm32/register +14954 68/push 0/imm32/register +14955 68/push 0/imm32/no-stack-offset +14956 68/push 1/imm32/block-depth +14957 51/push-ecx +14958 68/push 0x11/imm32/alloc-id:fake +14959 68/push 0/imm32/name +14960 68/push 0/imm32/name +14961 68/push 0x11/imm32/alloc-id:fake:payload +14962 89/<- %ecx 4/r32/esp +14963 $test-compare-reg-with-mem:initialize-var1-name: +14964 # var1->name = "var1" +14965 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +14966 (copy-array Heap "var1" %eax) +14967 $test-compare-reg-with-mem:initialize-var1-register: +14968 # var1->register = "eax" +14969 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +14970 (copy-array Heap "eax" %eax) +14971 $test-compare-reg-with-mem:initialize-var2: +14972 # var var2/edx: (payload var) +14973 68/push 0/imm32/register +14974 68/push 0/imm32/register +14975 68/push 8/imm32/stack-offset +14976 68/push 1/imm32/block-depth +14977 ff 6/subop/push *(ecx+0x10) +14978 68/push 0x11/imm32/alloc-id:fake +14979 68/push 0/imm32/name +14980 68/push 0/imm32/name +14981 68/push 0x11/imm32/alloc-id:fake:payload +14982 89/<- %edx 4/r32/esp +14983 $test-compare-reg-with-mem:initialize-var2-name: +14984 # var2->name = "var2" +14985 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +14986 (copy-array Heap "var2" %eax) +14987 $test-compare-reg-with-mem:initialize-inouts: +14988 # var inouts/esi: (payload stmt-var) = [var2] +14989 68/push 0/imm32/is-deref:false +14990 68/push 0/imm32/next +14991 68/push 0/imm32/next +14992 52/push-edx/var2 +14993 68/push 0x11/imm32/alloc-id:fake +14994 68/push 0x11/imm32/alloc-id:fake:payload +14995 89/<- %esi 4/r32/esp +14996 # inouts = [var1, var2] +14997 68/push 0/imm32/is-deref:false +14998 56/push-esi/next +14999 68/push 0x11/imm32/alloc-id:fake +15000 51/push-ecx/var1 +15001 68/push 0x11/imm32/alloc-id:fake +15002 68/push 0x11/imm32/alloc-id:fake:payload +15003 89/<- %esi 4/r32/esp +15004 $test-compare-reg-with-mem:initialize-stmt: +15005 # var stmt/esi: (addr statement) +15006 68/push 0/imm32/next +15007 68/push 0/imm32/next +15008 68/push 0/imm32/outputs +15009 68/push 0/imm32/outputs +15010 56/push-esi/inouts +15011 68/push 0x11/imm32/alloc-id:fake +15012 68/push 0/imm32/operation +15013 68/push 0/imm32/operation +15014 68/push 1/imm32/tag:stmt1 +15015 89/<- %esi 4/r32/esp +15016 $test-compare-reg-with-mem:initialize-stmt-operation: +15017 # stmt->operation = "compare" +15018 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15019 (copy-array Heap "compare" %eax) +15020 # convert +15021 c7 0/subop/copy *Curr-block-depth 0/imm32 +15022 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +15023 (flush _test-output-buffered-file) +15024 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15030 # check output +15031 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") +15032 # . epilogue +15033 89/<- %esp 5/r32/ebp +15034 5d/pop-to-ebp +15035 c3/return +15036 +15037 test-compare-mem-with-literal: +15038 # compare var1, 0x34 +15039 # => +15040 # 81 7/subop/compare *(ebp+___) 0x34/imm32 +15041 # +15042 # . prologue +15043 55/push-ebp +15044 89/<- %ebp 4/r32/esp +15045 # setup +15046 (clear-stream _test-output-stream) +15047 (clear-stream $_test-output-buffered-file->buffer) +15048 $test-compare-mem-with-literal:initialize-type: +15049 # var type/ecx: (payload tree type-id) = int +15050 68/push 0/imm32/right:null +15051 68/push 0/imm32/right:null +15052 68/push 0/imm32/left:unused +15053 68/push 1/imm32/value:int +15054 68/push 1/imm32/is-atom?:true +15055 68/push 0x11/imm32/alloc-id:fake:payload +15056 89/<- %ecx 4/r32/esp +15057 $test-compare-mem-with-literal:initialize-var1: +15058 # var var1/ecx: (payload var) +15059 68/push 0/imm32/register +15060 68/push 0/imm32/register +15061 68/push 8/imm32/stack-offset +15062 68/push 1/imm32/block-depth +15063 51/push-ecx +15064 68/push 0x11/imm32/alloc-id:fake +15065 68/push 0/imm32/name +15066 68/push 0/imm32/name +15067 68/push 0x11/imm32/alloc-id:fake:payload +15068 89/<- %ecx 4/r32/esp +15069 $test-compare-mem-with-literal:initialize-var1-name: +15070 # var1->name = "var1" +15071 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +15072 (copy-array Heap "var1" %eax) +15073 $test-compare-mem-with-literal:initialize-literal-type: +15074 # var type/edx: (payload tree type-id) = literal +15075 68/push 0/imm32/right:null +15076 68/push 0/imm32/right:null +15077 68/push 0/imm32/left:unused +15078 68/push 0/imm32/value:literal +15079 68/push 1/imm32/is-atom?:true +15080 68/push 0x11/imm32/alloc-id:fake:payload +15081 89/<- %edx 4/r32/esp +15082 $test-compare-mem-with-literal:initialize-literal: +15083 # var l/edx: (payload var) +15084 68/push 0/imm32/register +15085 68/push 0/imm32/register +15086 68/push 0/imm32/no-stack-offset +15087 68/push 1/imm32/block-depth +15088 52/push-edx +15089 68/push 0x11/imm32/alloc-id:fake +15090 68/push 0/imm32/name +15091 68/push 0/imm32/name +15092 68/push 0x11/imm32/alloc-id:fake:payload +15093 89/<- %edx 4/r32/esp +15094 $test-compare-mem-with-literal:initialize-literal-value: +15095 # l->name = "0x34" +15096 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +15097 (copy-array Heap "0x34" %eax) +15098 $test-compare-mem-with-literal:initialize-inouts: +15099 # var inouts/esi: (payload stmt-var) = [l] +15100 68/push 0/imm32/is-deref:false +15101 68/push 0/imm32/next +15102 68/push 0/imm32/next +15103 52/push-edx/l +15104 68/push 0x11/imm32/alloc-id:fake +15105 68/push 0x11/imm32/alloc-id:fake:payload +15106 89/<- %esi 4/r32/esp +15107 # var inouts = (handle stmt-var) = [var1, var2] +15108 68/push 0/imm32/is-deref:false +15109 56/push-esi/next +15110 68/push 0x11/imm32/alloc-id:fake +15111 51/push-ecx/var1 +15112 68/push 0x11/imm32/alloc-id:fake +15113 68/push 0x11/imm32/alloc-id:fake:payload +15114 89/<- %esi 4/r32/esp +15115 $test-compare-mem-with-literal:initialize-stmt: +15116 # var stmt/esi: (addr statement) +15117 68/push 0/imm32/next +15118 68/push 0/imm32/next +15119 68/push 0/imm32/outputs +15120 68/push 0/imm32/outputs +15121 56/push-esi/inouts +15122 68/push 0x11/imm32/alloc-id:fake +15123 68/push 0/imm32/operation +15124 68/push 0/imm32/operation +15125 68/push 1/imm32/tag:stmt1 +15126 89/<- %esi 4/r32/esp +15127 $test-compare-mem-with-literal:initialize-stmt-operation: +15128 # stmt->operation = "compare" +15129 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15130 (copy-array Heap "compare" %eax) +15131 # convert +15132 c7 0/subop/copy *Curr-block-depth 0/imm32 +15133 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +15134 (flush _test-output-buffered-file) +15135 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15141 # check output +15142 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") +15143 # . epilogue +15144 89/<- %esp 5/r32/ebp +15145 5d/pop-to-ebp +15146 c3/return +15147 +15148 test-compare-eax-with-literal: +15149 # compare var1/eax 0x34 +15150 # => +15151 # 3d/compare-eax-with 0x34/imm32 +15152 # +15153 # . prologue +15154 55/push-ebp +15155 89/<- %ebp 4/r32/esp +15156 # setup +15157 (clear-stream _test-output-stream) +15158 (clear-stream $_test-output-buffered-file->buffer) +15159 $test-compare-eax-with-literal:initialize-type: +15160 # var type/ecx: (payload tree type-id) = int +15161 68/push 0/imm32/right:null +15162 68/push 0/imm32/right:null +15163 68/push 0/imm32/left:unused +15164 68/push 1/imm32/value:int +15165 68/push 1/imm32/is-atom?:true +15166 68/push 0x11/imm32/alloc-id:fake:payload +15167 89/<- %ecx 4/r32/esp +15168 $test-compare-eax-with-literal:initialize-var1: +15169 # var var1/ecx: (payload var) +15170 68/push 0/imm32/register +15171 68/push 0/imm32/register +15172 68/push 0/imm32/no-stack-offset +15173 68/push 1/imm32/block-depth +15174 51/push-ecx +15175 68/push 0x11/imm32/alloc-id:fake +15176 68/push 0/imm32/name +15177 68/push 0/imm32/name +15178 68/push 0x11/imm32/alloc-id:fake:payload +15179 89/<- %ecx 4/r32/esp +15180 $test-compare-eax-with-literal:initialize-var1-name: +15181 # var1->name = "var1" +15182 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +15183 (copy-array Heap "var1" %eax) +15184 $test-compare-eax-with-literal:initialize-var1-register: +15185 # v->register = "eax" +15186 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +15187 (copy-array Heap "eax" %eax) +15188 $test-compare-eax-with-literal:initialize-literal-type: +15189 # var type/edx: (payload tree type-id) = literal +15190 68/push 0/imm32/right:null +15191 68/push 0/imm32/right:null +15192 68/push 0/imm32/left:unused +15193 68/push 0/imm32/value:literal +15194 68/push 1/imm32/is-atom?:true +15195 68/push 0x11/imm32/alloc-id:fake:payload +15196 89/<- %edx 4/r32/esp +15197 $test-compare-eax-with-literal:initialize-literal: +15198 # var l/edx: (payload var) +15199 68/push 0/imm32/register +15200 68/push 0/imm32/register +15201 68/push 0/imm32/no-stack-offset +15202 68/push 1/imm32/block-depth +15203 52/push-edx +15204 68/push 0x11/imm32/alloc-id:fake +15205 68/push 0/imm32/name +15206 68/push 0/imm32/name +15207 68/push 0x11/imm32/alloc-id:fake:payload +15208 89/<- %edx 4/r32/esp +15209 $test-compare-eax-with-literal:initialize-literal-value: +15210 # l->name = "0x34" +15211 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +15212 (copy-array Heap "0x34" %eax) +15213 $test-compare-eax-with-literal:initialize-inouts: +15214 # var inouts/esi: (payload stmt-var) = [l] +15215 68/push 0/imm32/is-deref:false +15216 68/push 0/imm32/next +15217 68/push 0/imm32/next +15218 52/push-edx/l +15219 68/push 0x11/imm32/alloc-id:fake +15220 68/push 0x11/imm32/alloc-id:fake:payload +15221 89/<- %esi 4/r32/esp +15222 # var inouts = (handle stmt-var) = [var1, var2] +15223 68/push 0/imm32/is-deref:false +15224 56/push-esi/next +15225 68/push 0x11/imm32/alloc-id:fake +15226 51/push-ecx/var1 +15227 68/push 0x11/imm32/alloc-id:fake +15228 68/push 0x11/imm32/alloc-id:fake:payload +15229 89/<- %esi 4/r32/esp +15230 $test-compare-eax-with-literal:initialize-stmt: +15231 # var stmt/esi: (addr statement) +15232 68/push 0/imm32/next +15233 68/push 0/imm32/next +15234 68/push 0/imm32/outputs +15235 68/push 0/imm32/outputs +15236 56/push-esi/inouts +15237 68/push 0x11/imm32/alloc-id:fake +15238 68/push 0/imm32/operation +15239 68/push 0/imm32/operation +15240 68/push 1/imm32/tag:stmt1 +15241 89/<- %esi 4/r32/esp +15242 $test-compare-eax-with-literal:initialize-stmt-operation: +15243 # stmt->operation = "compare" +15244 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15245 (copy-array Heap "compare" %eax) +15246 # convert +15247 c7 0/subop/copy *Curr-block-depth 0/imm32 +15248 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +15249 (flush _test-output-buffered-file) +15250 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15256 # check output +15257 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") +15258 # . epilogue +15259 89/<- %esp 5/r32/ebp +15260 5d/pop-to-ebp +15261 c3/return +15262 +15263 test-compare-reg-with-literal: +15264 # compare var1/ecx 0x34 +15265 # => +15266 # 81 7/subop/compare %ecx 0x34/imm32 +15267 # +15268 # . prologue +15269 55/push-ebp +15270 89/<- %ebp 4/r32/esp +15271 # setup +15272 (clear-stream _test-output-stream) +15273 (clear-stream $_test-output-buffered-file->buffer) +15274 $test-compare-reg-with-literal:initialize-type: +15275 # var type/ecx: (payload tree type-id) = int +15276 68/push 0/imm32/right:null +15277 68/push 0/imm32/right:null +15278 68/push 0/imm32/left:unused +15279 68/push 1/imm32/value:int +15280 68/push 1/imm32/is-atom?:true +15281 68/push 0x11/imm32/alloc-id:fake:payload +15282 89/<- %ecx 4/r32/esp +15283 $test-compare-reg-with-literal:initialize-var1: +15284 # var var1/ecx: (payload var) +15285 68/push 0/imm32/register +15286 68/push 0/imm32/register +15287 68/push 0/imm32/no-stack-offset +15288 68/push 1/imm32/block-depth +15289 51/push-ecx +15290 68/push 0x11/imm32/alloc-id:fake +15291 68/push 0/imm32/name +15292 68/push 0/imm32/name +15293 68/push 0x11/imm32/alloc-id:fake:payload +15294 89/<- %ecx 4/r32/esp +15295 $test-compare-reg-with-literal:initialize-var1-name: +15296 # var1->name = "var1" +15297 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +15298 (copy-array Heap "var1" %eax) +15299 $test-compare-reg-with-literal:initialize-var1-register: +15300 # v->register = "ecx" +15301 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +15302 (copy-array Heap "ecx" %eax) +15303 $test-compare-reg-with-literal:initialize-literal-type: +15304 # var type/edx: (payload tree type-id) = literal +15305 68/push 0/imm32/right:null +15306 68/push 0/imm32/right:null +15307 68/push 0/imm32/left:unused +15308 68/push 0/imm32/value:literal +15309 68/push 1/imm32/is-atom?:true +15310 68/push 0x11/imm32/alloc-id:fake:payload +15311 89/<- %edx 4/r32/esp +15312 $test-compare-reg-with-literal:initialize-literal: +15313 # var l/edx: (payload var) +15314 68/push 0/imm32/register +15315 68/push 0/imm32/register +15316 68/push 0/imm32/no-stack-offset +15317 68/push 1/imm32/block-depth +15318 52/push-edx +15319 68/push 0x11/imm32/alloc-id:fake +15320 68/push 0/imm32/name +15321 68/push 0/imm32/name +15322 68/push 0x11/imm32/alloc-id:fake:payload +15323 89/<- %edx 4/r32/esp +15324 $test-compare-reg-with-literal:initialize-literal-value: +15325 # l->name = "0x34" +15326 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +15327 (copy-array Heap "0x34" %eax) +15328 $test-compare-reg-with-literal:initialize-inouts: +15329 # var inouts/esi: (payload stmt-var) = [l] +15330 68/push 0/imm32/is-deref:false +15331 68/push 0/imm32/next +15332 68/push 0/imm32/next +15333 52/push-edx/l +15334 68/push 0x11/imm32/alloc-id:fake +15335 68/push 0x11/imm32/alloc-id:fake:payload +15336 89/<- %esi 4/r32/esp +15337 # var inouts = (handle stmt-var) = [var1, var2] +15338 68/push 0/imm32/is-deref:false +15339 56/push-esi/next +15340 68/push 0x11/imm32/alloc-id:fake +15341 51/push-ecx/var1 +15342 68/push 0x11/imm32/alloc-id:fake +15343 68/push 0x11/imm32/alloc-id:fake:payload +15344 89/<- %esi 4/r32/esp +15345 $test-compare-reg-with-literal:initialize-stmt: +15346 # var stmt/esi: (addr statement) +15347 68/push 0/imm32/next +15348 68/push 0/imm32/next +15349 68/push 0/imm32/outputs +15350 68/push 0/imm32/outputs +15351 56/push-esi/inouts +15352 68/push 0x11/imm32/alloc-id:fake +15353 68/push 0/imm32/operation +15354 68/push 0/imm32/operation +15355 68/push 1/imm32/tag:stmt1 +15356 89/<- %esi 4/r32/esp +15357 $test-compare-reg-with-literal:initialize-stmt-operation: +15358 # stmt->operation = "compare" +15359 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15360 (copy-array Heap "compare" %eax) +15361 # convert +15362 c7 0/subop/copy *Curr-block-depth 0/imm32 +15363 (emit-subx-stmt _test-output-buffered-file %esi Primitives) +15364 (flush _test-output-buffered-file) +15365 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15371 # check output +15372 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") +15373 # . epilogue +15374 89/<- %esp 5/r32/ebp +15375 5d/pop-to-ebp +15376 c3/return +15377 +15378 test-emit-subx-stmt-function-call: +15379 # Call a function on a variable on the stack. +15380 # f foo +15381 # => +15382 # (f *(ebp-8)) +15383 # (Changing the function name supports overloading in general, but here it +15384 # just serves to help disambiguate things.) 15385 # -15386 # We don't perform any checking here on the type of 'f'. -15387 # -15388 # . prologue -15389 55/push-ebp -15390 89/<- %ebp 4/r32/esp -15391 # setup -15392 (clear-stream _test-output-stream) -15393 (clear-stream $_test-output-buffered-file->buffer) -15394 $test-emit-subx-function-call:initialize-type: -15395 # var type/ecx: (payload tree type-id) = int -15396 68/push 0/imm32/right:null -15397 68/push 0/imm32/right:null -15398 68/push 0/imm32/left:unused -15399 68/push 1/imm32/value:int -15400 68/push 1/imm32/is-atom?:true -15401 68/push 0x11/imm32/alloc-id:fake:payload -15402 89/<- %ecx 4/r32/esp -15403 $test-emit-subx-function-call:initialize-var: -15404 # var var-foo/ecx: (payload var) = var(type) -15405 68/push 0/imm32/no-register -15406 68/push 0/imm32/no-register -15407 68/push -8/imm32/stack-offset -15408 68/push 1/imm32/block-depth -15409 51/push-ecx/type -15410 68/push 0x11/imm32/alloc-id:fake -15411 68/push 0/imm32/name -15412 68/push 0/imm32/name -15413 68/push 0x11/imm32/alloc-id:fake:payload -15414 89/<- %ecx 4/r32/esp -15415 $test-emit-subx-function-call:initialize-var-name: -15416 # var-foo->name = "foo" -15417 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -15418 (copy-array Heap "foo" %eax) -15419 $test-emit-subx-function-call:initialize-stmt-var: -15420 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -15421 68/push 0/imm32/is-deref:false -15422 68/push 0/imm32/next -15423 68/push 0/imm32/next -15424 51/push-ecx/var-foo -15425 68/push 0x11/imm32/alloc-id:fake -15426 68/push 0x11/imm32/alloc-id:fake:payload -15427 89/<- %ebx 4/r32/esp -15428 $test-emit-subx-function-call:initialize-stmt: -15429 # var stmt/esi: (addr statement) -15430 68/push 0/imm32/no-outputs -15431 68/push 0/imm32/no-outputs -15432 53/push-ebx/inouts -15433 68/push 0x11/imm32/alloc-id:fake -15434 68/push 0/imm32/operation -15435 68/push 0/imm32/operation -15436 68/push 1/imm32/tag -15437 89/<- %esi 4/r32/esp -15438 $test-emit-subx-function-call:initialize-stmt-operation: -15439 # stmt->operation = "f" -15440 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15441 (copy-array Heap "f" %eax) -15442 # convert -15443 c7 0/subop/copy *Curr-block-depth 0/imm32 -15444 (emit-subx-stmt _test-output-buffered-file %esi 0) -15445 (flush _test-output-buffered-file) -15446 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15452 # check output -15453 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") -15454 # . epilogue -15455 89/<- %esp 5/r32/ebp -15456 5d/pop-to-ebp -15457 c3/return -15458 -15459 test-emit-subx-stmt-function-call-with-literal-arg: -15460 # Call a function on a literal. -15461 # f 0x34 -15462 # => -15463 # (f2 0x34) -15464 # -15465 # . prologue -15466 55/push-ebp -15467 89/<- %ebp 4/r32/esp -15468 # setup -15469 (clear-stream _test-output-stream) -15470 (clear-stream $_test-output-buffered-file->buffer) -15471 $test-emit-subx-function-call-with-literal-arg:initialize-type: -15472 # var type/ecx: (payload tree type-id) = int -15473 68/push 0/imm32/right:null -15474 68/push 0/imm32/right:null -15475 68/push 0/imm32/left:unused -15476 68/push 0/imm32/value:literal -15477 68/push 1/imm32/is-atom?:true -15478 68/push 0x11/imm32/alloc-id:fake:payload -15479 89/<- %ecx 4/r32/esp -15480 $test-emit-subx-function-call-with-literal-arg:initialize-var: -15481 # var var-foo/ecx: (payload var) = var(lit) -15482 68/push 0/imm32/no-register -15483 68/push 0/imm32/no-register -15484 68/push 0/imm32/no-stack-offset -15485 68/push 1/imm32/block-depth -15486 51/push-ecx/type -15487 68/push 0x11/imm32/alloc-id:fake -15488 68/push 0/imm32/name -15489 68/push 0/imm32/name -15490 68/push 0x11/imm32/alloc-id:fake:payload -15491 89/<- %ecx 4/r32/esp -15492 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: -15493 # var-foo->name = "0x34" -15494 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -15495 (copy-array Heap "0x34" %eax) -15496 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: -15497 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -15498 68/push 0/imm32/is-deref:false -15499 68/push 0/imm32/next -15500 68/push 0/imm32/next -15501 51/push-ecx/var-foo -15502 68/push 0x11/imm32/alloc-id:fake -15503 68/push 0x11/imm32/alloc-id:fake:payload -15504 89/<- %ebx 4/r32/esp -15505 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: -15506 # var stmt/esi: (addr statement) -15507 68/push 0/imm32/no-outputs -15508 68/push 0/imm32/no-outputs -15509 53/push-ebx/inouts -15510 68/push 0x11/imm32/alloc-id:fake -15511 68/push 0/imm32/operation -15512 68/push 0/imm32/operation -15513 68/push 1/imm32/tag -15514 89/<- %esi 4/r32/esp -15515 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: -15516 # stmt->operation = "f" -15517 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -15518 (copy-array Heap "f" %eax) -15519 # convert -15520 c7 0/subop/copy *Curr-block-depth 0/imm32 -15521 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx) -15522 (flush _test-output-buffered-file) -15523 +-- 6 lines: #? # dump _test-output-stream ----------------------------------------------------------------------------------------------------------------------------------------- -15529 # check output -15530 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") -15531 # . epilogue -15532 89/<- %esp 5/r32/ebp -15533 5d/pop-to-ebp -15534 c3/return -15535 -15536 emit-indent: # out: (addr buffered-file), n: int -15537 # . prologue -15538 55/push-ebp -15539 89/<- %ebp 4/r32/esp -15540 # . save registers -15541 50/push-eax -15542 # var i/eax: int = n -15543 8b/-> *(ebp+0xc) 0/r32/eax -15544 { -15545 # if (i <= 0) break -15546 3d/compare-eax-with 0/imm32 -15547 7e/jump-if-<= break/disp8 -15548 (write-buffered *(ebp+8) " ") -15549 48/decrement-eax -15550 eb/jump loop/disp8 -15551 } -15552 $emit-indent:end: -15553 # . restore registers -15554 58/pop-to-eax -15555 # . epilogue -15556 89/<- %esp 5/r32/ebp -15557 5d/pop-to-ebp -15558 c3/return -15559 -15560 emit-subx-prologue: # out: (addr buffered-file) -15561 # . prologue -15562 55/push-ebp -15563 89/<- %ebp 4/r32/esp -15564 # -15565 (write-buffered *(ebp+8) " # . prologue\n") -15566 (write-buffered *(ebp+8) " 55/push-ebp\n") -15567 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") -15568 $emit-subx-prologue:end: -15569 # . epilogue -15570 89/<- %esp 5/r32/ebp -15571 5d/pop-to-ebp -15572 c3/return -15573 -15574 emit-subx-epilogue: # out: (addr buffered-file) -15575 # . prologue -15576 55/push-ebp -15577 89/<- %ebp 4/r32/esp -15578 # -15579 (write-buffered *(ebp+8) " # . epilogue\n") -15580 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") -15581 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") -15582 (write-buffered *(ebp+8) " c3/return\n") -15583 $emit-subx-epilogue:end: -15584 # . epilogue -15585 89/<- %esp 5/r32/ebp -15586 5d/pop-to-ebp -15587 c3/return +15386 # There's a variable on the var stack as follows: +15387 # name: 'foo' +15388 # type: int +15389 # stack-offset: -8 +15390 # +15391 # There's nothing in primitives. +15392 # +15393 # We don't perform any checking here on the type of 'f'. +15394 # +15395 # . prologue +15396 55/push-ebp +15397 89/<- %ebp 4/r32/esp +15398 # setup +15399 (clear-stream _test-output-stream) +15400 (clear-stream $_test-output-buffered-file->buffer) +15401 $test-emit-subx-function-call:initialize-type: +15402 # var type/ecx: (payload tree type-id) = int +15403 68/push 0/imm32/right:null +15404 68/push 0/imm32/right:null +15405 68/push 0/imm32/left:unused +15406 68/push 1/imm32/value:int +15407 68/push 1/imm32/is-atom?:true +15408 68/push 0x11/imm32/alloc-id:fake:payload +15409 89/<- %ecx 4/r32/esp +15410 $test-emit-subx-function-call:initialize-var: +15411 # var var-foo/ecx: (payload var) = var(type) +15412 68/push 0/imm32/no-register +15413 68/push 0/imm32/no-register +15414 68/push -8/imm32/stack-offset +15415 68/push 1/imm32/block-depth +15416 51/push-ecx/type +15417 68/push 0x11/imm32/alloc-id:fake +15418 68/push 0/imm32/name +15419 68/push 0/imm32/name +15420 68/push 0x11/imm32/alloc-id:fake:payload +15421 89/<- %ecx 4/r32/esp +15422 $test-emit-subx-function-call:initialize-var-name: +15423 # var-foo->name = "foo" +15424 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +15425 (copy-array Heap "foo" %eax) +15426 $test-emit-subx-function-call:initialize-stmt-var: +15427 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +15428 68/push 0/imm32/is-deref:false +15429 68/push 0/imm32/next +15430 68/push 0/imm32/next +15431 51/push-ecx/var-foo +15432 68/push 0x11/imm32/alloc-id:fake +15433 68/push 0x11/imm32/alloc-id:fake:payload +15434 89/<- %ebx 4/r32/esp +15435 $test-emit-subx-function-call:initialize-stmt: +15436 # var stmt/esi: (addr statement) +15437 68/push 0/imm32/no-outputs +15438 68/push 0/imm32/no-outputs +15439 53/push-ebx/inouts +15440 68/push 0x11/imm32/alloc-id:fake +15441 68/push 0/imm32/operation +15442 68/push 0/imm32/operation +15443 68/push 1/imm32/tag +15444 89/<- %esi 4/r32/esp +15445 $test-emit-subx-function-call:initialize-stmt-operation: +15446 # stmt->operation = "f" +15447 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15448 (copy-array Heap "f" %eax) +15449 # convert +15450 c7 0/subop/copy *Curr-block-depth 0/imm32 +15451 (emit-subx-stmt _test-output-buffered-file %esi 0) +15452 (flush _test-output-buffered-file) +15453 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15459 # check output +15460 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") +15461 # . epilogue +15462 89/<- %esp 5/r32/ebp +15463 5d/pop-to-ebp +15464 c3/return +15465 +15466 test-emit-subx-stmt-function-call-with-literal-arg: +15467 # Call a function on a literal. +15468 # f 0x34 +15469 # => +15470 # (f2 0x34) +15471 # +15472 # . prologue +15473 55/push-ebp +15474 89/<- %ebp 4/r32/esp +15475 # setup +15476 (clear-stream _test-output-stream) +15477 (clear-stream $_test-output-buffered-file->buffer) +15478 $test-emit-subx-function-call-with-literal-arg:initialize-type: +15479 # var type/ecx: (payload tree type-id) = int +15480 68/push 0/imm32/right:null +15481 68/push 0/imm32/right:null +15482 68/push 0/imm32/left:unused +15483 68/push 0/imm32/value:literal +15484 68/push 1/imm32/is-atom?:true +15485 68/push 0x11/imm32/alloc-id:fake:payload +15486 89/<- %ecx 4/r32/esp +15487 $test-emit-subx-function-call-with-literal-arg:initialize-var: +15488 # var var-foo/ecx: (payload var) = var(lit) +15489 68/push 0/imm32/no-register +15490 68/push 0/imm32/no-register +15491 68/push 0/imm32/no-stack-offset +15492 68/push 1/imm32/block-depth +15493 51/push-ecx/type +15494 68/push 0x11/imm32/alloc-id:fake +15495 68/push 0/imm32/name +15496 68/push 0/imm32/name +15497 68/push 0x11/imm32/alloc-id:fake:payload +15498 89/<- %ecx 4/r32/esp +15499 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: +15500 # var-foo->name = "0x34" +15501 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +15502 (copy-array Heap "0x34" %eax) +15503 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: +15504 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +15505 68/push 0/imm32/is-deref:false +15506 68/push 0/imm32/next +15507 68/push 0/imm32/next +15508 51/push-ecx/var-foo +15509 68/push 0x11/imm32/alloc-id:fake +15510 68/push 0x11/imm32/alloc-id:fake:payload +15511 89/<- %ebx 4/r32/esp +15512 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: +15513 # var stmt/esi: (addr statement) +15514 68/push 0/imm32/no-outputs +15515 68/push 0/imm32/no-outputs +15516 53/push-ebx/inouts +15517 68/push 0x11/imm32/alloc-id:fake +15518 68/push 0/imm32/operation +15519 68/push 0/imm32/operation +15520 68/push 1/imm32/tag +15521 89/<- %esi 4/r32/esp +15522 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: +15523 # stmt->operation = "f" +15524 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +15525 (copy-array Heap "f" %eax) +15526 # convert +15527 c7 0/subop/copy *Curr-block-depth 0/imm32 +15528 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx) +15529 (flush _test-output-buffered-file) +15530 +-- 6 lines: #? # dump _test-output-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +15536 # check output +15537 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") +15538 # . epilogue +15539 89/<- %esp 5/r32/ebp +15540 5d/pop-to-ebp +15541 c3/return +15542 +15543 emit-indent: # out: (addr buffered-file), n: int +15544 # . prologue +15545 55/push-ebp +15546 89/<- %ebp 4/r32/esp +15547 # . save registers +15548 50/push-eax +15549 # var i/eax: int = n +15550 8b/-> *(ebp+0xc) 0/r32/eax +15551 { +15552 # if (i <= 0) break +15553 3d/compare-eax-with 0/imm32 +15554 7e/jump-if-<= break/disp8 +15555 (write-buffered *(ebp+8) " ") +15556 48/decrement-eax +15557 eb/jump loop/disp8 +15558 } +15559 $emit-indent:end: +15560 # . restore registers +15561 58/pop-to-eax +15562 # . epilogue +15563 89/<- %esp 5/r32/ebp +15564 5d/pop-to-ebp +15565 c3/return +15566 +15567 emit-subx-prologue: # out: (addr buffered-file) +15568 # . prologue +15569 55/push-ebp +15570 89/<- %ebp 4/r32/esp +15571 # +15572 (write-buffered *(ebp+8) " # . prologue\n") +15573 (write-buffered *(ebp+8) " 55/push-ebp\n") +15574 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") +15575 $emit-subx-prologue:end: +15576 # . epilogue +15577 89/<- %esp 5/r32/ebp +15578 5d/pop-to-ebp +15579 c3/return +15580 +15581 emit-subx-epilogue: # out: (addr buffered-file) +15582 # . prologue +15583 55/push-ebp +15584 89/<- %ebp 4/r32/esp +15585 # +15586 (write-buffered *(ebp+8) " # . epilogue\n") +15587 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") +15588 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") +15589 (write-buffered *(ebp+8) " c3/return\n") +15590 $emit-subx-epilogue:end: +15591 # . epilogue +15592 89/<- %esp 5/r32/ebp +15593 5d/pop-to-ebp +15594 c3/return -- cgit 1.4.1-2-gfad0